@applicaster/zapp-react-native-utils 16.0.0-rc.8 → 16.0.0-rc.81

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__/loadItemsFromSource.test.ts

@@ -0,0 +1,88 @@
+import { loadItemsFromSource } from "../openBottomSheet";
+
+const mockCall = jest.fn();
+
+jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
+  RequestBuilder: jest.fn().mockImplementation(() => ({
+    setEntryContext: jest.fn().mockReturnThis(),
+    setScreenContext: jest.fn().mockReturnThis(),
+    setUrl: jest.fn().mockReturnThis(),
+    buildAxiosRequest: jest.fn().mockResolvedValue(undefined),
+    call: (...args: any[]) => mockCall(...args),
+  })),
+  PipesClientResponseHelper: jest.fn().mockImplementation(() => ({
+    error: null,
+  })),
+}));
+
+describe("loadItemsFromSource", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns items plus role and behavior from feed.extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "a", title: "Playlist A", media_group: [] }],
+        extensions: {
+          role: "collection_selector",
+          behavior: {
+            select_mode: "multi",
+            current_selection: ["a"],
+            selector: "extensions.tag",
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.role).toBe("collection_selector");
+
+    expect(result.behavior).toEqual({
+      selectMode: "multi",
+      currentSelection: ["a"],
+      selector: "extensions.tag",
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].isSelected).toBe(true);
+    expect(result.items[0].title).toBe("Playlist A");
+  });
+
+  it("returns undefined role/behavior when feed has no extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "1", title: "Plain", media_group: [] }],
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/plain");
+
+    expect(result.role).toBeUndefined();
+    expect(result.behavior).toBeUndefined();
+    expect(result.items).toHaveLength(1);
+  });
+
+  it("preserves events in dynamic_collection_options", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [],
+        extensions: {
+          dynamic_collection_options: {
+            operations: "add,remove",
+            events: {
+              add: [{ type: "showTextInput", options: {} }],
+            },
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.dynamicCollection?.events).toEqual({
+      add: [{ type: "showTextInput", options: {} }],
+    });
+  });
+});

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

@@ -0,0 +1,133 @@
+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" }
+    );
+  });
+
+  // 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 () => {
+    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.replaceTop).toHaveBeenCalledWith(
+      { id: "entry-id", type: { value: "parentLock" } },
+      { pinFlow: "change-pin" }
+    );
+
+    expect(navigator.replace).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);
+  });
+});

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

@@ -0,0 +1,76 @@
+import { openBottomSheetAction } from "../openBottomSheet";
+import { ActionResult } from "../../ActionExecutor";
+import { openBottomSheetModal } from "../../../modalState/store";
+import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
+
+jest.mock("../../../modalState/store", () => ({
+  openBottomSheetModal: jest.fn(),
+}));
+
+jest.mock("../../../modalState/ModalOrchestrator", () => ({
+  modalOrchestrator: {
+    open: jest.fn(),
+  },
+  isPresentSubMenuAction: jest.requireActual("../../../modalState/types")
+    .isPresentSubMenuAction,
+}));
+
+describe("openBottomSheetAction custom content", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("opens default sheet with contentComponent body props", async () => {
+    const CustomContent = function CustomContent() {
+      return null;
+    };
+
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Create Playlist" },
+        content: {
+          component: CustomContent,
+          props: {
+            inputLabel: "Name your playlist",
+            buttonLabel: "Create",
+            defaultValue: "",
+            submitAction: { type: "sendCloudEvent", options: {} },
+          },
+        },
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Success);
+    expect(openBottomSheetModal).toHaveBeenCalledTimes(1);
+    expect(modalOrchestrator.open).not.toHaveBeenCalled();
+
+    const args = (openBottomSheetModal as jest.Mock).mock.calls[0][0];
+    // Default ModalComponent provides the standard header
+    expect(args.ModalBottomSheetContent).toBeUndefined();
+
+    expect(args.modalBottomSheetContentProps).toMatchObject({
+      title: "Create Playlist",
+      contentComponent: CustomContent,
+      contentComponentProps: {
+        inputLabel: "Name your playlist",
+        buttonLabel: "Create",
+        defaultValue: "",
+      },
+    });
+  });
+
+  it("returns Error when neither list data nor content.component is provided", async () => {
+    const result = await openBottomSheetAction({
+      type: "openBottomSheet",
+      options: {
+        header: { title: "Empty" },
+        content: {},
+      },
+    } as any);
+
+    expect(result).toBe(ActionResult.Error);
+    expect(openBottomSheetModal).not.toHaveBeenCalled();
+    expect(modalOrchestrator.open).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,212 @@
+import { openBottomSheetAction } from "../openBottomSheet";
+import { actionExecutor, ActionResult } from "../../ActionExecutor";
+import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
+
+jest.mock("../../../modalState/store", () => ({
+  openBottomSheetModal: jest.fn(),
+}));
+
+jest.mock("../../../modalState/ModalOrchestrator", () => ({
+  modalOrchestrator: {
+    open: jest.fn(),
+    replace: jest.fn(),
+    stackSize: 0,
+  },
+  isPresentSubMenuAction: jest.requireActual("../../../modalState/types")
+    .isPresentSubMenuAction,
+}));
+
+describe("openBottomSheetAction inline items", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (modalOrchestrator as any).stackSize = 0;
+  });
+
+  const speedSheetAction = {
+    type: "openBottomSheet",
+    options: {
+      header: { title: "Playback Speed" },
+      content: {
+        role: "collection_selector",
+        behavior: {
+          selectMode: "single",
+          currentSelection: ["1"],
+        },
+        items: [
+          {
+            id: "0.8",
+            title: "0.8x",
+            extensions: {
+              tap_actions: {
+                actions: [
+                  { type: "setPlaybackSpeed", options: { value: 0.8 } },
+                ],
+              },
+            },
+          },
+          {
+            id: "1",
+            title: "1x",
+            extensions: {
+              tap_actions: {
+                actions: [{ type: "setPlaybackSpeed", options: { value: 1 } }],
+              },
+            },
+          },
+        ],
+      },
+    },
+  } as any;
+
+  it("opens orchestrator with inline items and marks current selection", async () => {
+    const result = await openBottomSheetAction(speedSheetAction);
+
+    expect(result).toBe(ActionResult.Success);
+    expect(modalOrchestrator.open).toHaveBeenCalledTimes(1);
+    expect(modalOrchestrator.replace).not.toHaveBeenCalled();
+
+    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
+
+    expect(menu.content.items[0].isSelected).toBe(false);
+
+    expect(menu.content.items[1]).toMatchObject({
+      id: "1",
+      title: "1x",
+      isSelected: true,
+      action: { type: "setPlaybackSpeed", options: { value: 1 } },
+    });
+  });
+
+  it("pushes a new sheet by default even when another sheet is already open", async () => {
+    (modalOrchestrator as any).stackSize = 1;
+
+    await openBottomSheetAction(speedSheetAction);
+
+    expect(modalOrchestrator.open).toHaveBeenCalledTimes(1);
+    expect(modalOrchestrator.replace).not.toHaveBeenCalled();
+  });
+
+  it("replaces the current sheet when options.replace is true", async () => {
+    (modalOrchestrator as any).stackSize = 1;
+
+    await openBottomSheetAction({
+      ...speedSheetAction,
+      options: { ...speedSheetAction.options, replace: true },
+    });
+
+    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();
+  });
+});

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

