TypeScript modal-widgets.modalWidgets.naked类代码示例

  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(
        modalWidgets.naked.make({
          window: "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({ window: "root" }),
            },
          ],
          widgetParams: null,
        })
      )
    );
  });

  watcher.on(actions.showGameUpdate, async (store, action) => {
    const { update } = action.payload;
    const { game, upload } = update;
    const uploads = [upload];

    const { title } = game;

    let dialogTitle = ["pick_update_upload.single.title", { title }];
    let dialogMessage = ["pick_update_upload.single.message", { title }];
    let dialogDetail = ["pick_update_upload.single.detail"];

    const dialogButtons: IModalButtonSpec[] = [
      {
        icon: "download",
        label: ["pick_update_upload.buttons.update"],
        action: actions.queueGameUpdate({ update }),
      },
      {
        icon: "play2",
        label: ["pick_update_upload.buttons.just_launch"],
        action: actions.queueGame({ game }),
        className: "secondary",
      },
      "cancel",
    ];

    store.dispatch(
      actions.openModal(
        modalWidgets.naked.make({
          window: "root",
          title: dialogTitle,
          message: dialogMessage,
          detail: dialogDetail,
          bigButtons: map(uploads, upload => {
            const spec: IModalButtonSpec = {
              ...makeUploadButton(upload, { showSize: false }),
              action: actions.queueGameUpdate({ update }),
            };
            return spec;
          }),
          buttons: dialogButtons,
          widgetParams: null,
        })
      )
    );
  });

 async ({ params }) => {
   const res = await promisedModal(
     store,
     modalWidgets.naked.make({
       window: "root",
       title: ["preferences.scan_install_locations.confirm_import"],
       message: ["preferences.scan_install_locations.message"],
       detail: names.map(n => `  * ${n}`).join("\n") + "\n",
       widgetParams: null,
       buttons: [
         {
           label: [
             "preferences.scan_install_locations.import_items",
             { numItems: params.numItems },
           ],
           icon: "install",
           action: actions.modalResponse({}),
         },
         "cancel",
       ],
     })
   );
   return { confirm: !!res };
 }

      onError: async (e: Error, log) => {
        let title = game ? game.title : "<missing game>";

        const re = asRequestError(e);
        if (re) {
          switch (re.rpcError.code) {
            case Code.OperationAborted:
              // just ignore it
              return;

            case Code.InstallFolderDisappeared:
              // oh we can do something about that.
              store.dispatch(
                actions.openModal(
                  modalWidgets.naked.make({
                    window: "root",
                    title: ["game.install.could_not_launch", { title }],
                    coverUrl: game.coverUrl,
                    stillCoverUrl: game.stillCoverUrl,
                    message: `The folder where **${title}** was installed doesn't exist anymore.`,
                    detail: `That means we can't open it.`,
                    bigButtons: [
                      {
                        icon: "delete",
                        label: "Remove install entry",
                        tags: [{ label: "Recommended" }],
                        action: actions.queueCaveUninstall({ caveId: cave.id }),
                      },
                      {
                        icon: "folder-open",
                        label: "Open parent folder",
                        className: "secondary",
                        tags: [{ label: "Seeing is believing." }],
                        action: actions.exploreCave({ caveId: cave.id }),
                      },
                    ],
                    buttons: ["nevermind"],
                    widgetParams: null,
                  })
                )
              );
              return;
          }
        }

        await promisedModal(
          store,
          modalWidgets.showError.make({
            window: "root",
            title: ["game.install.could_not_launch", { title }],
            coverUrl: game.coverUrl,
            stillCoverUrl: game.stillCoverUrl,
            message: t(store.getState().i18n, formatError(e)),
            detail: isInternalError(e)
              ? ["game.install.could_not_launch.detail"]
              : null,
            widgetParams: { rawError: e, log, game, forceDetails: true },
            buttons: [
              {
                label: ["prompt.action.ok"],
              },
              {
                label: showInExplorerString(),
                className: "secondary",
                action: actions.exploreCave({ caveId: cave.id }),
              },
              "cancel",
            ],
          })
        );
      },