@applicaster/zapp-react-native-utils 16.0.0-alpha.3081324238 → 16.0.0-alpha.3202041045

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/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,
         },
       });
 

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

@@ -0,0 +1,62 @@
+import { Player } from "../player";
+
+const entry = (id: string) => ({ id, title: id }) as unknown as ZappEntry;
+
+const makePlayer = () => {
+  const player = new Player({ playerId: "test-player" });
+  player.entry = entry("first");
+
+  return player;
+};
+
+describe("Player per-entry diagnostics", () => {
+  it("keeps the latest of onError and onVideoError, and clears it when a new entry loads", () => {
+    const player = makePlayer();
+    const second = { message: "second" };
+
+    player.onError({ message: "first" } as any);
+    player.onVideoError(second as any);
+
+    expect(player.lastError).toBe(second);
+
+    player.entry = entry("second");
+
+    expect(player.lastError).toBeNull();
+  });
+
+  it("reads the next entry without creating the overlay observer", () => {
+    const player = makePlayer();
+
+    expect(player.getPlayNextEntry()).toBeNull();
+
+    jest
+      .spyOn(player.getOverlayObservable(), "getPlayNextEntry")
+      .mockReturnValue(entry("next"));
+
+    expect(player.getPlayNextEntry()).toEqual(entry("next"));
+  });
+
+  it("keeps the content clock while a client-side ad plays", () => {
+    const player = makePlayer();
+
+    player.onVideoProgress({
+      currentTime: 300,
+      duration: 1800,
+      seekableDuration: 1800,
+    });
+
+    player.onAdBegin({});
+
+    player.onVideoProgress({
+      currentTime: 5,
+      duration: 15,
+      seekableDuration: 15,
+    });
+
+    expect(player.getPosition()).toBe(5);
+    expect(player.getDuration()).toBe(15);
+    expect(player.getContentPosition()).toBe(300);
+    expect(player.getContentDuration()).toBe(1800);
+    expect(player.getSeekableDuration()).toBe(1800);
+  });
+});

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

