@applicaster/zapp-react-native-utils 16.0.0-alpha.1593888345 → 16.0.0-alpha.1733304298

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

@@ -2,6 +2,22 @@ import { openBottomSheetAction } from "../openBottomSheet";
 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;
 

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

@@ -0,0 +1,49 @@
+import { showAlertAction } from "../showAlert";
+import { ActionResult } from "../../ActionExecutor";
+import { showAlertDialog } from "../../../alertUtils";
+
+jest.mock("../../../alertUtils", () => ({
+  showAlertDialog: jest.fn(),
+}));
+
+const dialog = showAlertDialog as jest.Mock;
+
+const dismiss = () => dialog.mock.calls[0][0].completion();
+
+describe("showAlert", () => {
+  beforeEach(() => dialog.mockReset());
+
+  it("shows the notice and resolves once it is dismissed", async () => {
+    const result = showAlertAction({
+      type: "showAlert",
+      options: { title: "Locked", message: "Ask the account owner." },
+    });
+
+    expect(dialog).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: "Locked",
+        message: "Ask the account owner.",
+        okButtonText: "OK",
+      })
+    );
+
+    dismiss();
+
+    // Dismissing a notice is not a cancellation: the chain carries on.
+    await expect(result).resolves.toBe(ActionResult.Success);
+  });
+
+  it("takes the dismiss label from the action", async () => {
+    const result = showAlertAction({
+      type: "showAlert",
+      options: { title: "Locked", okButtonText: "Got it" },
+    });
+
+    expect(dialog).toHaveBeenCalledWith(
+      expect.objectContaining({ okButtonText: "Got it" })
+    );
+
+    dismiss();
+    await result;
+  });
+});

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

@@ -31,7 +31,7 @@ describe("showToastAction", () => {
         message: "Added to queue",
         extraMessage: "Extra info",
         style: undefined,
-        timeout: 1000,
+        timeout: 5000,
         source: "confirmation",
       },
     ]);
@@ -78,7 +78,7 @@ describe("showToastAction", () => {
         message: undefined,
         extraMessage: undefined,
         style: undefined,
-        timeout: 1000,
+        timeout: 5000,
         source: "confirmation",
       },
     ]);

package/actionsExecutor/actions/index.ts

@@ -15,6 +15,8 @@ export { appRestartAction } from "./appRestart";
 
 export { confirmDialogAction } from "./confirmDialog";
 
+export { showAlertAction } from "./showAlert";
+
 export { sendCloudEventAction } from "./sendCloudEvent";
 
 export { sessionStorageToggleFlagAction } from "./sessionStorageToggleFlag";

package/actionsExecutor/actions/navigateToScreen.ts

