TypeScript modals.naked.make方法代码示例

  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,
        })
      )
    );
  });

  watcher.on(actions.requestCaveUninstall, async (store, action) => {
    const { caveId } = action.payload;

    const { cave } = await mcall(messages.FetchCave, { caveId });
    const { game } = cave;

    // FIXME: i18n - plus, that's generally bad
    const title = game ? game.title : "this";

    store.dispatch(
      actions.openModal(
        modals.naked.make({
          wind: "root",
          title: "",
          message: ["prompt.uninstall.message", { title }],
          buttons: [
            {
              label: ["prompt.uninstall.reinstall"],
              id: "modal-reinstall",
              action: actions.queueCaveReinstall({ caveId }),
              icon: "repeat",
            },
            {
              label: ["prompt.uninstall.uninstall"],
              id: "modal-uninstall",
              action: actions.queueCaveUninstall({ caveId }),
              icon: "uninstall",
            },
            "cancel",
          ],
          widgetParams: null,
        })
      )
    );
  });

  watcher.on(actions.queueGame, async (store, action) => {
    const { game, caveId } = action.payload;
    let caves: Cave[];

    if (caveId) {
      const { cave } = await mcall(messages.FetchCave, { caveId });
      if (cave) {
        caves = [cave];
      }
    } else {
      caves = (await mcall(messages.FetchCaves, {
        filters: { gameId: game.id },
      })).items;
    }

    if (isEmpty(caves)) {
      logger.info(
        `No cave for ${game.title} (#${game.id}), attempting install`
      );
      await queueInstall(store, game);
      return;
    }

    logger.info(
      `Have ${caves.length} caves for game ${game.title} (#${game.id})`
    );

    if (caves.length === 1) {
      const cave = caves[0];
      store.dispatch(actions.queueLaunch({ cave }));
      return;
    }

    store.dispatch(
      actions.openModal(
        modals.naked.make({
          wind: "root",
          title: ["prompt.launch.title", { title: game.title }],
          message: ["prompt.launch.message"],
          bigButtons: map(caves, cave => {
            return {
              ...makeUploadButton(cave.upload),
              action: actions.queueLaunch({ cave }),
            };
          }),
          buttons: ["cancel"],
          widgetParams: null,
        })
      )
    );
  });

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

    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: ModalButtonSpec[] = [
      {
        icon: "moon",
        label: ["pick_update_upload.buttons.skip_update"],
        action: actions.snoozeCave({ caveId: update.caveId }),
        className: "secondary",
      },
      {
        icon: "play2",
        label: ["pick_update_upload.buttons.just_launch"],
        action: actions.queueGame({ game }),
        className: "secondary",
      },
      "cancel",
    ];

    store.dispatch(
      actions.openModal(
        modals.naked.make({
          wind: "root",
          title: dialogTitle,
          message: dialogMessage,
          detail: dialogDetail,
          bigButtons: map(update.choices, choice => {
            const spec: ModalButtonSpec = {
              ...makeUploadButton(choice.upload, { showSize: false }),
              action: actions.queueGameUpdate({ update, choice }),
            };
            spec.tags.push({
              icon: choice.confidence > 0.5 ? "like" : "neutral",
              label: ` ${(choice.confidence * 100).toFixed()}%`,
            });
            return spec;
          }),
          buttons: dialogButtons,
          widgetParams: null,
        })
      )
    );
  });

 watcher.on(actions.changeUser, async (store, action) => {
   store.dispatch(
     actions.openModal(
       modals.naked.make({
         wind: "root",
         title: ["prompt.logout_title"],
         message: ["prompt.logout_confirm"],
         detail: ["prompt.logout_detail"],
         buttons: [
           {
             id: "modal-logout",
             label: ["prompt.logout_action"],
             action: actions.requestLogout({}),
             icon: "exit",
           },
           "cancel",
         ],
         widgetParams: null,
       })
     )
   );
 });

  watcher.on(actions.forceCloseGameRequest, async (store, action) => {
    const { game } = action.payload;

    store.dispatch(
      actions.openModal(
        modals.naked.make({
          wind: "root",
          title: ["prompt.force_close_game.title"],
          message: ["prompt.force_close_game.message", { title: game.title }],
          buttons: [
            {
              label: ["prompt.action.force_close"],
              id: "modal-force-close",
              action: actions.forceCloseGame({ gameId: game.id }),
              icon: "stop",
            },
            "nevermind",
          ],
          widgetParams: null,
        })
      )
    );
  });

            convo.on(messages.AcceptLicense, async ({ text }) => {
              const res = await promisedModal(
                store,
                modals.naked.make({
                  wind: "root",
                  title: ["prompt.sla.title"],
                  message: ["prompt.sla.message"],
                  detail: text,
                  widgetParams: {} as any,
                  buttons: [
                    {
                      label: ["prompt.sla.accept"],
                      action: actions.modalResponse({}),
                    },
                    "cancel",
                  ],
                })
              );

              if (res) {
                return { accept: true };
              }
              return { accept: false };
            });

  watcher.on(actions.removeInstallLocation, async (store, action) => {
    const { id } = action.payload;

    const { installLocations } = await mcall(messages.InstallLocationsList, {});
    if (installLocations.length <= 1) {
      // refuse to remove the last one
      return;
    }

    const { installLocation } = await mcall(messages.InstallLocationsGetByID, {
      id,
    });
    if (!installLocation) {
      return;
    }

    {
      const res = await promisedModal(
        store,
        modals.naked.make({
          wind: "root",
          title: ["prompt.install_location_remove.title"],
          message: ["prompt.install_location_remove.message"],
          detail: [
            "prompt.install_location_remove.detail",
            {
              location: installLocation.path,
            },
          ],
          buttons: [
            {
              label: ["prompt.action.confirm_removal"],
              action: actions.modalResponse({}),
            },
            "cancel",
          ],
          widgetParams: null,
        })
      );

      if (!res) {
        // modal was closed
        return;
      }

      const logger = recordingLogger(mainLogger);
      try {
        await mcall(messages.InstallLocationsRemove, { id }, convo => {
          hookLogging(convo, logger);
        });
        store.dispatch(actions.installLocationsChanged({}));
      } catch (e) {
        store.dispatch(
          actions.openModal(
            modals.showError.make({
              wind: "root",
              title: _("prompt.show_error.generic_message"),
              message: t(store.getState().i18n, formatError(e)),
              widgetParams: {
                rawError: e,
                log: logger.getLog(),
                forceDetails: true,
              },
              buttons: ["ok"],
            })
          )
        );
      }
    }
  });

      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(
                  modals.naked.make({
                    wind: "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;
          }
        }

        const res = await promisedModal(
          store,
          modals.showError.make({
            wind: "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,
              showSendReport: true,
            },
            buttons: [
              {
                label: ["prompt.action.ok"],
                action: "widgetResponse",
              },
              {
                label: showInExplorerString(),
                className: "secondary",
                action: actions.exploreCave({ caveId: cave.id }),
              },
              "cancel",
            ],
          })
        );

        if (res && res.sendReport) {
          store.dispatch(
            actions.sendFeedback({
              log: mergeLogAndError(log, e),
            })
          );
        }
      },