@applicaster/zapp-react-native-utils 16.0.0-alpha.4004661200 → 16.0.0-alpha.4065452341

package/reactHooks/navigation/__tests__/usePresentScreen.test.ts

@@ -0,0 +1,154 @@
+import { modalStore } from "../../../modalState";
+import { isWeb } from "../../../reactUtils";
+import { presentScreen } from "../usePresentScreen";
+
+jest.mock("../../../reactUtils", () => ({
+  ...jest.requireActual("../../../reactUtils"),
+  isWeb: jest.fn(() => false),
+}));
+
+const river = { id: "river-parent-lock", type: "parent_lock" } as any;
+
+const rivers = { "river-parent-lock": river };
+
+const contentTypes = { parent_lock: { screen_id: "river-parent-lock" } };
+
+const present = (args = {}) =>
+  presentScreen({ typeMapping: "parent_lock", rivers, contentTypes, ...args });
+
+const modalState = () => modalStore.getState().modalState;
+
+const screenCallback = () => modalState().props?.resultCallback as hookCallback;
+
+describe("presentScreen", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (isWeb as jest.Mock).mockReturnValue(false);
+    modalStore.getState().dismissModal();
+  });
+
+  it("opens a modal with the river resolved from typeMapping", () => {
+    void present();
+
+    expect(modalState().visible).toBe(true);
+    expect(modalState().screen).toBe(river);
+  });
+
+  it("resolves with success when the presented screen reports success", async () => {
+    const result = present();
+
+    screenCallback()({ success: true, payload: { verified: true } });
+
+    await expect(result).resolves.toMatchObject({
+      success: true,
+      cancelled: false,
+      payload: { verified: true },
+    });
+  });
+
+  it("dismisses the modal once the presented screen reports a result", async () => {
+    const result = present();
+
+    screenCallback()({ success: true, payload: {} });
+    await result;
+
+    expect(modalState().visible).toBe(false);
+  });
+
+  it("resolves as cancelled when the modal is dismissed without a result", async () => {
+    const result = present();
+
+    // What the hardware back button does: RN Modal's onRequestClose resets modal state.
+    modalStore.getState().dismissModal();
+
+    await expect(result).resolves.toMatchObject({
+      success: false,
+      cancelled: true,
+    });
+  });
+
+  it("resolves as cancelled when the presented screen reports cancellation", async () => {
+    const result = present();
+
+    screenCallback()({ success: false, payload: {}, cancelled: true });
+
+    await expect(result).resolves.toMatchObject({
+      success: false,
+      cancelled: true,
+    });
+  });
+
+  it("resolves as cancelled when another modal replaces the presented screen", async () => {
+    const result = present();
+
+    modalStore.getState().openModal({ item: { id: "other-modal" } as any });
+
+    await expect(result).resolves.toMatchObject({ cancelled: true });
+  });
+
+  it("leaves the modal that replaced the presented screen open", async () => {
+    const result = present();
+    const other = { id: "other-modal" } as any;
+
+    modalStore.getState().openModal({ item: other });
+    await result;
+
+    expect(modalState().screen).toBe(other);
+    expect(modalState().visible).toBe(true);
+  });
+
+  it("ignores a result reported after the modal was already cancelled", async () => {
+    const result = present();
+    const callback = screenCallback();
+
+    modalStore.getState().dismissModal();
+    callback({ success: true, payload: {} });
+
+    await expect(result).resolves.toMatchObject({
+      success: false,
+      cancelled: true,
+    });
+  });
+
+  it("hands the entry to the ModalProvider so it reaches ScreenDataContext", () => {
+    const entry = { id: "entry-1", type: { value: "video" } } as any;
+
+    void present({ entry });
+
+    expect(modalState().props?.entry).toBe(entry);
+  });
+
+  it("omits the entry when the screen is presented without one", () => {
+    void present();
+
+    expect(modalState().props).not.toHaveProperty("entry");
+  });
+
+  it("fails without opening a modal when typeMapping has no content type", async () => {
+    const result = await present({ typeMapping: "unmapped" });
+
+    expect(result).toMatchObject({ success: false, cancelled: false });
+    expect(result.error).toEqual(expect.any(String));
+    expect(modalState().visible).toBe(false);
+  });
+
+  it("fails without opening a modal when the content type resolves to a missing river", async () => {
+    const result = await present({
+      contentTypes: { parent_lock: { screen_id: "gone" } },
+    });
+
+    expect(result).toMatchObject({ success: false, cancelled: false });
+    expect(result.error).toEqual(expect.any(String));
+    expect(modalState().visible).toBe(false);
+  });
+
+  it("fails without opening a modal on web, where no modal host exists", async () => {
+    (isWeb as jest.Mock).mockReturnValue(true);
+
+    const result = await present();
+
+    expect(result).toMatchObject({ success: false, cancelled: false });
+    expect(result.error).toEqual(expect.any(String));
+    expect(modalState().visible).toBe(false);
+  });
+});

