TypeScript t.t函数代码示例

export function makeInstallErrorModal(params: InstallErrorParams) {
  let buttons: IModalButtonSpec[] = [];
  let detail: ILocalizedString;
  let shouldRetry = true;
  let forceDetails = false;

  const { store, e, log, retryAction, stopAction, game } = params;
  const { i18n } = store.getState();

  const re = asRequestError(e);

  if (re) {
    switch (re.rpcError.code) {
      case messages.Code.UnsupportedPackaging: {
        const learnMore = t(i18n, ["docs.how_to_help"]);
        detail = `[${learnMore}](https://itch.io/docs/itch/integrating/quickstart.html)`;
        shouldRetry = false;
        forceDetails = true;
        break;
      }
    }
  }

  if (shouldRetry) {
    buttons = [
      ...buttons,
      {
        label: ["game.install.try_again"],
        icon: "repeat",
        action: retryAction(),
      },
    ];
  }

  buttons = [
    ...buttons,

    {
      label: ["grid.item.discard_download"],
      icon: "delete",
      action: stopAction(),
    },
    "cancel",
  ];

  return modalWidgets.showError.make({
    window: "root",
    title: ["prompt.install_error.title"],
    message: t(i18n, formatError(e)),
    detail,
    widgetParams: { rawError: e, log, forceDetails, game },
    buttons,
  });
}

  nativeWindow.on("close", (e: any) => {
    const rs = store.getState();
    if (wind === "root") {
      const prefs =
        rs.preferences || ({ closeToTray: true } as PreferencesState);

      let { closeToTray } = prefs;
      if (rs.system.macos) {
        closeToTray = true;
      }
      if (env.integrationTests) {
        // always let app close in testing
        closeToTray = false;
      }

      if (store.getState().system.quitting) {
        logger.debug("On window.close: quitting, letting it close");
        return;
      }
      if (closeToTray) {
        logger.debug("On window.close: close to tray enabled");
      } else {
        logger.debug("On window.close: close to tray disabled, quitting!");
        process.nextTick(() => {
          store.dispatch(actions.quit({}));
        });
        return;
      }

      // hide, never destroy
      e.preventDefault();
      nativeWindow.hide();

      if (!prefs.gotMinimizeNotification && !store.getState().system.macos) {
        store.dispatch(
          actions.updatePreferences({
            gotMinimizeNotification: true,
          })
        );

        const i18n = store.getState().i18n;
        store.dispatch(
          actions.notify({
            title: t(i18n, ["notification.see_you_soon.title"]),
            body: t(i18n, ["notification.see_you_soon.message"]),
          })
        );
      }
    } else {
      store.dispatch(actions.windClosed({ wind }));
    }
  });

 watcher.on(actions.statusMessage, async (store, action) => {
   const { message } = action.payload;
   const { i18n } = store.getState();
   logger.info(`Status: ${t(i18n, message)}`);
   await delay(AUTODISMISS_DELAY);
   store.dispatch(actions.dismissStatusMessage({}));
 });

