@applicaster/zapp-react-native-utils 15.1.7 → 15.1.9-alpha.3547421944

package/actionsExecutor/__tests__/feedDecorator.test.ts

@@ -0,0 +1,61 @@
+import { decorateFeed } from "../feedDecorator";
+
+const preferenceFeed = (selectMode: string) =>
+  ({
+    id: "agree-component",
+    title: "I agree to the terms",
+    type: { value: "feed" },
+    extensions: {
+      role: "preference_editor",
+      preference_editor_options: {
+        key: "agree",
+        scope: "screen",
+        select_mode: selectMode,
+      },
+    },
+    entry: [
+      {
+        id: "I agree to the terms-agree",
+        title: "I agree to the terms",
+        type: { value: "action" },
+        extensions: { tag: "true" },
+      },
+    ],
+  }) as unknown as ZappFeed;
+
+describe("decorateFeed", () => {
+  it("decorates single select feeds with screenSetVariable", () => {
+    const decorated = decorateFeed(preferenceFeed("single"));
+
+    expect(decorated.extensions.behavior).toEqual(
+      expect.objectContaining({
+        select_mode: "single",
+        current_selection: "@{screen/agree}",
+      })
+    );
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenSetVariable"
+    );
+  });
+
+  it("decorates multi select feeds with screenToggleFlag", () => {
+    const decorated = decorateFeed(preferenceFeed("multi"));
+
+    expect(decorated.extensions.behavior.select_mode).toBe("multi");
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenToggleFlag"
+    );
+  });
+
+  it("leaves a feed without the preference_editor role untouched", () => {
+    const feed = preferenceFeed("single");
+    feed.extensions.role = undefined;
+
+    const decorated = decorateFeed(feed);
+
+    expect(decorated.extensions.behavior).toBeUndefined();
+    expect(decorated.entry[0].extensions.tap_actions).toBeUndefined();
+  });
+});

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/navigateToScreen.ts