package/reactHooks/navigation/index.ts

@@ -22,6 +22,8 @@ import { useLayoutVersion } from "../layout";
 
 export { useNavigation } from "./useNavigation";
 
+export { usePresentScreen, presentScreen } from "./usePresentScreen";
+
 export { useRoute } from "./useRoute";
 
 export { usePathname } from "./usePathname";

package/reactHooks/navigation/usePresentScreen.ts

@@ -0,0 +1,157 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { useCallback } from "react";
+
+import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
+
+import { modalStore } from "../../modalState";
+import { isWeb } from "../../reactUtils";
+import { createLogger } from "../../logger";
+import { useRivers } from "../state";
+
+const { log_error, log_info } = createLogger({
+  subsystem: "usePresentScreen",
+  category: "General",
+});
+
+export interface PresentScreenArgs {
+  /** The screen type to present (from content types mapping) */
+  typeMapping: string;
+
+  /** Entry to present the screen with. Omit to present the screen on its own. */
+  entry?: ZappEntry;
+}
+
+export interface PresentScreenResult {
+  /** The presented screen completed successfully */
+  success: boolean;
+
+  /** The presented screen was dismissed without completing (e.g. the back button) */
+  cancelled: boolean;
+
+  /** Set when the screen could not be presented at all */
+  error?: string;
+
+  /** Whatever the presented screen reported back */
+  payload?: unknown;
+}
+
+export type PresentScreenFn = (
+  args: PresentScreenArgs
+) => Promise<PresentScreenResult>;
+
+interface Dependencies {
+  rivers: Record<string, ZappRiver>;
+  contentTypes: ZappContentTypes;
+}
+
+const failure = (error: string): Promise<PresentScreenResult> => {
+  log_error(`presentScreen: ${error}`);
+
+  return Promise.resolve({ success: false, cancelled: false, error });
+};
+
+/**
+ * Presents a screen as a modal and resolves once that screen reports a result
+ * or is dismissed.
+ *
+ * The screen is rendered by the ModalProvider through the regular ScreenResolver,
+ * so it receives the `resultCallback` we pass here as its `callback` prop — the
+ * same channel hook screens already use to report success and cancellation.
+ */
+export const presentScreen = ({
+  typeMapping,
+  entry,
+  rivers,
+  contentTypes,
+}: PresentScreenArgs & Dependencies): Promise<PresentScreenResult> => {
+  if (!typeMapping) {
+    return failure("typeMapping option is missing");
+  }
+
+  // The web ModalProvider renders nothing, so no result could ever arrive and
+  // awaiting one would stall the caller indefinitely.
+  if (isWeb()) {
+    return failure("screens can not be presented as modals on web");
+  }
+
+  const screenId = contentTypes?.[typeMapping]?.screen_id;
+
+  if (!screenId) {
+    return failure(`can not resolve screen type mapping: ${typeMapping}`);
+  }
+
+  const river = rivers?.[screenId];
+
+  if (!river) {
+    return failure(`can not resolve river for screen id: ${screenId}`);
+  }
+
+  return new Promise<PresentScreenResult>((resolve) => {
+    let settled = false;
+    let unsubscribe: () => void = () => {};
+
+    const settle = (result: PresentScreenResult) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      unsubscribe();
+      resolve(result);
+    };
+
+    const resultCallback = ({
+      success,
+      cancelled,
+      payload,
+    }: hookCallbackArgs) =>
+      settle({ success: !!success, cancelled: !!cancelled, payload });
+
+    const props: Record<string, unknown> = { resultCallback };
+
+    if (entry) {
+      // The ModalProvider turns this into the screen's ScreenDataContext and
+      // screenData, so the presented screen reads the entry exactly as it
+      // would when navigated to.
+      props.entry = entry;
+    }
+
+    log_info(
+      `presentScreen: presenting screen type: ${typeMapping}${
+        entry ? ` with entry id: ${entry.id}` : ""
+      }`
+    );
+
+    modalStore.getState().openModal({ item: river, props });
+
+    // Covers every dismissal we do not initiate ourselves: the hardware back
+    // button (via the Modal's onRequestClose), a swipe dismiss, another modal
+    // taking our slot, or dismissModal() called from anywhere else.
+    unsubscribe = modalStore.subscribe(({ modalState }) => {
+      if (!modalState.visible || modalState.screen !== river) {
+        settle({ success: false, cancelled: true });
+      }
+    });
+  }).then((result) => {
+    // Only take down our own modal — by now something else may already own the slot.
+    if (modalStore.getState().modalState.screen === river) {
+      modalStore.getState().dismissModal();
+    }
+
+    return result;
+  });
+};
+
+/**
+ * @returns a function presenting a screen as a modal, resolving with its result.
+ */
+export const usePresentScreen = (): PresentScreenFn => {
+  const rivers = useRivers();
+  const contentTypes = useContentTypes();
+
+  return useCallback(
+    (args: PresentScreenArgs) =>
+      presentScreen({ ...args, rivers, contentTypes }),
+    [rivers, contentTypes]
+  );
+};