function convertTemplate(
  store: Store,
  template: MenuItem[]
): MenuItemConstructorOptions[] {
  const rs = store.getState();
  const { i18n } = rs;
  const result: MenuItemConstructorOptions[] = [];
  for (const item of template) {
    const opts: MenuItemConstructorOptions = {};
    if (item.localizedLabel) {
      opts.label = t(i18n, item.localizedLabel);
    }
    if (item.action) {
      opts.click = () => {
        store.dispatch(item.action);
      };
    }
    if (item.type) {
      opts.type = item.type;
    }
    if (item.submenu) {
      opts.submenu = convertTemplate(store, item.submenu);
    }
    if (item.accelerator) {
      opts.accelerator = item.accelerator;
    }
    result.push(opts);
  }
  return result;
}

  watcher.on(actions.addInstallLocation, async (store, action) => {
    const { window } = action.payload;
    const i18n = store.getState().i18n;
    const nativeWindow = getNativeWindow(store.getState(), window);
    if (!nativeWindow) {
      return;
    }

    const dialogOpts = {
      title: t(i18n, ["prompt.install_location_add.title"]),
      // crazy typescript workaround, avert your eyes
      properties: ["openDirectory", "createDirectory"] as (
        | "openDirectory"
        | "createDirectory")[],
    };

    const promise = new ItchPromise<string>((resolve, reject) => {
      const callback = (response: string[]) => {
        if (!response) {
          return resolve();
        }

        return resolve(response[0]);
      };
      dialog.showOpenDialog(nativeWindow, dialogOpts, callback);
    });

    const path = await promise;
    if (path) {
      await call(messages.InstallLocationsAdd, { path });
      store.dispatch(actions.installLocationsChanged({}));
    }
  });

  const visitNode = (input: MenuItem) => {
    const node = { ...input } as Electron.MenuItemConstructorOptions;
    if (node.type === "separator") {
      return node;
    }

    const { localizedLabel, role = null, enabled = true } = input;

    if (localizedLabel) {
      node.label = t(i18n, localizedLabel);
    }
    if (enabled && !node.click) {
      node.click = e => {
        const menuAction = convertMenuAction(
          wind,
          { localizedLabel, role },
          runtime
        );
        if (menuAction) {
          store.dispatch(menuAction);
        }
      };
    }

    if (node.submenu) {
      node.submenu = map(node.submenu as MenuItem[], visitNode);
    }

    return node;
  };

  watcher.on(actions.relaunchRequest, async (store, action) => {
    const rs = store.getState();
    const pkg = rs.broth.packages[rs.system.appName];
    if (pkg.stage !== "need-restart") {
      return;
    }
    const version = pkg.availableVersion;
    const restart = t(rs.i18n, ["prompt.self_update_ready.action.restart"]);

    store.dispatch(
      actions.openModal(
        modals.naked.make({
          wind: "root",
          title: ["prompt.self_update.title", { version }],
          message: ["prompt.self_update_ready.message", { restart }],
          buttons: [
            {
              label: ["prompt.self_update_ready.action.restart"],
              action: actions.relaunch({}),
            },
            {
              label: ["prompt.self_update_ready.action.snooze"],
              action: actions.closeModal({ wind: "root" }),
            },
          ],
          widgetParams: null,
        })
      )
    );
  });

  nativeWindow.on("close", (e: any) => {
    const prefs = store.getState().preferences || { closeToTray: true };

    let { closeToTray } = prefs;
    if (env.integrationTests) {
      // always let app close in testing
      closeToTray = false;
    }

    if (closeToTray) {
      logger.debug("Close to tray enabled");
    } else {
      logger.debug("Close to tray disabled, quitting!");
      process.nextTick(() => {
        store.dispatch(actions.quit({}));
      });
      return;
    }

    if (!nativeWindow.isVisible()) {
      logger.info("Main window hidden, letting it close");
      return;
    }

    if (!prefs.gotMinimizeNotification) {
      store.dispatch(
        actions.updatePreferences({
          gotMinimizeNotification: true,
        })
      );

      const i18n = store.getState().i18n;
      store.dispatch(
        actions.notify({
          title: t(i18n, ["notification.see_you_soon.title"]),
          body: t(i18n, ["notification.see_you_soon.message"]),
        })
      );
    }

    // hide, never destroy
    e.preventDefault();
    logger.info("Hiding main window");
    nativeWindow.hide();
  });

 let processItem = (i: number) => {
   let item = history[i];
   let label = item.label ? t(i18n, item.label) : item.url;
   template.push({
     localizedLabel: truncate(label, { length: 50 }),
     checked: i === currentIndex,
     action: actions.tabGoToIndex({ wind, tab, index: i }),
   });
 };

  watcher.on(actions.downloadEnded, async (store, action) => {
    const { download } = action.payload;
    if (download.error) {
      // don't show notifications for these
      return;
    }

    const prefs = store.getState().preferences || { readyNotification: true };
    const { readyNotification } = prefs;

    if (readyNotification) {
      let notificationMessage: string = null;
      let notificationOptions: any = {
        title: download.game.title,
      };

      switch (download.reason) {
        case "install":
          notificationMessage = "notification.download_installed";
          break;
        case "reinstall":
          notificationMessage = "notification.download_healed";
          break;
        case "update":
          notificationMessage = "notification.download_updated";
          break;
        case "version-switch":
          notificationMessage = "notification.download_reverted";
          notificationOptions.version = `?`;
          const { build } = download;
          if (build) {
            notificationOptions.version = `#${build.userVersion ||
              build.version}`;
          }
          break;
        default:
        // make the typescript compiler happy
      }

      if (notificationMessage) {
        const { i18n } = store.getState();
        const message = t(i18n, [notificationMessage, notificationOptions]);
        store.dispatch(
          actions.notify({
            body: message,
            onClick: actions.navigateToGame({
              window: "root",
              game: download.game,
            }),
          })
        );
      }
    }
  });