@@ -13,7 +13,7 @@ const { log_info, log_error } = createLogger({
  */
 export interface NavigateToScreenOptions {
   /** The screen type to navigate to (from content types mapping) */
-  typeMapping: string;
+  typeMapping?: string;
 
   /** Navigation action: push adds to history, replace replaces current screen */
   navigationAction?: "push" | "replace";
@@ -58,14 +58,6 @@ export function createNavigateToScreenAction(
     action,
     context?: ActionExecutionContext
   ): Promise<ActionResult> {
-    const screenType = action.options?.typeMapping;
-
-    if (!screenType) {
-      log_error("navigateToScreen: typeMapping option is missing");
-
-      return ActionResult.Error;
-    }
-
     const navigationAction = action.options?.navigationAction;
     const entrySource = action.options?.entry;
     const navigationOptions = action.options?.navigationOptions;
@@ -76,61 +68,53 @@ export function createNavigateToScreenAction(
         : entrySource
       : null;
 
-    if (entry) {
-      if (typeof entry !== "object") {
-        log_error(
-          `navigateToScreen: entry option is not an object, entry: ${entry}`
-        );
+    const screenType = action.options?.typeMapping || entry?.type?.value;
 
-        return ActionResult.Error;
-      }
+    const navigate =
+      navigationAction === "push" ? navigator.push : navigator.replace;
+
+    let navigatingEntry: ZappEntry | ZappRiver = entry;
 
+    if (entry && screenType) {
       log_info(
         `navigateToScreen: navigating to screen type: ${screenType} with entry id: ${entry.id}`
       );
 
-      const overriddenEntry: ZappEntry = {
+      navigatingEntry = {
         ...entry,
-        type: {
-          value: screenType,
-        },
+        type: { value: screenType },
       };
+    } else {
+      if (!screenType) {
+        log_error(
+          "navigateToScreen: options.typeMapping or entry?.type?.value is not provided"
+        );
 
-      if (navigationAction === "push") {
-        navigator.push(overriddenEntry, navigationOptions);
-      } else {
-        // Use replaceTop for entries since replace() only accepts ZappRiver
-        navigator.replaceTop(overriddenEntry, navigationOptions);
+        return ActionResult.Error;
       }
 
-      return ActionResult.Success;
-    }
-
-    const screenId = contentTypes?.[screenType]?.screen_id || null;
+      const screenId = contentTypes?.[screenType]?.screen_id || null;
+      const river = rivers?.[screenId];
 
-    if (!screenId) {
-      log_error(
-        `navigateToScreen: can not resolve screen type mapping: ${screenType}`
-      );
+      if (!screenId) {
+        log_error(
+          `navigateToScreen: can not resolve screen type mapping: ${screenType}`
+        );
 
-      return ActionResult.Error;
-    }
+        return ActionResult.Error;
+      }
 
-    const river = rivers[screenId];
+      if (!river) {
+        log_error("navigateToScreen: can not resolve river");
 
-    if (!river) {
-      log_error("navigateToScreen: can not resolve river");
+        return ActionResult.Error;
+      }
 
-      return ActionResult.Error;
+      navigatingEntry = river;
     }
 
     context?.callback?.({ success: false, error: null, abort: true });
-
-    if (navigationAction === "push") {
-      navigator.push(river, navigationOptions);
-    } else {
-      navigator.replace(river, navigationOptions);
-    }
+    navigate(navigatingEntry, navigationOptions);
 
     return ActionResult.Success;
   };

package/actionsExecutor/actions/openBottomSheet.ts

@@ -208,7 +208,11 @@ export async function openBottomSheetAction(
           items: [],
           onPress: () => {},
           contentComponent: content.component,
-          contentComponentProps: content.props || {},
+          contentComponentProps: {
+            ...(content.props || {}),
+            actionContext: context,
+          },
+          themePluginId,
         },
       });
 
@@ -224,7 +228,18 @@ export async function openBottomSheetAction(
 
     let dynamicCollection: DynamicCollectionOptions | undefined;
 
-    if (Array.isArray(inlineItems) && inlineItems.length > 0) {
+    const rawDynamicCollection =
+      content?.dynamicCollection ??
+      content?.extensions?.dynamic_collection_options;
+
+    // An empty items array is a valid starting state for a provider-backed or
+    // offline collection. A sheet with neither items nor a source still errors.
+    const hasDynamicCollection = Boolean(rawDynamicCollection);
+
+    if (
+      Array.isArray(inlineItems) &&
+      (inlineItems.length > 0 || hasDynamicCollection)
+    ) {
       log_info("openBottomSheet: using inline items from action options", {
         count: inlineItems.length,
       });
@@ -236,10 +251,7 @@ export async function openBottomSheetAction(
         entryToMenuItem(entry, behavior?.currentSelection ?? [])
       );
 
-      dynamicCollection = parseDynamicCollectionOptions(
-        content?.dynamicCollection ??
-          content?.extensions?.dynamic_collection_options
-      );
+      dynamicCollection = parseDynamicCollectionOptions(rawDynamicCollection);
     } else if (itemsUrl) {
       log_info(`openBottomSheet: loading items from source: ${itemsUrl}`);
 
@@ -277,6 +289,9 @@ export async function openBottomSheetAction(
         dynamicCollection,
         themePluginId,
         styleOverrides: styleOverrides ?? content?.styleOverrides,
+        emptyMessage: content?.emptyMessage,
+        operationButtons: content?.operationButtons,
+        context,
       },
     };
 

package/actionsExecutor/actions/screenToggleFlag.ts

@@ -27,12 +27,10 @@ export const screenToggleFlagAction: ActionHandler<
   const screenRoute = context?.screenRoute;
   const screenStateStore = context?.screenStateStore;
 
-  await screenToggleFlag(
+  return await screenToggleFlag(
     screenRoute,
     screenStateStore,
     { entry: context?.entry, options: action.options },
     action
   );
-
-  return ActionResult.Success;
 };

package/actionsExecutor/actions/showAlert.ts

@@ -0,0 +1,51 @@
+/// <reference types="@applicaster/applicaster-types" />
+import { showAlertDialog } from "../../alertUtils";
+import { ActionResult } from "../ActionExecutor";
+import { ActionHandler } from "../types";
+import { createLogger } from "../../logger";
+
+const { log_info } = createLogger({
+  subsystem: "ActionExecutorContext",
+  category: "General",
+});
+
+/**
+ * Options for the showAlert action.
+ */
+export interface ShowAlertOptions {
+  /** Dialog title (required) */
+  title: string;
+
+  /** Dialog message */
+  message?: string;
+
+  /** Dismiss button text. Defaults to "OK" */
+  okButtonText?: string;
+}
+
+/**
+ * Tells the user something and waits for them to acknowledge it.
+ *
+ * One button, because there is nothing to decide. Use `confirmDialog` when the
+ * user is choosing between going on and backing out; a `confirmDialog` without
+ * a cancel label still renders two buttons, the second one blank.
+ *
+ * Always resolves to Success: dismissing a notice is not a cancellation, so the
+ * rest of the chain runs.
+ */
+export const showAlertAction: ActionHandler<ShowAlertOptions> = async (
+  action
+): Promise<ActionResult> => {
+  log_info("handleAction: showAlert event");
+
+  const options = action.options as ShowAlertOptions;
+
+  return new Promise<ActionResult>((resolve) => {
+    showAlertDialog({
+      title: options?.title,
+      message: options?.message,
+      okButtonText: options?.okButtonText || "OK",
+      completion: () => resolve(ActionResult.Success),
+    });
+  });
+};

package/actionsExecutor/actions/showToast.ts

@@ -5,7 +5,7 @@ import { postEvent } from "../../reactHooks/useSubscriberFor";
 
 export const CONFIRMATION_TOAST_SOURCE = "confirmation";
 
-export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 1000;
+export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 5000;
 
 /**
  * Shows a mobile confirmation toast with Theme defaults from
@@ -13,7 +13,7 @@ export const CONFIRMATION_TOAST_DEFAULT_TIMEOUT = 1000;
  *
  * This action is confirmation-only by design: it always stamps
  * `source: "confirmation"` (so Theme confirmation styles apply) and defaults
- * `timeout` to 1000 ms. Non-confirmation toasts (e.g. Offline Experience)
+ * `timeout` to 5000 ms. Non-confirmation toasts (e.g. Offline Experience)
  * must post on the shared `"showToast"` event bus directly and omit `source`.
  * Callers may override individual style fields; Theme supplies the rest.
  *

package/actionsExecutor/consts.ts

@@ -23,6 +23,7 @@ export const ACTION_TYPES = {
   SWITCH_LAYOUT: "switchLayout",
   APP_RESTART: "appRestart",
   CONFIRM_DIALOG: "confirmDialog",
+  SHOW_ALERT: "showAlert",
   SCREEN_SET_VARIABLE: "screenSetVariable",
   SCREEN_TOGGLE_FLAG: "screenToggleFlag",
 } as const;

package/actionsExecutor/feedDecorator.ts

@@ -47,6 +47,11 @@ function makeMultiSelect(feed: ZappFeed, key, decoratedFeed) {
         ? "sessionStorageToggleFlag"
         : "localStorageToggleFlag";
 
+  // the toggle actions read their limit from their own options
+  const maxItems = Number(
+    decoratedFeed.extensions?.preference_editor_options?.max_items
+  );
+
   decoratedFeed.entry?.forEach((entry: ZappEntry) => {
     entry.type.value = "action";
     entry.id = entry.extensions?.tag || entry.id;
@@ -59,6 +64,7 @@ function makeMultiSelect(feed: ZappFeed, key, decoratedFeed) {
             type: actionType,
             options: {
               key,
+              ...(maxItems > 0 && { max_items: maxItems }),
             },
           },
         ],

package/analyticsUtils/__tests__/playerAnalyticsSafeguard.test.ts

@@ -0,0 +1,62 @@
+import { PlayerAnalyticsTracker } from "../playerAnalyticsTracker";
+import { PLAYBACK_EVENT } from "../events";
+
+const mockPostAnalyticEvent = jest.fn();
+
+jest.mock("../manager", () => ({
+  postAnalyticEvent: (...args) => mockPostAnalyticEvent(...args),
+}));
+
+describe("Player Analytics Safeguards against nativeEvent leakage", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const mockEntry = {
+    id: "vod_123",
+    title: "Test Video",
+    type: { value: "video" },
+    content: { type: "video/mp4" },
+    extensions: { duration: 120 },
+  };
+
+  const mockPlayer = {
+    playerPluginId: "quick_brick_player",
+    getEntry: () => mockEntry,
+    getState: () => ({ isPaused: false, contentPosition: 0.63 }),
+  };
+
+  it("omits nativeEvent from analytics payload if present in eventData", () => {
+    const tracker = new PlayerAnalyticsTracker();
+    tracker.setPlayer(mockPlayer as any);
+
+    const payload = tracker.prepareAnalyticPayload(PLAYBACK_EVENT.play, {
+      nativeEvent: { currentTime: 0.63, reason: "video_ready" },
+      player_type: "quick_brick_player",
+    } as any);
+
+    expect(payload.nativeEvent).toBeUndefined();
+    expect(payload.media_id).toBe("vod_123");
+    expect(payload.name).toBe("Test Video");
+    expect(payload.player_type).toBe("quick_brick_player");
+  });
+
+  it("properly prepares payload when eventData is unwrapped", () => {
+    const tracker = new PlayerAnalyticsTracker();
+    tracker.setPlayer(mockPlayer as any);
+
+    const payload = tracker.prepareAnalyticPayload(PLAYBACK_EVENT.play, {
+      currentTime: 0.63,
+      reason: "video_ready",
+      player_type: "quick_brick_player",
+    } as any);
+
+    expect(payload.nativeEvent).toBeUndefined();
+    expect(payload.currentTime).toBeUndefined();
+    expect(payload.current_position).toBe(0.63);
+    expect(payload.reason).toBe("video_ready");
+    expect(payload.media_id).toBe("vod_123");
+    expect(payload.name).toBe("Test Video");
+    expect(payload.player_type).toBe("quick_brick_player");
+  });
+});

package/analyticsUtils/playerAnalyticsTracker.ts

@@ -214,6 +214,7 @@ export class PlayerAnalyticsTracker implements PlayerAnalyticsTrackerI {
         "isLive",
         "event",
         "entry",
+        "nativeEvent",
       ],
       eventData
     );

package/appUtils/contextKeysManager/__tests__/getKey/failure.test.ts

@@ -1,4 +1,4 @@
-import { ContextKeysManager, NOTHING } from "../..";
+import { ContextKeysManager } from "../..";
 
 describe("Context Keys Manager - getKey", () => {
   it("returns null if key is invalid", async () => {
@@ -34,8 +34,6 @@ describe("Context Keys Manager - getKey", () => {
       secureStorage: mockedSecureStorage,
     });
 
-    const getKeyByReference = jest.spyOn(contextManager, "getKeyByReference");
-
     // run
     const result = await contextManager.getKey(invalidKey);
 
@@ -50,7 +48,6 @@ describe("Context Keys Manager - getKey", () => {
       data: { key: invalidKey },
     });
 
-    expect(getKeyByReference).not.toHaveBeenCalled();
     expect(mockedSessionStorage.getItem).not.toHaveBeenCalled();
     expect(mockedLocalStorage.getItem).not.toHaveBeenCalled();
     expect(mockedSecureStorage.getItem).not.toHaveBeenCalled();
@@ -90,10 +87,6 @@ describe("Context Keys Manager - getKey", () => {
       secureStorage: mockedSecureStorage,
     });
 
-    const getKeyByReference = jest
-      .spyOn(contextManager, "getKeyByReference")
-      .mockResolvedValueOnce(NOTHING);
-
     // run
     const result = await contextManager.getKey(key);
 
@@ -107,8 +100,6 @@ describe("Context Keys Manager - getKey", () => {
       data: { key },
     });
 
-    expect(getKeyByReference).toHaveBeenCalledWith("key", "namespace");
-
     expect(mockedSessionStorage.getItem).toHaveBeenCalledWith(
       "key",
       "namespace"
@@ -152,10 +143,6 @@ describe("Context Keys Manager - getKey", () => {
       secureStorage: mockedSecureStorage,
     });
 
-    const getKeyByReference = jest
-      .spyOn(contextManager, "getKeyByReference")
-      .mockResolvedValueOnce(NOTHING);
-
     // run
     const result = await contextManager.getKey(key);
 
@@ -169,8 +156,6 @@ describe("Context Keys Manager - getKey", () => {
       data: { key },
     });
 
-    expect(getKeyByReference).toHaveBeenCalledWith("key", "namespace");
-
     expect(mockedSessionStorage.getItem).toHaveBeenCalledWith(
       "key",
       "namespace"
@@ -214,10 +199,6 @@ describe("Context Keys Manager - getKey", () => {
       secureStorage: mockedSecureStorage,
     });
 
-    const getKeyByReference = jest
-      .spyOn(contextManager, "getKeyByReference")
-      .mockResolvedValueOnce(NOTHING);
-
     // run
     const result = await contextManager.getKey(key);
 
@@ -231,8 +212,6 @@ describe("Context Keys Manager - getKey", () => {
       data: { key },
     });
 
-    expect(getKeyByReference).toHaveBeenCalledWith("key", "namespace");
-
     expect(mockedSessionStorage.getItem).toHaveBeenCalledWith(
       "key",
       "namespace"