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

package/appUtils/playerManager/player.ts

@@ -1,9 +1,22 @@
 import * as R from "ramda";
-import { BehaviorSubject } from "rxjs";
+import { BehaviorSubject, Observable } from "rxjs";
+import { distinctUntilChanged } from "rxjs/operators";
 import { isEmptyOrNil } from "@applicaster/zapp-react-native-utils/cellUtils";
 import { createLogger, utilsLogger } from "../../logger";
-import { getBoolFromConfigValue } from "../../configurationUtils";
-import { PlayerRole, SharedPlayerCallBacksKeys } from "./conts";
+import {
+  getBoolFromConfigValue,
+  imageSrcFromMediaItem,
+} from "../../configurationUtils";
+// Imported from the leaf modules rather than the `playerUtils` barrel: that
+// barrel imports `playerManager`, so going through it would create a require
+// cycle (playerManager/index -> player -> playerUtils/index -> playerManager).
+import {
+  resolvePlayerTitleSubtitle,
+  getPlayerContentDataKeys,
+} from "../../playerUtils/resolvePlayerTitleSubtitle";
+import { isAudioItem } from "../../playerUtils/isAudioItem";
+import { isTV } from "../../reactUtils";
+import { PlayerRole, SharedPlayerCallBacksKeys } from "./const";
 import { OverlaysObserver } from "./OverlayObserver/OverlaysObserver";
 import { TVSeekController } from "../../reactHooks/player/TVSeekControlller/TVSeekController";
 
@@ -19,6 +32,23 @@ export declare type PlayerControllerListenerData = {
   id: string;
   listener: QuickBrickPlayer.SharedPlayerCallBacks;
 };