package/reactHooks/navigation/useRoute.ts

@@ -50,14 +50,18 @@ export const useRoute = (
   const rivers = useRivers();
   const contentTypes = useContentTypes();
 
-  const modalState = useModalStoreState();
-
-  const modalScreenData = modalState.screen;
-
+  // useRoute runs in every cell, so both modal stores are subscribed to only on
+  // the routes that actually read them. Off those routes the selectors return a
+  // stable reference, which keeps an unrelated modal opening or closing from
+  // re-rendering the whole tree.
   const hookModalScreenData = useHookModalScreenData(
     !isHookModalPathname(pathname)
   );
 
+  const modalState = useModalStoreState(!isModalPathname(pathname));
+
+  const modalScreenData = modalState.screen;
+
   const videoModalScreenData =
     navigator?.videoModalState?.item &&
     legacyScreenData(
@@ -80,7 +84,20 @@ export const useRoute = (
   // if path is hook grab screenData from screenData
 
   if (isModalPathname(pathname)) {
-    const screenData = modalScreenData ?? ({} as ZappEntry);
+    if (!modalScreenData) {
+      return { screenData: {} as ZappEntry, pathname };
+    }
+
+    // Mirror the pushed-screen shape ({ ...entry, targetScreen }) so a screen
+    // presented as a modal reads its entry the same way it would when
+    // navigated to, instead of only seeing the bare river.
+    const screenData = legacyScreenData(
+      {
+        screen: modalScreenData,
+        entry: modalState.props?.entry as NavigatorEntry,
+      },
+      plugins
+    );
 
     return { screenData, pathname };
   }