@@ -18,6 +18,9 @@ const loadToolbox = () => {
 const player = (overrides = {}) => ({
   getSeekableDuration: () => 100,
   getContentPosition: () => 40,
+  isLive: () => false,
+  getPlayNextEntry: () => null,
+  playNextHandler: jest.fn(),
   seekTo: jest.fn(),
   ...overrides,
 });
@@ -30,7 +33,7 @@ const registeredTools = async (active) => {
   mockXray = { registerReactToolbox: mockRegister };
   await loadToolbox().registerPlayerToolbox(manager(active));
 
-  const { tools } = mockRegister.mock.calls[0][0];
+  const { tools } = mockRegister.mock.lastCall[0];
 
   return Object.fromEntries(tools.map((tool) => [tool.name, tool.handler]));
 };
@@ -45,7 +48,7 @@ describe("playerToolbox", () => {
 
     await expect(
       loadToolbox().registerPlayerToolbox(manager(null))
-    ).resolves.toBeUndefined();
+    ).resolves.toBe(false);
   });
 
   it("does nothing when getXray returns null", async () => {
@@ -53,7 +56,7 @@ describe("playerToolbox", () => {
 
     await expect(
       loadToolbox().registerPlayerToolbox(manager(null))
-    ).resolves.toBeUndefined();
+    ).resolves.toBe(false);
   });
 
   it("swallows a failed registration", async () => {
@@ -62,7 +65,7 @@ describe("playerToolbox", () => {
 
     await expect(
       loadToolbox().registerPlayerToolbox(manager(null))
-    ).resolves.toBeUndefined();
+    ).resolves.toBe(false);
   });
 
   it("seeks to an absolute position, from the end when negative, clamped", async () => {
@@ -87,6 +90,187 @@ describe("playerToolbox", () => {
     );
   });
 
+  describe("state", () => {
+    const playing = (overrides = {}, entry: any = { id: "e1", title: "T" }) =>
+      player({
+        playerId: "p1",
+        playerRole: "Primary",
+        getEntry: () => entry,
+        getPosition: () => 40,
+        getDuration: () => 100,
+        getContentDuration: () => 100,
+        isReadyToPlay: () => true,
+        isPlaying: () => true,
+        isBuffering: () => false,
+        isAd: () => false,
+        isLive: () => false,
+        getIsMuted: () => false,
+        ...overrides,
+      });
+
+    const state = async (overrides = {}, entry?: any) =>
+      (await registeredTools(playing(overrides, entry))).state();
+
+    it("reports inactive when nothing plays", async () => {
+      expect((await registeredTools(null)).state()).toEqual({
+        active: false,
+        casting: false,
+      });
+    });
+
+    it("keeps the existing fields and adds the content clock for a VOD", async () => {
+      expect(await state()).toEqual({
+        active: true,
+        playerId: "p1",
+        entry: { id: "e1", title: "T" },
+        position: 40,
+        duration: 100,
+        playing: true,
+        buffering: false,
+        readyToPlay: true,
+        ad: false,
+        live: false,
+        muted: false,
+        role: "Primary",
+        plugin: null,
+        engine: null,
+        casting: false,
+        seekableDuration: 100,
+        contentPosition: 40,
+        contentDuration: 100,
+        drm: null,
+        lastError: null,
+        next: null,
+      });
+    });
+
+    it("reports the content's clock next to the ad's during a client-side ad", async () => {
+      const result = await state({
+        isAd: () => true,
+        getPosition: () => 5,
+        getDuration: () => 15,
+        getContentPosition: () => 300,
+        getContentDuration: () => 1800,
+      });
+
+      expect(result).toMatchObject({
+        ad: true,
+        position: 5,
+        duration: 15,
+        contentPosition: 300,
+        contentDuration: 1800,
+      });
+    });
+
+    it("reports non-finite numbers as null", async () => {
+      expect(
+        await state({
+          getSeekableDuration: () => NaN,
+          getContentPosition: () => null,
+          getContentDuration: () => Infinity,
+        })
+      ).toMatchObject({
+        seekableDuration: null,
+        contentPosition: null,
+        contentDuration: null,
+      });
+    });
+
+    it("reports the player plugin and its web engine", async () => {
+      expect(
+        await state({
+          playerPluginId: "QuickBrickPlayerPlugin",
+          engine: "hls.js",
+        })
+      ).toMatchObject({ plugin: "QuickBrickPlayerPlugin", engine: "hls.js" });
+    });
+
+    it("lists the entry's DRM key systems, or null", async () => {
+      const drm = { widevine: { license_url: "w" }, playready: {} };
+
+      expect((await state({}, { id: "e", extensions: { drm } })).drm).toEqual([
+        "widevine",
+        "playready",
+      ]);
+
+      expect((await state({}, { id: "e", extensions: { drm: {} } })).drm).toBe(
+        null
+      );
+
+      expect((await state({}, { id: "e", extensions: {} })).drm).toBe(null);
+      expect((await state({}, null)).drm).toBe(null);
+    });
+
+    it("reports no last error as null", async () => {
+      expect((await state({ lastError: null })).lastError).toBeNull();
+    });
+  });
+
+  describe("play next", () => {
+    const nextEntry = { id: "n1", title: "Next", extensions: {} };
+
+    const stateWith = async (overrides) =>
+      (
+        await registeredTools(
+          player({
+            getEntry: () => null,
+            getPosition: () => 0,
+            getDuration: () => 0,
+            getContentDuration: () => 0,
+            isReadyToPlay: () => true,
+            isPlaying: () => true,
+            isBuffering: () => false,
+            isAd: () => false,
+            getIsMuted: () => false,
+            ...overrides,
+          })
+        )
+      ).state();
+
+    it("reports the entry Play Next would play", async () => {
+      expect(
+        (await stateWith({ getPlayNextEntry: () => nextEntry })).next
+      ).toEqual({ id: "n1", title: "Next" });
+    });
+
+    it("reports no next entry as null", async () => {
+      expect((await stateWith({})).next).toBeNull();
+    });
+
+    it("plays the next entry through the player's Play Next action", async () => {
+      const active = player({ getPlayNextEntry: () => nextEntry });
+      const tools = await registeredTools(active);
+
+      expect(tools.next()).toEqual({ id: "n1", title: "Next" });
+      expect(active.playNextHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it("fails without a next entry", async () => {
+      const active = player();
+      const tools = await registeredTools(active);
+
+      expect(() => tools.next()).toThrow("No next item");
+      expect(active.playNextHandler).not.toHaveBeenCalled();
+    });
+
+    it("fails when no Play Next action is registered", async () => {
+      const tools = await registeredTools(
+        player({
+          getPlayNextEntry: () => nextEntry,
+          playNextHandler: null,
+        })
+      );
+
+      expect(() => tools.next()).toThrow("No next item");
+    });
+
+    it("fails without an active player", async () => {
+      const tools = await registeredTools(null);
+
+      expect(() => tools.next()).toThrow("No active player");
+    });
+  });
+
   it("refuses to seek a stream that is not seekable", async () => {
     const tools = await registeredTools(
       player({ getSeekableDuration: () => 0 })

package/appUtils/playerManager/index.ts

@@ -397,6 +397,11 @@ export class PlayerManager {
     return this.manager.removeHandler(event, handler);
   }
 
+  /** Whether anything handles `event` now, e.g. a mounted PlayerContainer for "toggleFullscreen". */
+  public hasHandler(event: string) {
+    return this.manager.handlers[event]?.length > 0;
+  }
+
   // TODO: should not be
   public invokeHandler(event, ...args) {
     return this.manager.invokeHandler(event, ...args);

package/appUtils/playerManager/player.ts

@@ -76,6 +76,12 @@ export class Player {
   private overlaysObserver?: OverlaysObserver | null;
   private entryObservable?: BehaviorSubject<ZappEntry> | null;
   private contentSubject?: BehaviorSubject<PlayerContent> | null;
+  // Read by the X-Ray `player` toolbox: the last onError/onVideoError of the current entry,
+  // and the Play Next action of the PlayerContainer showing this player.
+  public lastError: unknown = null;
+  public playNextHandler: (() => void) | null = null;
+  // The web engine the default player picked (hls.js, dash.js, shaka, video.js); null elsewhere.
+  public engine: string | null = null;
 
   protected listeners: {
     [key: string]: QuickBrickPlayer.SharedPlayerCallBacks;
@@ -89,6 +95,7 @@ export class Player {
 
   set entry(newEntry: ZappEntry | null) {
     this._entry = newEntry;
+    this.lastError = null;
     // The live entry is scoped to the entry it overlays - see
     // `OverlaysObserver.clearLiveEntry`. No-op when there is no observer,
     // which is every non-live player.
@@ -271,6 +278,10 @@ export class Player {
 
   getEntry = (): ZappEntry | null => this.entry;
 
+  /** The entry Play Next would play now; null without one. Never creates the overlay observer. */
+  getPlayNextEntry = (): ZappEntry | null =>
+    this.overlaysObserver?.getPlayNextEntry() ?? null;
+
   logState = (text, additionalParams = {}) => {
     const isSeeking = this.playerState.seekPosition !== null;
 
@@ -492,6 +503,8 @@ export class Player {
   };
 
   onVideoError = (error: Error) => {
+    this.lastError = error;
+
     this.invokeListenersUpdate({
       callbackName: SharedPlayerCallBacksKeys.OnVideoError,
       event: error,
@@ -499,6 +512,8 @@ export class Player {
   };
 
   onError = (error: Error) => {
+    this.lastError = error;
+
     this.invokeListenersUpdate({
       callbackName: SharedPlayerCallBacksKeys.OnError,
       event: error,