+
+/**
+ * The player's resolved Title/Subtitle text, published by the player the same
+ * way duration and progress are. Consumers render these values as-is rather
+ * than reading `entry` or the plugin configuration themselves.
+ */
+export type PlayerContent = {
+  title: Option<string | number>;
+  summary: Option<string | number>;
+  /**
+   * Cover art for the content currently playing. Published alongside the text
+   * (rather than read from `entry` by whoever needs it) so it follows the same
+   * entry: on live audio that means the programme's own artwork, refreshed
+   * with every feed poll, instead of the channel's.
+   */
+  imageUrl: Option<string>;
+};
 /**
  * Player Instance Controller
  * Instance exposes utility methods that will help set or get state
@@ -45,6 +75,7 @@ export class Player {
   readonly playerRole: PlayerRole = PlayerRole.Unspecified;
   private overlaysObserver?: OverlaysObserver | null;
   private entryObservable?: BehaviorSubject<ZappEntry> | null;
+  private contentSubject?: BehaviorSubject<PlayerContent> | null;
 
   protected listeners: {
     [key: string]: QuickBrickPlayer.SharedPlayerCallBacks;
@@ -58,7 +89,17 @@ export class Player {
 
   set entry(newEntry: ZappEntry | null) {
     this._entry = newEntry;
+    // 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.
+    this.overlaysObserver?.clearLiveEntry();
     this.entryObservable?.next(newEntry);
+    // Optional chaining short-circuits the whole call expression, so
+    // `getContent()` is NOT evaluated while no subscriber exists. That
+    // matters: `PlayerNative` assigns `this.entry` in its constructor, before
+    // subclass arrow-function properties such as `getPluginConfiguration`
+    // have been assigned.
+    this.contentSubject?.next(this.getContent());
   }
 
   constructor(props) {
@@ -117,6 +158,77 @@ export class Player {
     return this.entryObservable;
   };
 
+  /**
+   * The player's resolved Title/Subtitle.
+   *
+   * Resolved on demand rather than cached: the plugin configuration arrives
+   * asynchronously on both the native and cast paths, so a value computed once
+   * at entry-set time would be stale for whichever arrives first.
+   *
+   * Every fallback (no config, empty/whitespace key, unresolvable key, key
+   * resolving to an empty string or to a non-string/non-number) lives in
+   * `resolvePlayerContentText` and is never reimplemented here.
+   */
+  getContent = (): PlayerContent => {
+    // Live audio keeps playing one channel while the programme on air
+    // changes, so the observer's freshly-loaded programme entry wins when
+    // there is one. Read through `?.` so this never constructs an observer:
+    // a VOD or cast player has none and falls straight through to its entry.
+    const entry = this.overlaysObserver?.liveEntry ?? this.entry;
+
+    return {
+      ...resolvePlayerTitleSubtitle({
+        entry,
+        pluginConfiguration: this.getPluginConfiguration(),
+        dataKeys: getPlayerContentDataKeys({
+          isTV: isTV(),
+          isAudioContent: isAudioItem(entry),
+        }),
+      }),
+      // Same selection Android's `EntryHelpers.extractCoverImage` makes:
+      // prefer the `image_base` media item, otherwise the first one available.
+      // Reused rather than reimplemented so the two platforms cannot drift.
+      imageUrl: entry ? imageSrcFromMediaItem(entry, []) : undefined,
+    };
+  };
+
+  /**
+   * Created lazily, like `entryObservable`. An eagerly created subject would
+   * resolve during `PlayerNative`'s constructor and call a not-yet-assigned
+   * `getPluginConfiguration`.
+   *
+   * The seed is produced by calling the resolver, never from raw entry fields:
+   * a `BehaviorSubject` replays its seed synchronously on subscribe, so a raw
+   * seed would overwrite correctly-resolved text at mount.
+   */
+  getContentObservable = (): Observable<PlayerContent> => {
+    if (!this.contentSubject) {
+      this.contentSubject = new BehaviorSubject<PlayerContent>(
+        this.getContent()
+      );
+    }
+
+    return this.contentSubject.asObservable().pipe(
+      // `resolvePlayerTitleSubtitle` returns a fresh object every call, so
+      // reference equality would never dedupe. Compare by value.
+      distinctUntilChanged(
+        (previous, next) =>
+          previous.title === next.title &&
+          previous.summary === next.summary &&
+          previous.imageUrl === next.imageUrl
+      )
+    );
+  };
+
+  /**
+   * Re-resolves and publishes the current content. Called when something the
+   * resolution depends on changed without `entry` itself being reassigned -
+   * today that is the observer swapping in a newly-loaded live programme.
+   */
+  publishContent = () => {
+    this.contentSubject?.next(this.getContent());
+  };
+
   /**
    * ---------------------------------------- PLAYER SETTERS GETTERS ----------------------------------------
    * These methods let you get information about the content / ad playing

package/appUtils/playerManager/playerFactory.ts

@@ -1,7 +1,7 @@
 import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
 import { Player } from "./player";
-import { PlayerRole } from "./conts";
+import { PlayerRole } from "./const";
 
 type PlayerFactoryItem = {
   Component: any;

package/appUtils/playerManager/playerNative.ts

@@ -3,7 +3,7 @@ import { isEmptyOrNil } from "@applicaster/zapp-react-native-utils/cellUtils";
 import { createLogger, utilsLogger } from "../../logger";
 import { Player } from "./player";
 import { findNodeHandle } from "react-native";
-import { PlayerRole } from "./conts";
+import { PlayerRole } from "./const";
 import { toBooleanWithDefaultFalse } from "../../booleanUtils";
 import { RNPlayerManager } from "./nativePlayerManager";
 
@@ -296,9 +296,11 @@ export class PlayerNative extends Player {
     }, listeners);
   };
 
-  isAudioItem = () =>
-    this.getEntry()?.content?.type?.includes?.("audio") ||
-    this.getEntry()?.type?.value === "audio";
+  isAudioItem = (): boolean =>
+    Boolean(
+      this.getEntry()?.content?.type?.includes?.("audio") ||
+        this.getEntry()?.type?.value?.includes?.("audio")
+    );
 
   isFullScreenSupported = (): boolean => {
     const config = this.getConfig();

package/appUtils/playerManager/usePlayerContent.tsx

@@ -0,0 +1,43 @@
+import * as React from "react";
+import { Player, PlayerContent } from "./player";
+import { usePlayer } from "./usePlayer";
+
+const EMPTY_CONTENT: PlayerContent = {
+  title: null,
+  summary: null,
+  imageUrl: null,
+};
+
+/**
+ * Subscribes to the player's resolved Title/Subtitle, the same way
+ * `usePlayerState` subscribes to playback state. Modeled on that hook
+ * deliberately: one React bridge pattern for everything the manager publishes.
+ *
+ * Passing no `playerId` uses the active player, which is the right default -
+ * only one player instance is live at a time. `usePlayer` additionally swaps
+ * to the casting receiver while casting, so this follows cast handover
+ * automatically.
+ */
+export const usePlayerContent = (playerId?: string): PlayerContent => {
+  const player: Player = usePlayer(playerId);
+
+  const [content, setContent] = React.useState<PlayerContent>(
+    () => player?.getContent() ?? EMPTY_CONTENT
+  );
+
+  React.useEffect(() => {
+    if (!player) {
+      setContent(EMPTY_CONTENT);
+
+      return;
+    }
+
+    const subscription = player
+      .getContentObservable()
+      .subscribe((next) => setContent(next));
+
+    return () => subscription.unsubscribe();
+  }, [player]);
+
+  return content;
+};

