@applicaster/zapp-react-native-utils 16.0.0-alpha.2663208063 → 16.0.0-alpha.2710214351

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

@@ -0,0 +1,267 @@
+import { createNavigateToScreenAction } from "../navigateToScreen";
+import { ActionResult } from "../../ActionExecutor";
+
+const river = { id: "screen-id", type: "parent-lock" } as unknown as ZappRiver;
+
+const rivers = { "screen-id": river } as Record<string, ZappRiver>;
+
+const contentTypes = {
+  parentLock: { screen_id: "screen-id" },
+} as unknown as ZappContentTypes;
+
+function createNavigator() {
+  return {
+    push: jest.fn(),
+    replace: jest.fn(),
+    replaceTop: jest.fn(),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("navigateToScreen navigationOptions", () => {
+  it("forwards navigationOptions to push when navigating to a screen", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "navigateToScreen",
+      options: {
+        typeMapping: "parentLock",
+        navigationAction: "push",
+        navigationOptions: { pinFlow: "set-pin" },
+      },
+    };
+
+    const result = await createNavigateToScreenAction(
+      navigator,
+      rivers,
+      contentTypes
+    )(action);
+
+    expect(navigator.push).toHaveBeenCalledWith(river, {
+      pinFlow: "set-pin",
+    });
+
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("forwards navigationOptions to replace when navigating to a screen", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "navigateToScreen",
+      options: {
+        typeMapping: "parentLock",
+        navigationOptions: { pinFlow: "change-pin" },
+      },
+    };
+
+    await createNavigateToScreenAction(navigator, rivers, contentTypes)(action);
+
+    expect(navigator.replace).toHaveBeenCalledWith(river, {
+      pinFlow: "change-pin",
+    });
+  });
+
+  it("forwards navigationOptions to push when navigating with an entry", async () => {
+    const navigator = createNavigator();
+    const entry = { id: "entry-id" } as unknown as ZappEntry;
+
+    const action = {
+      type: "navigateToScreen",
+      options: {
+        typeMapping: "parentLock",
+        navigationAction: "push",
+        entry,
+        navigationOptions: { pinFlow: "set-pin" },
+      },
+    };
+
+    await createNavigateToScreenAction(navigator, rivers, contentTypes)(action);
+
+    expect(navigator.push).toHaveBeenCalledWith(
+      { id: "entry-id", type: { value: "parentLock" } },
+      { pinFlow: "set-pin" }
+    );
+  });
+
+  it("forwards navigationOptions to replace when navigating with an entry", async () => {
+    const navigator = createNavigator();
+    const entry = { id: "entry-id" } as unknown as ZappEntry;
+
+    const action = {
+      type: "navigateToScreen",
+      options: {
+        typeMapping: "parentLock",
+        entry,
+        navigationOptions: { pinFlow: "change-pin" },
+      },
+    };
+
+    await createNavigateToScreenAction(navigator, rivers, contentTypes)(action);
+
+    expect(navigator.replace).toHaveBeenCalledWith(
+      { id: "entry-id", type: { value: "parentLock" } },
+      { pinFlow: "change-pin" }
+    );
+
+    expect(navigator.replaceTop).not.toHaveBeenCalled();
+  });
+
+  // Regression guard: the no-options path must keep working unchanged.
+  it("still navigates when no navigationOptions are configured", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "navigateToScreen",
+      options: {
+        typeMapping: "parentLock",
+        navigationAction: "push",
+      },
+    };
+
+    const result = await createNavigateToScreenAction(
+      navigator,
+      rivers,
+      contentTypes
+    )(action);
+
+    expect(navigator.push).toHaveBeenCalledTimes(1);
+    expect((navigator.push as jest.Mock).mock.calls[0][0]).toBe(river);
+    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,7 +1,23 @@
 import { openBottomSheetAction } from "../openBottomSheet";
-import { ActionResult } from "../../ActionExecutor";
+import { actionExecutor, ActionResult } from "../../ActionExecutor";
 import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
 
+jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
+  PipesClientResponseHelper: jest.fn(() => ({ error: null })),
+  RequestBuilder: jest.fn(() => ({
+    setEntryContext: jest.fn().mockReturnThis(),
+    setScreenContext: jest.fn().mockReturnThis(),
+    setUrl: jest.fn().mockReturnThis(),
+    buildAxiosRequest: jest.fn().mockResolvedValue(undefined),
+    call: jest.fn().mockResolvedValue({
+      response: {
+        entry: [],
+        extensions: { dynamic_collection_options: { operations: "add" } },
+      },
+    }),
+  })),
+}));
+
 jest.mock("../../../modalState/store", () => ({
   openBottomSheetModal: jest.fn(),
 }));
@@ -77,6 +93,150 @@ 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("forwards content.operationButtons onto the menu", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Playlists" },
+        content: {
+          items: [{ id: "p1", title: "Playlist 1" }],
+          operationButtons: {
+            add: {
+              title: "Create New Playlist",
+              iconURL: "https://example.com/add.png",
+            },
+          },
+        },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Success);
+
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content.operationButtons).toEqual({
+      add: {
+        title: "Create New Playlist",
+        iconURL: "https://example.com/add.png",
+      },
+    });
+  });
+
+  it("preserves Add presentation when loading itemsUrl content", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        content: {
+          itemsUrl: "https://example.com/collections",
+          operationButtons: {
+            add: {
+              title: "Create Collection",
+              iconURL: "file:///bundled-add.png",
+            },
+          },
+        },
+      },
+    });
+
+    expect(result).toBe(ActionResult.Success);
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content).toMatchObject({
+      operationButtons: {
+        add: { title: "Create Collection", iconURL: "file:///bundled-add.png" },
+      },
+      dynamicCollection: { operations: ["add"] },
+    });
+  });
+
   it("pushes a new sheet by default even when another sheet is already open", async () => {
     (modalOrchestrator as any).stackSize = 1;
 
@@ -97,4 +257,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();
+  });
 });