@applicaster/zapp-react-native-utils 16.0.0-alpha.8101951023 → 16.0.0-alpha.8114431136

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/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

@@ -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;
 

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

@@ -212,6 +212,7 @@ export async function openBottomSheetAction(
             ...(content.props || {}),
             actionContext: context,
           },
+          themePluginId,
         },
       });
 
@@ -227,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,
       });
@@ -239,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}`);
 
@@ -280,6 +289,7 @@ export async function openBottomSheetAction(
         dynamicCollection,
         themePluginId,
         styleOverrides: styleOverrides ?? content?.styleOverrides,
+        emptyMessage: content?.emptyMessage,
         context,
       },
     };

package/appUtils/playerManager/OverlayObserver/__tests__/getUpcomingQueue.test.ts

@@ -0,0 +1,67 @@
+import { getUpcomingQueue } from "../getUpcomingQueue";
+
+describe("getUpcomingQueue", () => {
+  it("returns null when plugin is not provided or has no module", async () => {
+    expect(await getUpcomingQueue(undefined)).toBeNull();
+    expect(await getUpcomingQueue({} as any)).toBeNull();
+  });
+
+  it("returns null when QueueManager is not present on module", async () => {
+    const plugin = {
+      identifier: "queue-action",
+      module: {},
+    } as any;
+
+    expect(await getUpcomingQueue(plugin)).toBeNull();
+  });
+
+  it("calls setupQuickBrickQueue when QueueManager is not initialized", async () => {
+    const setupQuickBrickQueue = jest.fn();
+    const mockUpcoming = [{ id: "item_1" }];
+
+    const QueueManager = {
+      isInitialized: jest
+        .fn()
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(true),
+      instance: {
+        getUpcomingQueue: jest.fn().mockResolvedValue(mockUpcoming),
+      },
+    };
+
+    const plugin = {
+      identifier: "queue-action",
+      module: {
+        QueueManager,
+        setupQuickBrickQueue,
+      },
+    } as any;
+
+    const result = await getUpcomingQueue(plugin);
+
+    expect(setupQuickBrickQueue).toHaveBeenCalled();
+    expect(result).toEqual(mockUpcoming);
+  });
+
+  it("returns upcoming items when QueueManager is already initialized", async () => {
+    const mockUpcoming = [{ id: "item_1" }, { id: "item_2" }];
+
+    const QueueManager = {
+      isInitialized: jest.fn().mockReturnValue(true),
+      instance: {
+        getUpcomingQueue: jest.fn().mockResolvedValue(mockUpcoming),
+      },
+    };
+
+    const plugin = {
+      identifier: "queue-action",
+      module: {
+        QueueManager,
+      },
+    } as any;
+
+    const result = await getUpcomingQueue(plugin);
+
+    expect(result).toEqual(mockUpcoming);
+  });
+});

package/appUtils/playerManager/OverlayObserver/getUpcomingQueue.ts

@@ -1,9 +1,22 @@
 export const getUpcomingQueue = async (
   plugin?: QuickBrickPlugin | ZappPlugin
 ): Promise<unknown[] | null> => {
-  const QueueManager = (plugin as any)?.module?.QueueManager;
+  const module = (plugin as any)?.module;
+  const QueueManager = module?.QueueManager;
+  const setupQuickBrickQueue = module?.setupQuickBrickQueue;
 
-  if (!QueueManager?.instance) {
+  if (!QueueManager) {
+    return null;
+  }
+
+  if (
+    !QueueManager.isInitialized?.() &&
+    typeof setupQuickBrickQueue === "function"
+  ) {
+    setupQuickBrickQueue();
+  }
+
+  if (!QueueManager.isInitialized?.()) {
     return null;
   }
 

package/appUtils/playerManager/__tests__/playerNative.test.ts

@@ -36,3 +36,79 @@ describe("PlayerNative.isAudioItem", () => {
     expect(playerWithEntry(null).isAudioItem()).toBe(false);
   });
 });
+
+describe("PlayerNative.command", () => {
+  it("invokes native function with playerId on iOS platform", () => {
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "QuickBrickPlayerPlugin",
+    });
+
+    const commandSpy = jest.fn();
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({
+      command: commandSpy,
+    } as any);
+
+    player.command("setPlayerControls", { transport: ["play"] });
+
+    expect(commandSpy).toHaveBeenCalledWith(
+      "setPlayerControls",
+      "test-player",
+      {
+        transport: ["play"],
+      }
+    );
+  });
+
+  it("invokes native function with view tag on Android when method exists", () => {
+    const reactUtils = require("../../../reactUtils");
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "QuickBrickPlayerPlugin",
+    });
+
+    const commandSpy = jest.fn();
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({
+      command: commandSpy,
+    } as any);
+
+    jest.spyOn(player, "getComponentNode").mockReturnValue(12345 as any);
+
+    player.command("setPlayerControls", { transport: ["play"] });
+
+    expect(commandSpy).toHaveBeenCalledWith(12345, "setPlayerControls", {
+      transport: ["play"],
+    });
+
+    (reactUtils.isApplePlatform as jest.Mock).mockRestore();
+  });
+
+  it("handles when native module does not have command method on Android", () => {
+    const reactUtils = require("../../../reactUtils");
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    const player = new PlayerNative({
+      entry: null,
+      player: { current: {} } as any,
+      playerId: "test-player",
+      playerPluginId: "KalturaPlayerPlugin",
+    });
+
+    jest.spyOn(player, "getPlayerModule").mockReturnValue({} as any);
+    jest.spyOn(player, "getComponentNode").mockReturnValue(12345 as any);
+
+    expect(() => {
+      player.command("setPlayerControls", { transport: ["play"] });
+    }).not.toThrow();
+
+    (reactUtils.isApplePlatform as jest.Mock).mockRestore();
+  });
+});

package/appUtils/playerManager/__tests__/playerNativeCommand.test.ts

@@ -0,0 +1,62 @@
+import { NativeModules } from "react-native";
+import {
+  PlayerNativeCommandTypes,
+  PlayerNativeSendCommand,
+} from "../playerNativeCommand";
+
+describe("PlayerNativeSendCommand", () => {
+  const reactUtils = require("../../../reactUtils");
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("calls NativeModules.PlayerModule.command on Apple platform with playerId", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(true);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand(
+      PlayerNativeCommandTypes.setPlayerControls,
+      "player-123",
+      { transport: ["play"] }
+    );
+
+    expect(NativeModules.PlayerModule.command).toHaveBeenCalledWith(
+      "setPlayerControls",
+      "player-123",
+      { transport: ["play"] }
+    );
+  });
+
+  it("does not call NativeModules.PlayerModule.command on non-Apple platform", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(false);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand(
+      PlayerNativeCommandTypes.setPlayerControls,
+      "player-123",
+      { transport: ["play"] }
+    );
+
+    expect(NativeModules.PlayerModule.command).not.toHaveBeenCalled();
+  });
+
+  it("does nothing when playerId or command is missing", () => {
+    jest.spyOn(reactUtils, "isApplePlatform").mockReturnValue(true);
+
+    NativeModules.PlayerModule = {
+      command: jest.fn(),
+    };
+
+    PlayerNativeSendCommand("", "player-123");
+    PlayerNativeSendCommand("setPlayerControls", "");
+
+    expect(NativeModules.PlayerModule.command).not.toHaveBeenCalled();
+  });
+});