@applicaster/zapp-react-native-utils 16.0.0-alpha.2024822855 → 16.0.0-alpha.2105365027

package/actionUtils/index.ts

@@ -3,5 +3,7 @@ import { isTV } from "../reactUtils";
 
 export const resolveDefaultAssetUri = (source: string | number): string =>
   isTV()
-    ? (source as string)
+    ? typeof source === "number"
+      ? Image.resolveAssetSource(source)?.uri || ""
+      : (source as string)
     : Image.resolveAssetSource(source as number)?.uri || "";

package/actionsExecutor/ActionExecutor.ts

@@ -56,7 +56,6 @@ export class ActionExecutor {
     context?: ActionExecutionContext
   ): Promise<ActionResult> => {
     for (const action of actionTypes) {
-      // TODO: Handle action result error
       const result = await this.handleAction(action, context);
 
       if (result === ActionResult.Cancel) {
@@ -64,6 +63,16 @@ export class ActionExecutor {
 
         return result;
       }
+
+      if (result === ActionResult.Error) {
+        // Everything after a failed step was written for a state that never
+        // happened — the event was refused, the screen never opened — so
+        // running it is how a chain ends up telling the user their mail was
+        // sent when it was not.
+        log_error(`handleActions: action: ${action.type} failed`, { action });
+
+        return result;
+      }
     }
 
     return ActionResult.Success;

package/actionsExecutor/ActionExecutorContext.tsx

@@ -9,7 +9,7 @@ import { ActionExecutionContext, ActionHandler } from "./types";
 import { batchRemoveAllFromNamespaceForStorage } from "../zappFrameworkUtils/localStorageHelper";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 
-import { useNavigation, useRivers } from "../reactHooks";
+import { useNavigation, usePresentScreen, useRivers } from "../reactHooks";
 import { useContentTypes } from "@applicaster/zapp-react-native-redux/hooks";
 import { useSubscriberFor } from "../reactHooks/useSubscriberFor";
 import { APP_EVENTS } from "../appUtils/events";
@@ -18,11 +18,15 @@ import { createLogger } from "../logger";
 import {
   appRestartAction,
   confirmDialogAction,
+  showAlertAction,
+  createGoBackAction,
+  createGoHomeAction,
   createNavigateToScreenAction,
   dismissBottomSheetAction,
   localStorageRemoveAction,
   localStorageSetAction,
   localStorageToggleFlagAction,
+  createPresentScreenAction,
   openBottomSheetAction,
   refreshComponentAction,
   screenSetVariableAction,
@@ -107,6 +111,8 @@ const prepareDefaultActions = (actionExecutor) => {
     confirmDialogAction
   );
 
+  actionExecutor.registerAction(ACTION_TYPES.SHOW_ALERT, showAlertAction);
+
   actionExecutor.registerAction(
     ACTION_TYPES.SEND_CLOUD_EVENT,
     sendCloudEventAction
@@ -155,6 +161,7 @@ export function withActionExecutor(Component) {
     const navigator = useNavigation();
     const rivers = useRivers();
     const contentTypes = useContentTypes();
+    const presentScreen = usePresentScreen();
 
     const handlers = useMemo(() => {
       return {
@@ -189,6 +196,27 @@ export function withActionExecutor(Component) {
       );
     }, [navigator, rivers, contentTypes]);
 
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.PRESENT_SCREEN,
+        createPresentScreenAction(presentScreen)
+      );
+    }, [presentScreen]);
+
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.GO_BACK,
+        createGoBackAction(navigator)
+      );
+    }, [navigator]);
+
+    useEffect(() => {
+      return _actionExecutor.registerAction(
+        ACTION_TYPES.GO_HOME,
+        createGoHomeAction(navigator)
+      );
+    }, [navigator]);
+
     return (
       <ActionExecutorContext.Provider value={handlers}>
         <Component {...props} />

package/actionsExecutor/__tests__/ActionExecutor.test.ts

@@ -0,0 +1,71 @@
+import { ActionExecutor, ActionResult } from "../ActionExecutor";
+
+jest.mock("../../logger", () => ({
+  createLogger: () => ({
+    log_error: jest.fn(),
+    log_debug: jest.fn(),
+    log_info: jest.fn(),
+  }),
+}));
+
+describe("handleActions", () => {
+  const executor = () => {
+    const ran: string[] = [];
+    const actionExecutor = new ActionExecutor();
+
+    const register = (type: string, result?: ActionResult) =>
+      actionExecutor.registerAction(type, async () => {
+        ran.push(type);
+
+        return result as ActionResult;
+      });
+
+    register("ok", ActionResult.Success);
+    register("fails", ActionResult.Error);
+    register("cancels", ActionResult.Cancel);
+    register("recover", ActionResult.Success);
+    register("after", ActionResult.Success);
+
+    return { actionExecutor, ran };
+  };
+
+  // Everything after a failed step was written for a state that never
+  // happened: the event was refused, the screen never opened.
+  it("stops when an action fails", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "fails" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["fails"]);
+    expect(result).toBe(ActionResult.Error);
+  });
+
+  it("still stops on a cancel", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "cancels" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["cancels"]);
+    expect(result).toBe(ActionResult.Cancel);
+  });
+
+  // An action nobody registered never ran, which is a misconfigured feed
+  // rather than a step that failed. It is stepped over, as it always was.
+  it("steps over an action with no handler", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "nobody-registered-this" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["after"]);
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/dismissBottomSheet.test.ts