@@ -25,6 +25,19 @@ export interface NavigateToScreenOptions {
    * - undefined to navigate to screen without entry
    */
   entry?: "@{entry/}" | ZappEntry;
+
+  /**
+   * Arbitrary values passed through to the destination screen.
+   *
+   * They are stored on the navigation route as `NavigationScreenData.options`
+   * and read on the target screen via `useNavigation().data?.options`. Use this
+   * to hand per-navigation parameters to a screen instead of routing them
+   * through module-level state.
+   *
+   * Note: `legacyScreenData()` does not carry these values, so they are not
+   * visible through `useCurrentScreenData()` / `useRoute()`.
+   */
+  navigationOptions?: Record<string, unknown>;
 }
 
 /**
@@ -55,6 +68,7 @@ export function createNavigateToScreenAction(
 
     const navigationAction = action.options?.navigationAction;
     const entrySource = action.options?.entry;
+    const navigationOptions = action.options?.navigationOptions;
 
     const entry = entrySource
       ? entrySource === "@{entry/}"
@@ -83,10 +97,10 @@ export function createNavigateToScreenAction(
       };
 
       if (navigationAction === "push") {
-        navigator.push(overriddenEntry);
+        navigator.push(overriddenEntry, navigationOptions);
       } else {
         // Use replaceTop for entries since replace() only accepts ZappRiver
-        navigator.replaceTop(overriddenEntry);
+        navigator.replaceTop(overriddenEntry, navigationOptions);
       }
 
       return ActionResult.Success;
@@ -113,9 +127,9 @@ export function createNavigateToScreenAction(
     context?.callback?.({ success: false, error: null, abort: true });
 
     if (navigationAction === "push") {
-      navigator.push(river);
+      navigator.push(river, navigationOptions);
     } else {
-      navigator.replace(river);
+      navigator.replace(river, navigationOptions);
     }
 
     return ActionResult.Success;

package/actionsExecutor/feedDecorator.ts

@@ -159,13 +159,13 @@ export const decorateFeed = (feed: ZappFeed) => {
 
   const decoratedFeed = R.clone(feed);
 
-  const isSingleSelect =
-    (feed.extensions?.["preference_editor_options"]?.select_mode ||
-      feed.extensions?.["behavior"]?.select_mode) === "single";
+  const selectMode =
+    feed.extensions?.preference_editor_options?.select_mode ||
+    feed.extensions?.behavior?.select_mode;
 
-  if (isSingleSelect) {
+  if (selectMode === "single") {
     return makeSingleSelect(feed, key, decoratedFeed);
-  } else {
-    return makeMultiSelect(feed, key, decoratedFeed);
   }
+
+  return makeMultiSelect(feed, key, decoratedFeed);
 };

package/appUtils/HooksManager/index.ts

@@ -504,6 +504,15 @@ export function HooksManager({
         presentUI
       );
     } catch (e) {
+      // Without this the failure is invisible: the hook stops right after the
+      // "Executing hook" line, with nothing in the log explaining why and no
+      // remaining hook ever running.
+      logHookEvent(
+        hooksManagerLogger.error,
+        `runInBackground: hook ${hookPlugin.identifier} threw: ${e?.message}`,
+        { hook: hookPlugin, payload, error: e, stack: e?.stack }
+      );
+
       hookPlugin.setStateAndNotify(HOOKS_EVENTS.ERROR, {
         error: e,
         hookPlugin,

package/appUtils/playerManager/OverlayObserver/OverlaysObserver.ts

@@ -19,6 +19,12 @@ export const { log_verbose, log_debug, log_info, log_error } = createLogger({
   parent: utilsLogger,
 });
 
+/**
+ * Mirrors `initial_value` for `audio_live_player_update_interval` in
+ * `defaultManifestConfigurations/player.js`.
+ */
+const DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS = 60;
+
 type ChapterMarkerOriginal = {
   id: string;
   title: string;
@@ -40,11 +46,6 @@ export type LiveMetadataConfig = {
   updateInterval: number;
 };
 
-export type TitleSummaryEvent = {
-  title: string | number;
-  summary: string | number;
-};
-
 type ChapterMarkersObserverProps = {
   player: Player;
 };
@@ -66,11 +67,9 @@ export class OverlaysObserver {
   readonly chapterSubject: BehaviorSubject<ChapterMarkerEvent>;
   private playNextSubject: BehaviorSubject<PlayNextState>;
   private liveMetadataSubject: BehaviorSubject<LiveMetadataEvent>;
-  private titleSummarySubject: BehaviorSubject<TitleSummaryEvent>;
-  private feedUrl: string;
-  private reloadData: () => void;
-  private updateTitleAndDescription: (data: any) => void;
-  private feedDataInterval: any;
+  private liveContentInterval: any;
+  private liveContentGeneration = 0;
+  private _liveEntry: ZappEntry | null = null;
   private liveMetadataUpdateInterval: any;
   private releasePlayerObserver?: () => void;
   readonly entry: ZappEntry;
@@ -86,41 +85,140 @@ export class OverlaysObserver {
     this.player = player;
     this.entry = player.getEntry();
 
-    this.titleSummarySubject = new BehaviorSubject<TitleSummaryEvent>({
-      title: this.entry?.title || "",
-      summary: this.entry?.summary || "",
-    });
-
     this.liveMetadataSubject = new BehaviorSubject<LiveMetadataEvent>(
       this.entry?.extensions?.liveMetadata || null
     );
 
     this.chapterMarkerEvents = this.prepareChapterMarkers();
     this.releasePlayerObserver = this.subscribeToPlayerEvents();
-    this.feedUrl = "";
-    this.reloadData = () => {};
-    this.updateTitleAndDescription = () => {};
-    this.feedDataInterval = null;
+    this.liveContentInterval = null;
     this.liveMetadataUpdateInterval = null;
     void this.preparePlayNext();
     void this.prepareLiveMetadata();
   }
 
-  private setupFeedDataInterval(interval: number) {
-    if (this.feedUrl && this.reloadData && this.updateTitleAndDescription) {
-      this.feedDataInterval = setInterval(() => {
-        this.reloadData();
-      }, interval * 1000);
+  /**
+   * Polls the live feed and pushes each loaded entry into the player, which
+   * re-resolves its Title/Subtitle and publishes on its content channel.
+   *
+   * Runs entirely outside React: `loadFeedEntry` builds its request through
+   * `RequestBuilder.setUrl`, which inflates URL macros with the entry and
+   * screen contexts, so no `useInflatedUrl` is needed. `prepareLiveMetadata`
+   * below already polls this way.
+   */
+  public startLiveContentUpdates() {
+    this.stopLiveContentUpdates();
+
+    if (!this.player?.isLive?.()) {
+      log_debug("startLiveContentUpdates: Player is not live. Skipping...");
+
+      return;
     }
+
+    const feedUrl = this.getLiveContentFeedUrl();
+
+    if (!feedUrl) {
+      log_debug(
+        "startLiveContentUpdates: Entry carries no live channel feed. Skipping..."
+      );
+
+      return;
+    }
+
+    const intervalSeconds = this.getLiveContentUpdateInterval();
+
+    // Clearing the interval cannot cancel a request already in flight, so each
+    // run carries the generation it started in. A response that arrives after
+    // a stop or a restart belongs to a channel that is no longer playing and
+    // is dropped, rather than publishing the previous programme's title over
+    // the current one.
+    const generation = ++this.liveContentGeneration;
+
+    const load = async () => {
+      try {
+        const entry = await loadFeedEntry(feedUrl, this.entry);
+
+        if (generation !== this.liveContentGeneration) {
+          return;
+        }
+
+        this._liveEntry = entry;
+        this.player.publishContent();
+      } catch {
+        // `loadFeedEntry` already logs the failure. Keep whatever content is
+        // currently published rather than blanking the title on a transient
+        // network error.
+      }
+    };
+
+    void load();
+
+    this.liveContentInterval = setInterval(load, intervalSeconds * 1000);
   }
 
-  public clearFeedDataInterval() {
-    if (this.feedDataInterval) {
-      clearInterval(this.feedDataInterval);
-      this.feedDataInterval = null;
+  public stopLiveContentUpdates() {
+    // Invalidates any in-flight request as well as the interval.
+    this.liveContentGeneration += 1;
+
+    if (this.liveContentInterval) {
+      clearInterval(this.liveContentInterval);
+      this.liveContentInterval = null;
     }
   }
 
+  /**
+   * The programme feed for the channel currently playing. Derived here rather
+   * than by the caller so no UI component needs to know where a live channel
+   * keeps its feed, or that the URL has to be rewritten to reach the
+   * programme ("livePage") view of it.
+   */
+  private getLiveContentFeedUrl(): string {
+    const channelSrc =
+      this.player.getEntry()?.extensions?.live?.channel_src ?? "";
+
+    return channelSrc.replace(new RegExp("subClass", "g"), "livePage");
+  }
+
+  /**
+   * Falls back to the manifest's own `initial_value` when the app ships no
+   * value: `intervalSeconds * 1000` would otherwise be `NaN`, and
+   * `setInterval` treats `NaN` as `0` - a tight loop hammering the feed.
+   */
+  private getLiveContentUpdateInterval(): number {
+    const configured =
+      this.player.getPluginConfiguration()?.audio_live_player_update_interval;
+
+    const seconds = Number(configured);
+
+    return Number.isFinite(seconds) && seconds > 0
+      ? seconds
+      : DEFAULT_LIVE_CONTENT_UPDATE_INTERVAL_SECONDS;
+  }
+
+  /**
+   * The entry most recently loaded from the live channel feed - the programme
+   * currently on air, as opposed to `player.entry`, which is the channel and
+   * stays put for the whole listening session.
+   *
+   * Read by `Player.getContent()`, which prefers it over the player's own
+   * entry. It lives here rather than on `Player` because it is live-feed
+   * state, like `liveMetadata` and play-next: a VOD or cast player never has
+   * an observer at all, so it never carries this either.
+   */
+  public get liveEntry(): ZappEntry | null {
+    return this._liveEntry;
+  }
+
+  /**
+   * Called by `Player`'s `entry` setter. The live entry is an overlay on the
+   * current entry, so its lifetime is scoped to that entry: without this, a
+   * programme from a previous channel would shadow the new one forever - the
+   * content would change but the title would not.
+   */
+  public clearLiveEntry() {
+    this._liveEntry = null;
+  }
+
   public clearLiveMetadataUpdateInterval() {
     if (this.liveMetadataUpdateInterval) {
       clearInterval(this.liveMetadataUpdateInterval);
@@ -128,22 +226,6 @@ export class OverlaysObserver {
     }
   }
 
-  public setFeedDataHandlers(
-    feedUrl: string,
-    reloadData: () => void,
-    interval: number,
-    updateTitleAndDescription: (data: any) => void
-  ) {
-    this.feedUrl = feedUrl;
-    this.reloadData = reloadData;
-    this.updateTitleAndDescription = updateTitleAndDescription;
-    this.setupFeedDataInterval(interval);
-  }
-
-  public getTitleSummaryObservable(): Observable<TitleSummaryEvent> {
-    return this.titleSummarySubject.asObservable().pipe(distinctUntilChanged());
-  }
-
   hidePlayNext = () => {
     this.isPlayNextSuppressed = true;
     this.playNextSubject.next(null);
@@ -395,9 +477,8 @@ export class OverlaysObserver {
     this.chapterSubject.complete();
     this.playNextSubject.complete();
     this.liveMetadataSubject.complete();
-    this.titleSummarySubject.complete();
     this.releasePlayerObserver?.();
-    this.clearFeedDataInterval();
+    this.stopLiveContentUpdates();
     this.clearLiveMetadataUpdateInterval();
     this.releasePlayerObserver = null;
   };