package/appUtils/playerManager/usePlayerControllerSetup.tsx

@@ -3,7 +3,7 @@ import { useConfiguration } from "../../reactHooks/useConfiguration";
 import { useEffect } from "react";
 import { playerManager } from "./index";
 import { useValidatePlayerConfig } from "../../playerUtils/useValidatePlayerConfig";
-import { PlayerRole } from "./conts";
+import { PlayerRole } from "./const";
 import { isAppleTV } from "@applicaster/zapp-react-native-ui-components/Helpers/Platform";
 import { TVSeekController } from "../../reactHooks/player/TVSeekControlller/TVSeekController";
 import { KeyInputHandler } from "../keyInputHandler/KeyInputHandler";

package/appUtils/playerManager/userLanguagePreference.ts

@@ -1,7 +1,7 @@
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 import { createLogger, utilsLogger } from "../../logger";
-import { userPreferencesNamespace } from "./conts";
+import { userPreferencesNamespace } from "./const";
 
 export const preferredAudioLanguageStorageKey = "preferred_audio_language";
 

package/arrayUtils/__tests__/{anyThruthy.test.ts → anyTruthy.test.ts}

@@ -21,4 +21,12 @@ describe("anyTruthy", () => {
     expect(anyTruthy([true])).toBe(true);
     expect(anyTruthy([false])).toBe(false);
   });
+
+  it("should return true when the first value is true", () => {
+    expect(anyTruthy([true, false, false])).toBe(true);
+  });
+
+  it("should return true when only the last value is true", () => {
+    expect(anyTruthy([false, false, true])).toBe(true);
+  });
 });

package/arrayUtils/__tests__/arrayUtils.test.ts

@@ -28,6 +28,30 @@ describe("shiftArray", () => {
     expect(shiftArray(negativeOffset, array)).toMatchSnapshot();
     expect(shiftArray(2 * negativeOffset, array)).toMatchSnapshot();
   });