@@ -4,6 +4,9 @@ import { ActionResult } from "../../ActionExecutor";
 
 jest.mock("../../../modalState", () => ({
   dismissModal: jest.fn(),
+  modalOrchestrator: {
+    close: jest.fn(),
+  },
 }));
 
 describe("dismissBottomSheetAction", () => {

package/actionsExecutor/actions/__tests__/goBack.test.ts

@@ -0,0 +1,62 @@
+import { createGoBackAction } from "../goBack";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator(canGoBack = true) {
+  return {
+    goBack: jest.fn(),
+    canGoBack: jest.fn().mockReturnValue(canGoBack),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goBack", () => {
+  it("goes back with fallbackToHome enabled when no options are provided", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoBackAction(navigator)({ type: "goBack" });
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("forwards backToTop", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "goBack",
+      options: { backToTop: true },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, true);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("goes back without falling back to home when the stack allows it", async () => {
+    const navigator = createNavigator(true);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(false, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("does nothing when there is nothing to go back to and fallbackToHome is off", async () => {
+    const navigator = createNavigator(false);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).not.toHaveBeenCalled();
+    expect(result).toBe(ActionResult.Error);
+  });
+});

package/actionsExecutor/actions/__tests__/goHome.test.ts

@@ -0,0 +1,19 @@
+import { createGoHomeAction } from "../goHome";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator() {
+  return {
+    goHome: jest.fn(),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goHome", () => {
+  it("navigates to the home screen", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoHomeAction(navigator)({ type: "goHome" });
+
+    expect(navigator.goHome).toHaveBeenCalledWith();
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/navigateToScreen.test.ts

@@ -83,9 +83,7 @@ describe("navigateToScreen navigationOptions", () => {
     );
   });
 
-  // Entries cannot go through replace(), which only accepts a river, so the
-  // non-push path falls back to replaceTop().
-  it("forwards navigationOptions to replaceTop when navigating with an entry", async () => {
+  it("forwards navigationOptions to replace when navigating with an entry", async () => {
     const navigator = createNavigator();
     const entry = { id: "entry-id" } as unknown as ZappEntry;
 
@@ -100,12 +98,12 @@ describe("navigateToScreen navigationOptions", () => {
 
     await createNavigateToScreenAction(navigator, rivers, contentTypes)(action);
 
-    expect(navigator.replaceTop).toHaveBeenCalledWith(
+    expect(navigator.replace).toHaveBeenCalledWith(
       { id: "entry-id", type: { value: "parentLock" } },
       { pinFlow: "change-pin" }
     );
 
-    expect(navigator.replace).not.toHaveBeenCalled();
+    expect(navigator.replaceTop).not.toHaveBeenCalled();
   });
 
   // Regression guard: the no-options path must keep working unchanged.
@@ -131,3 +129,139 @@ describe("navigateToScreen navigationOptions", () => {
     expect(result).toBe(ActionResult.Success);
   });
 });
+
+describe("navigateToScreen target resolution", () => {
+  function run(options, context?) {
+    const navigator = createNavigator();
+
+    const result = createNavigateToScreenAction(
+      navigator,
+      rivers,
+      contentTypes
+    )({ type: "navigateToScreen", options }, context);
+
+    return { navigator, result };
+  }
+
+  it("overrides entry.type with typeMapping when both are provided", async () => {
+    const entry = {
+      id: "entry-id",
+      type: { value: "video" },
+    } as unknown as ZappEntry;
+
+    const { navigator, result } = run({
+      typeMapping: "parentLock",
+      navigationAction: "push",
+      entry,
+    });
+
+    expect(await result).toBe(ActionResult.Success);
+
+    expect(navigator.push).toHaveBeenCalledWith(
+      { id: "entry-id", type: { value: "parentLock" } },
+      undefined
+    );
+
+    expect(entry.type).toEqual({ value: "video" });
+  });
+
+  it("navigates with the entry's own type when typeMapping is not provided", async () => {
+    const entry = {
+      id: "entry-id",
+      type: { value: "video" },
+    } as unknown as ZappEntry;
+
+    const { navigator, result } = run({ navigationAction: "push", entry });
+
+    expect(await result).toBe(ActionResult.Success);
+
+    expect(navigator.push).toHaveBeenCalledWith(
+      { id: "entry-id", type: { value: "video" } },
+      undefined
+    );
+  });
+
+  it("resolves the context entry when entry is @{entry/} and typeMapping is not provided", async () => {
+    const entry = {
+      id: "context-entry-id",
+      type: { value: "video" },
+    } as unknown as ZappEntry;
+
+    const { navigator, result } = run({ entry: "@{entry/}" }, { entry });
+
+    expect(await result).toBe(ActionResult.Success);
+
+    expect(navigator.replace).toHaveBeenCalledWith(
+      { id: "context-entry-id", type: { value: "video" } },
+      undefined
+    );
+  });
+
+  it("returns an error when neither typeMapping nor entry type is provided", async () => {
+    const entry = { id: "entry-id" } as unknown as ZappEntry;
+
+    const { navigator, result } = run({ navigationAction: "push", entry });
+
+    expect(await result).toBe(ActionResult.Error);
+    expect(navigator.push).not.toHaveBeenCalled();
+    expect(navigator.replace).not.toHaveBeenCalled();
+  });
+
+  it("returns an error when neither typeMapping nor entry is provided", async () => {
+    const { navigator, result } = run({ navigationAction: "push" });
+
+    expect(await result).toBe(ActionResult.Error);
+    expect(navigator.push).not.toHaveBeenCalled();
+  });
+
+  it("returns an error when typeMapping has no screen_id mapping", async () => {
+    const callback = jest.fn();
+
+    const { navigator, result } = run(
+      { typeMapping: "unknownType", navigationAction: "push" },
+      { callback }
+    );
+
+    expect(await result).toBe(ActionResult.Error);
+    expect(navigator.push).not.toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("returns an error when the mapped screen_id has no river", async () => {
+    const navigator = createNavigator();
+    const callback = jest.fn();
+
+    const result = await createNavigateToScreenAction(navigator, rivers, {
+      orphan: { screen_id: "missing-screen-id" },
+    } as unknown as ZappContentTypes)(
+      {
+        type: "navigateToScreen",
+        options: { typeMapping: "orphan", navigationAction: "push" },
+      },
+      { callback }
+    );
+
+    expect(result).toBe(ActionResult.Error);
+    expect(navigator.push).not.toHaveBeenCalled();
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("aborts the action pipeline before navigating to a resolved river", async () => {
+    const callback = jest.fn();
+
+    const { navigator, result } = run(
+      { typeMapping: "parentLock" },
+      { callback }
+    );
+
+    expect(await result).toBe(ActionResult.Success);
+
+    expect(callback).toHaveBeenCalledWith({
+      success: false,
+      error: null,
+      abort: true,
+    });
+
+    expect(navigator.replace).toHaveBeenCalledWith(river, undefined);
+  });
+});

package/actionsExecutor/actions/__tests__/openBottomSheet.customContent.test.ts

@@ -60,6 +60,30 @@ describe("openBottomSheetAction custom content", () => {
     });
   });
 
+  it("passes themePluginId through to the name sheet", async () => {
+    const CustomContent = function CustomContent() {
+      return null;
+    };
+
+    await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Create New Playlist" },
+        themePluginId: "playlist-experience",
+        content: {
+          component: CustomContent,
+          props: { buttonLabel: "Create" },
+        },
+      },
+    } as any);
+
+    const args = (openBottomSheetModal as jest.Mock).mock.calls[0][0];
+
+    expect(args.modalBottomSheetContentProps.themePluginId).toBe(
+      "playlist-experience"
+    );
+  });
+
   it("returns Error when neither list data nor content.component is provided", async () => {
     const result = await openBottomSheetAction({
       type: "openBottomSheet",

package/actionsExecutor/actions/__tests__/openBottomSheet.inlineItems.test.ts

@@ -1,5 +1,5 @@
 import { openBottomSheetAction } from "../openBottomSheet";
-import { ActionResult } from "../../ActionExecutor";
+import { actionExecutor, ActionResult } from "../../ActionExecutor";
 import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
 
 jest.mock("../../../modalState/store", () => ({
@@ -77,6 +77,94 @@ describe("openBottomSheetAction inline items", () => {
     });
   });
 
+  it("opens an empty inline collection when dynamic collection options are present", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Queue" },
+        content: {
+          items: [],
+          emptyMessage: "Queued items will be added here",
+          dynamicCollection: {
+            operations: ["remove"],
+            provider: "@{provider/queue}",
+          },
+        },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Success);
+
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content.items).toEqual([]);
+    expect(menu.content.emptyMessage).toBe("Queued items will be added here");
+
+    expect(menu.content.dynamicCollection).toMatchObject({
+      operations: ["remove"],
+      provider: "@{provider/queue}",
+    });
+  });
+
+  it("accepts empty inline items when dynamic_collection_options live on extensions", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        content: {
+          items: [],
+          extensions: {
+            dynamic_collection_options: {
+              operations: "remove,reorder",
+              provider: "@{provider/offline}",
+            },
+          },
+        },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Success);
+
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content.items).toEqual([]);
+
+    expect(menu.content.dynamicCollection).toMatchObject({
+      operations: ["remove", "reorder"],
+      provider: "@{provider/offline}",
+    });
+  });
+
+  it("returns an error for an empty items array with no source", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        content: { items: [] },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Error);
+    expect(modalOrchestrator.open).not.toHaveBeenCalled();
+  });
+
+  it("forwards content.emptyMessage onto the menu", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Queue" },
+        content: {
+          items: [{ id: "t1", title: "Track 1" }],
+          emptyMessage: "Queued items will be added here",
+        },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Success);
+
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content.emptyMessage).toBe("Queued items will be added here");
+  });
+
   it("pushes a new sheet by default even when another sheet is already open", async () => {
     (modalOrchestrator as any).stackSize = 1;
 
@@ -97,4 +185,116 @@ describe("openBottomSheetAction inline items", () => {
     expect(modalOrchestrator.replace).toHaveBeenCalledTimes(1);
     expect(modalOrchestrator.open).not.toHaveBeenCalled();
   });
+
+  it("executes all actions in tap_actions when onItemPress is called", async () => {
+    const multiActionSheet = {
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Target Playlists" },
+        content: {
+          role: "collection_selector",
+          behavior: { selectMode: "none", currentSelection: [] },
+          items: [
+            {
+              id: "playlist-1",
+              title: "My Playlist",
+              extensions: {
+                tap_actions: {
+                  actions: [
+                    {
+                      type: "sendCloudEvent",
+                      options: { subject: "add_collection_to_collection" },
+                    },
+                    {
+                      type: "showToast",
+                      options: { message: "Added to playlist" },
+                    },
+                    { type: "dismissBottomSheet", options: {} },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    await openBottomSheetAction(multiActionSheet);
+
+    const [menu, onItemPress] = (modalOrchestrator.open as jest.Mock).mock
+      .calls[0];
+
+    expect(menu.content.items[0].actions).toHaveLength(3);
+
+    const handleActionsSpy = jest
+      .spyOn(actionExecutor, "handleActions")
+      .mockResolvedValue(ActionResult.Success);
+
+    await onItemPress(menu.content.items[0]);
+
+    expect(handleActionsSpy).toHaveBeenCalledWith(
+      [
+        {
+          type: "sendCloudEvent",
+          options: { subject: "add_collection_to_collection" },
+        },
+        {
+          type: "showToast",
+          options: { message: "Added to playlist" },
+        },
+        { type: "dismissBottomSheet", options: {} },
+      ],
+      expect.objectContaining({
+        entry: menu.content.items[0],
+      })
+    );
+
+    handleActionsSpy.mockRestore();
+  });
+
+  it("executes preceding actions and excludes presentSubMenu from actionExecutor", async () => {
+    const subMenuSheet = {
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Menu" },
+        content: {
+          items: [
+            {
+              id: "item-with-submenu",
+              title: "More Options",
+              extensions: {
+                tap_actions: {
+                  actions: [
+                    { type: "sendAnalytics", options: { event: "click_more" } },
+                    {
+                      type: "presentSubMenu",
+                      menu: { content: { title: "Sub Options", items: [] } },
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    await openBottomSheetAction(subMenuSheet);
+
+    const [menu, onItemPress] = (modalOrchestrator.open as jest.Mock).mock
+      .calls[0];
+
+    const handleActionsSpy = jest
+      .spyOn(actionExecutor, "handleActions")
+      .mockResolvedValue(ActionResult.Success);
+
+    await onItemPress(menu.content.items[0]);
+
+    expect(handleActionsSpy).toHaveBeenCalledWith(
+      [{ type: "sendAnalytics", options: { event: "click_more" } }],
+      expect.objectContaining({ entry: menu.content.items[0] })
+    );
+
+    handleActionsSpy.mockRestore();
+  });
 });