@@ -0,0 +1,88 @@
+import { showToastAction } from "../showToast";
+import { postEvent } from "../../../reactHooks/useSubscriberFor";
+import { ActionResult } from "../../ActionExecutor";
+
+jest.mock("../../../reactHooks/useSubscriberFor", () => ({
+  postEvent: jest.fn(),
+}));
+
+describe("showToastAction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("calls postEvent with confirmation source, default timeout, and returns Success", async () => {
+    const action = {
+      type: "showToast",
+      options: {
+        id: "toast-1",
+        message: "Added to queue",
+        extraMessage: "Extra info",
+      },
+    };
+
+    const result = await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledTimes(1);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: "toast-1",
+        message: "Added to queue",
+        extraMessage: "Extra info",
+        style: undefined,
+        timeout: 1000,
+        source: "confirmation",
+      },
+    ]);
+
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("preserves an explicit timeout and style override", async () => {
+    const action = {
+      type: "showToast",
+      options: {
+        message: "Playlist created",
+        timeout: 3000,
+        style: { backgroundColor: "#00FF00" },
+      },
+    };
+
+    await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: undefined,
+        message: "Playlist created",
+        extraMessage: undefined,
+        style: { backgroundColor: "#00FF00" },
+        timeout: 3000,
+        source: "confirmation",
+      },
+    ]);
+  });
+
+  it("handles missing or empty options without throwing", async () => {
+    const action = {
+      type: "showToast",
+    };
+
+    const result = await showToastAction(action);
+
+    expect(postEvent).toHaveBeenCalledTimes(1);
+
+    expect(postEvent).toHaveBeenCalledWith("showToast", [
+      {
+        id: undefined,
+        message: undefined,
+        extraMessage: undefined,
+        style: undefined,
+        timeout: 1000,
+        source: "confirmation",
+      },
+    ]);
+
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/appRestart.ts

@@ -0,0 +1,24 @@
+/// <reference types="@applicaster/applicaster-types" />
+import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
+import { QUICK_BRICK_EVENTS } from "@applicaster/zapp-react-native-bridge/QuickBrick";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Restarts the application by triggering a force reload event.
+ * This action does not require any options or context.
+ */
+export const appRestartAction: ActionHandler =
+  async (): Promise<ActionResult> => {
+    log_info(`handleAction: ${QUICK_BRICK_EVENTS.FORCE_APP_RELOAD} event`);
+
+    QuickBrickManager.sendQuickBrickEvent(QUICK_BRICK_EVENTS.FORCE_APP_RELOAD);
+
+    return ActionResult.Success;
+  };