+
+  it("returns a new array and does not mutate the original", () => {
+    const original = ["a", "b", "c"];
+    const result = shiftArray(1, original);
+
+    expect(result).toEqual(["b", "c", "a"]);
+    expect(result).not.toBe(original);
+    expect(original).toEqual(["a", "b", "c"]);
+  });
+
+  it("returns an empty array when shifting an empty array", () => {
+    expect(shiftArray(1, [])).toEqual([]);
+    expect(shiftArray(-1, [])).toEqual([]);
+  });
+
+  it("returns the same order for a single-element array", () => {
+    expect(shiftArray(1, [1])).toEqual([1]);
+    expect(shiftArray(-1, [1])).toEqual([1]);
+  });
+
+  it("handles an offset equal to the array length", () => {
+    expect(shiftArray(4, array)).toEqual(array);
+    expect(shiftArray(-4, array)).toEqual(array);
+  });
 });
 
 describe("removeItemFromList", () => {
@@ -58,6 +82,38 @@ describe("removeItemFromList", () => {
       arrayOfObjects
     );
   });
+
+  it("returns the same reference when the item is not found", () => {
+    const list = [1, 2, 3];
+
+    expect(removeItemFromList(4, list)).toBe(list);
+  });
+
+  it("returns a new array when the item is removed", () => {
+    const list = [1, 2, 3];
+    const result = removeItemFromList(2, list);
+
+    expect(result).toEqual([1, 3]);
+    expect(result).not.toBe(list);
+    expect(list).toEqual([1, 2, 3]);
+  });
+
+  it("removes only the first occurrence of a duplicate item", () => {
+    expect(removeItemFromList(2, [1, 2, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it("removes the first and last items", () => {
+    expect(removeItemFromList(1, [1, 2, 3])).toEqual([2, 3]);
+    expect(removeItemFromList(3, [1, 2, 3])).toEqual([1, 2]);
+  });
+
+  it("returns an empty list when removing from an empty list", () => {
+    expect(removeItemFromList(1, [])).toEqual([]);
+  });
+
+  it("returns an empty list when removing the only item", () => {
+    expect(removeItemFromList(1, [1])).toEqual([]);
+  });
 });
 
 describe("mapPromises", () => {
@@ -84,145 +140,146 @@ describe("mapPromises", () => {
     values.forEach((value) => {
       expect(promiseFn).toHaveBeenNthCalledWith(value, value, value - 1);
     });
-  });
 
-  describe("removeItemFromList", () => {
-    it("removes an item from a list", () => {
-      const arrayOfPrimitives = [1, 2, 3, 4];
-      expect(removeItemFromList(1, arrayOfPrimitives)).toEqual([2, 3, 4]);
+    expect.assertions(values.length + 1);
+  });
 
-      const arrayOfObjects = [
-        { prop: "value1" },
-        { prop: "value2" },
-        { prop: "value3" },
-      ];
+  it("resolves to an empty array for an empty input", async () => {
+    await expect(mapPromises(promiseFn, [])).resolves.toEqual([]);
+    expect(promiseFn).not.toHaveBeenCalled();
+  });
 
-      expect(removeItemFromList({ prop: "value2" }, arrayOfObjects)).toEqual([
-        { prop: "value1" },
-        { prop: "value3" },
-      ]);
-    });
+  it("rejects when any promise rejects", async () => {
+    const failingFn = jest.fn((num) =>
+      num === 2 ? Promise.reject(new Error("fail")) : Promise.resolve(num)
+    );
 
-    it("leaves the list as is if the item is not found", () => {
-      const arrayOfObjects = [
-        { prop: "value1" },
-        { prop: "value2" },
-        { prop: "value3" },
-      ];
+    await expect(mapPromises(failingFn, [1, 2, 3])).rejects.toThrow("fail");
+  });
+});
 
-      expect(removeItemFromList({ prop: "value4" }, arrayOfObjects)).toEqual(
-        arrayOfObjects
-      );
+describe("reducePromises", () => {
+  const promiseFn = jest.fn((current, previous, index, cb) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(previous + current);
+        cb?.(index);
+      }, 1);
     });
   });
 
-  describe("mapPromises", () => {
-    const promiseFn = jest.fn((num) => Promise.resolve(num + 1));
+  beforeEach(() => {
+    promiseFn.mockClear();
+  });
 
-    beforeEach(() => {
-      promiseFn.mockClear();
-    });
+  it("is a curried function; and returns the reduced promise values", async () => {
+    const promiseReducer = reducePromises(promiseFn);
 
-    it("is a curried function, and returns an array of resolved values", async () => {
-      const promiseMapper = mapPromises(promiseFn);
-      const values = [1, 2, 3];
+    const initialValue = 0;
+    const values = [1, 2, 3];
+    const sumOfValues = initialValue + values.reduce((a, b) => a + b, 0);
 
-      expect(typeof promiseMapper).toBe("function");
-      await expect(promiseMapper(values)).resolves.toEqual([2, 3, 4]);
-    });
+    expect(typeof promiseReducer).toBe("function");
 
-    it("calls all the promises immediately", () => {
-      const values = [1, 2, 3];
+    await expect(promiseReducer(initialValue, values)).resolves.toEqual(
+      sumOfValues
+    );
+  });
 
-      mapPromises(promiseFn, values);
-      expect(promiseFn).toHaveBeenCalledTimes(values.length);
+  it("calls promises one after the other", (done) => {
+    const values = [1, 2, 3];
+    const previousValues = [0, 1, 3];
+
+    reducePromises(
+      (current, previous, index) =>
+        promiseFn(current, previous, index, (index) => {
+          expect(promiseFn).toHaveBeenCalledTimes(index + 1);
+
+          expect(promiseFn).toHaveBeenNthCalledWith(
+            index + 1,
+            values[index],
+            previousValues[index],
+            index,
+            expect.any(Function)
+          );
+
+          if (index === 2) done();
+        }),
+      0,
+      values
+    );
 
-      values.forEach((value) => {
-        expect(promiseFn).toHaveBeenNthCalledWith(value, value, value - 1);
-      });
+    expect.assertions(values.length * 2);
+  });
 
-      expect.assertions(values.length + 1);
-    });
+  it("returns the initial value for an empty list", async () => {
+    await expect(reducePromises(promiseFn, 10, [])).resolves.toBe(10);
+    expect(promiseFn).not.toHaveBeenCalled();
   });
 
-  describe("reduce promises", () => {
-    const promiseFn = jest.fn((current, previous, index, cb) => {
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(previous + current);
-          cb?.(index);
-        }, 1);
-      });
-    });
+  it("reduces a single-element list", async () => {
+    await expect(reducePromises(promiseFn, 5, [2])).resolves.toBe(7);
+  });
 
-    beforeEach(() => {
-      promiseFn.mockClear();
+  it("rejects when a promise rejects", async () => {
+    const failingFn = jest.fn(async (current, previous) => {
+      if (current === 2) throw new Error("reduce fail");
+
+      return previous + current;
     });
 
-    it("is a curried function; and returns the reduced promise values", async () => {
-      const promiseReducer = reducePromises(promiseFn);
+    await expect(reducePromises(failingFn, 0, [1, 2, 3])).rejects.toThrow(
+      "reduce fail"
+    );
+  });
+});
+
+describe("mapAndSplit", () => {
+  it("maps over a list of values and split it in chunks", () => {
+    const values = new Array(20).fill(0).map((_, i) => i);
+
+    const alphabet = Array.from(Array(26)).map((_, i) =>
+      String.fromCharCode(i + 65)
+    );
 
-      const initialValue = 0;
-      const values = [1, 2, 3];
-      const sumOfValues = initialValue + values.reduce((a, b) => a + b, 0);
+    const getLetterForInt = (num) => alphabet[num];
+    const chunkSize = 5;
 
-      expect(typeof promiseReducer).toBe("function");
+    const result = mapAndSplit<number, string>(
+      getLetterForInt,
+      chunkSize
+    )(values);
 
-      await expect(promiseReducer(initialValue, values)).resolves.toEqual(
-        sumOfValues
-      );
-    });
+    expect(result.length).toBe(values.length / chunkSize);
 
-    it("calls promises one after the other", (done) => {
-      const values = [1, 2, 3];
-      const previousValues = [0, 1, 3];
-
-      reducePromises(
-        (current, previous, index) =>
-          promiseFn(current, previous, index, (index) => {
-            expect(promiseFn).toHaveBeenCalledTimes(index + 1);
-
-            expect(promiseFn).toHaveBeenNthCalledWith(
-              index + 1,
-              values[index],
-              previousValues[index],
-              index,
-              expect.any(Function)
-            );
-
-            if (index === 2) done();
-          }),
-        0,
-        values
-      );
-
-      expect.assertions(values.length * 2);
+    result.forEach((chunk, chunkIndex) => {
+      chunk.forEach((value, index) => {
+        expect(value).toBe(alphabet[chunkIndex * chunkSize + index]);
+      });
     });
   });
 
-  describe("mapAndSplit", () => {
-    it("maps over a list of values and split it in chunks", () => {
-      const values = new Array(20).fill(0).map((_, i) => i);
+  it("is a curried function", () => {
+    const mapper = (n: number) => n * 2;
+    const splitBy2 = mapAndSplit(mapper, 2);
 
-      const alphabet = Array.from(Array(26)).map((_, i) =>
-        String.fromCharCode(i + 65)
-      );
+    expect(typeof splitBy2).toBe("function");
 
-      const getLetterForInt = (num) => alphabet[num];
-      const chunkSize = 5;
+    expect(splitBy2([1, 2, 3, 4])).toEqual([
+      [2, 4],
+      [6, 8],
+    ]);
+  });
 
-      const result = mapAndSplit<number, string>(
-        getLetterForInt,
-        chunkSize
-      )(values);
+  it("returns an empty list for an empty input", () => {
+    expect(mapAndSplit((n: number) => n, 2)([])).toEqual([]);
+  });
 
-      expect(result.length).toBe(values.length / chunkSize);
+  it("puts remaining items in a final smaller chunk", () => {
+    expect(mapAndSplit((n: number) => n, 2)([1, 2, 3])).toEqual([[1, 2], [3]]);
+  });
 
-      result.forEach((chunk, chunkIndex) => {
-        chunk.forEach((value, index) => {
-          expect(value).toBe(alphabet[chunkIndex * chunkSize + index]);
-        });
-      });
-    });
+  it("returns a single chunk when chunk size exceeds the list length", () => {
+    expect(mapAndSplit((n: number) => n * 10, 10)([1, 2])).toEqual([[10, 20]]);
   });
 });

package/arrayUtils/__tests__/isEmptyArray.test.ts

@@ -60,4 +60,15 @@ describe("isEmptyArray", () => {
 
     expect(isEmptyArray(value)).toBe(false);
   });
+
+  it("array with falsy values is not empty", () => {
+    expect(isEmptyArray([0])).toBe(false);
+    expect(isEmptyArray([false])).toBe(false);
+    expect(isEmptyArray([null])).toBe(false);
+    expect(isEmptyArray([undefined])).toBe(false);
+  });
+
+  it("nested empty array is not empty", () => {
+    expect(isEmptyArray([[]])).toBe(false);
+  });
 });

package/arrayUtils/__tests__/isFilledArray.test.ts

@@ -60,4 +60,16 @@ describe("isFilledArray", () => {
 
     expect(isFilledArray(value)).toBe(false);
   });
+
+  it("array with falsy values is filled", () => {
+    expect(isFilledArray([0])).toBe(true);
+    expect(isFilledArray([false])).toBe(true);
+    expect(isFilledArray([null])).toBe(true);
+    expect(isFilledArray([undefined])).toBe(true);
+    expect(isFilledArray([""])).toBe(true);
+  });
+
+  it("nested empty array is filled", () => {
+    expect(isFilledArray([[]])).toBe(true);
+  });
 });

package/arrayUtils/__tests__/isFirst.test.ts

@@ -0,0 +1,17 @@
+import { isFirst } from "..";
+
+describe("isFirst", () => {
+  it("returns true for index 0", () => {
+    expect(isFirst(0)).toBe(true);
+  });
+
+  it("returns false for positive indexes", () => {
+    expect(isFirst(1)).toBe(false);
+    expect(isFirst(10)).toBe(false);
+  });
+
+  it("returns true for negative indexes", () => {
+    expect(isFirst(-1)).toBe(true);
+    expect(isFirst(-100)).toBe(true);
+  });
+});

package/arrayUtils/__tests__/isIndexInRange.test.ts

@@ -56,4 +56,18 @@ describe("isIndexInRange", () => {
 
     expect(isIndexInRange(index, length)).toBe(false);
   });
+
+  it("single-element list", () => {
+    expect(isIndexInRange(0, 1)).toBe(true);
+    expect(isIndexInRange(1, 1)).toBe(false);
+  });
+
+  it("negative length is out of range", () => {
+    expect(isIndexInRange(0, -1)).toBe(false);
+    expect(isIndexInRange(0, -5)).toBe(false);
+  });
+
+  it("middle index is in range", () => {
+    expect(isIndexInRange(1, 3)).toBe(true);
+  });
 });