@applicaster/zapp-react-native-utils 16.0.0-alpha.1803022420 → 16.0.0-alpha.1816065263

package/playerUtils/contentDataKeys.ts

@@ -0,0 +1,134 @@
+import { get } from "@applicaster/zapp-react-native-utils/utils";
+import { isNotEmptyString } from "@applicaster/zapp-react-native-utils/stringUtils";
+
+type GetValue = <T = string | number | null>(key: string) => T;
+
+export type PlayerContentField = "title" | "subtitle";
+
+const CUSTOM_SOURCE = "other";
+
+const DEFAULT_ENTRY_PATH: Record<PlayerContentField, string> = {
+  title: "title",
+  subtitle: "summary",
+};
+
+/**
+ * Configuration keys backing each field, exported so callers can build a
+ * stable configuration getter without duplicating the key strings.
+ */
+export const PLAYER_CONTENT_DATA_KEYS: Record<
+  PlayerContentField,
+  { source: string; custom: string }
+> = {
+  title: {
+    source: "title_data_key_source",
+    custom: "title_custom_data_key",
+  },
+  subtitle: {
+    source: "subtitle_data_key_source",
+    custom: "subtitle_custom_data_key",
+  },
+};
+
+export type PlayerContentDataKeys = Record<
+  PlayerContentField,
+  { source: string; custom: string }
+>;
+
+/**
+ * TV keeps separate Title/Summary configuration per media type. Mobile has
+ * no equivalent split - it shares a single `PLAYER_CONTENT_DATA_KEYS` set
+ * for both video and audio - which is why these sets carry a media-type
+ * prefix (`video_player_*` / `audio_player_*`) and mobile's doesn't.
+ */
+export const VIDEO_PLAYER_CONTENT_DATA_KEYS: PlayerContentDataKeys = {
+  title: {
+    source: "video_player_title_data_key_source",
+    custom: "video_player_title_custom_data_key",
+  },
+  subtitle: {
+    source: "video_player_summary_data_key_source",
+    custom: "video_player_summary_custom_data_key",
+  },
+};
+
+export const AUDIO_PLAYER_CONTENT_DATA_KEYS: PlayerContentDataKeys = {
+  title: {
+    source: "audio_player_title_data_key_source",
+    custom: "audio_player_title_custom_data_key",
+  },
+  subtitle: {
+    source: "audio_player_summary_data_key_source",
+    custom: "audio_player_summary_custom_data_key",
+  },
+};
+
+/**
+ * Builds a GetValue over a plugin configuration object. Callers that hold a
+ * configuration rather than a `value` closure use this instead of hand-rolling
+ * the lookup.
+ */
+export const createConfigValueGetter =
+  (configuration: Option<Record<string, any>>): GetValue =>
+  <T>(key: string) =>
+    (configuration?.[key] ?? null) as T;
+
+type ResolvePlayerContentTextParams = {
+  entry: Option<ZappEntry>;
+  field: PlayerContentField;
+  value: GetValue;
+  dataKeys?: PlayerContentDataKeys;
+};
+
+/**
+ * Resolves the text shown for the player's Title or Subtitle.
+ *
+ * Unless the customer explicitly selected the "Other" data key source and
+ * supplied a resolvable key, this returns the hardcoded entry field the
+ * player has always used, which keeps existing apps unchanged.
+ */
+export const resolvePlayerContentText = ({
+  entry,
+  field,
+  value,
+  dataKeys,
+}: ResolvePlayerContentTextParams): Option<string | number> => {
+  if (!entry) {
+    return undefined;
+  }
+
+  const defaultValue = get(entry, DEFAULT_ENTRY_PATH[field]);
+
+  const { source, custom } = (dataKeys ?? PLAYER_CONTENT_DATA_KEYS)[field];
+
+  if (value(source) !== CUSTOM_SOURCE) {
+    return defaultValue;
+  }
+
+  const customKey = value<Option<string>>(custom);
+
+  // Only trim when the config value really is a string - it comes from
+  // free-text Studio configuration and can be a non-string (or null/undefined),
+  // and calling .trim() on that would throw.
+  const trimmedKey = isNotEmptyString(customKey) ? customKey.trim() : customKey;
+
+  if (!isNotEmptyString(trimmedKey)) {
+    return defaultValue;
+  }
+
+  const customValue = get(entry, trimmedKey);
+
+  if (customValue === null || customValue === undefined || customValue === "") {
+    return defaultValue;
+  }
+
+  // The key is free text in the Studio, so it can easily land on an object or
+  // an array (`extensions.show` instead of `extensions.show.name`). Those
+  // reach <Text> untouched and throw "Objects are not valid as a React child",
+  // so they fall back like every other unusable key.
+  if (typeof customValue !== "string" && typeof customValue !== "number") {
+    return defaultValue;
+  }
+
+  return customValue;
+};

package/playerUtils/index.ts

@@ -9,6 +9,26 @@ import { Dimensions } from "react-native";
 
 export { getPlayerActionButtons } from "./getPlayerActionButtons";
 
+export {
+  resolvePlayerContentText,
+  PLAYER_CONTENT_DATA_KEYS,
+  VIDEO_PLAYER_CONTENT_DATA_KEYS,
+  AUDIO_PLAYER_CONTENT_DATA_KEYS,
+  createConfigValueGetter,
+} from "./contentDataKeys";
+
+export type {
+  PlayerContentField,
+  PlayerContentDataKeys,
+} from "./contentDataKeys";
+
+export {
+  resolvePlayerTitleSubtitle,
+  getPlayerContentDataKeys,
+} from "./resolvePlayerTitleSubtitle";
+
+export { isAudioItem } from "./isAudioItem";
+
 export const HLS_MIME_TYPES = [
   "application/x-mpegURL",
   "application/vnd.apple.mpegurl",
@@ -102,21 +122,6 @@ export const isVideoItem = (item: Option<ZappEntry>) => {
   );
 };
 
-export const isAudioItem = (item: Option<ZappEntry>) => {
-  if (
-    isString(item?.content?.type) &&
-    item?.content?.type?.includes?.("audio")
-  ) {
-    return true;
-  }
-
-  if (isString(item?.type?.value) && item?.type?.value?.includes?.("audio")) {
-    return true;
-  }
-
-  return false;
-};
-
 export const isInlineTV = (screenData) => {
   return isTV() && isFilledArray(screenData?.ui_components);
 };

package/playerUtils/isAudioItem.ts

@@ -0,0 +1,26 @@
+import { isString } from "@applicaster/zapp-react-native-utils/typeGuards";
+
+/**
+ * Lives in its own module rather than in `playerUtils/index.ts` because that
+ * barrel imports `playerManager`, and files inside `appUtils/playerManager/`
+ * need this helper. Importing it from the barrel there would create a require
+ * cycle:
+ *
+ *   playerManager/index -> player -> playerUtils/index -> playerManager/index
+ *
+ * Re-exported from the barrel, so existing importers are unaffected.
+ */
+export const isAudioItem = (item: Option<ZappEntry>) => {
+  if (
+    isString(item?.content?.type) &&
+    item?.content?.type?.includes?.("audio")
+  ) {
+    return true;
+  }
+
+  if (isString(item?.type?.value) && item?.type?.value?.includes?.("audio")) {
+    return true;
+  }
+
+  return false;
+};

package/playerUtils/resolvePlayerTitleSubtitle.ts

@@ -0,0 +1,76 @@
+import {
+  createConfigValueGetter,
+  resolvePlayerContentText,
+  VIDEO_PLAYER_CONTENT_DATA_KEYS,
+  AUDIO_PLAYER_CONTENT_DATA_KEYS,
+} from "./contentDataKeys";
+import type { PlayerContentDataKeys } from "./contentDataKeys";
+
+/**
+ * Resolves the player's Title/Subtitle text as raw values (string | number |
+ * null). Called by `Player.getContent()`, which publishes the result on the
+ * player's content channel; every consumer - the mobile/TV transport
+ * controls, `ProgramInfo`, the TV audio player, the Chromecast controller and
+ * the native bridge - reads it from there rather than resolving for itself.
+ *
+ * `dataKeys` selects which Studio-configured key set backs the resolution:
+ * omit it for the default (mobile) `PLAYER_CONTENT_DATA_KEYS` set, or pass
+ * an explicit set (e.g. `VIDEO_PLAYER_CONTENT_DATA_KEYS`) for platforms/content
+ * types that keep separate Studio configuration for this text. Getting the
+ * key set backwards would make one platform read another platform's
+ * configuration, so every caller must be explicit about which set it wants.
+ *
+ * Keeping this in one place is what stops the dot-path / key-set resolution
+ * logic (`resolvePlayerContentText`) from being duplicated per caller.
+ */
+export const resolvePlayerTitleSubtitle = ({
+  entry,
+  pluginConfiguration,
+  dataKeys,
+}: {
+  entry: Option<ZappEntry>;
+  pluginConfiguration: Option<Record<string, any>>;
+  dataKeys?: PlayerContentDataKeys;
+}): {
+  title: Option<string | number>;
+  summary: Option<string | number>;
+} => {
+  const value = createConfigValueGetter(pluginConfiguration);
+
+  const title =
+    resolvePlayerContentText({ entry, field: "title", value, dataKeys }) ??
+    null;
+
+  const summary =
+    resolvePlayerContentText({
+      entry,
+      field: "subtitle",
+      value,
+      dataKeys,
+    }) ?? null;
+
+  return { title, summary };
+};
+
+/**
+ * Picks which Studio-configured key set backs a Title/Subtitle resolution,
+ * from the full three-way choice: TV audio, TV video, or mobile. Each of
+ * those ships separate Studio configuration for this text; getting this
+ * backwards would make one platform (or content type) read another's
+ * configuration.
+ */
+export const getPlayerContentDataKeys = ({
+  isTV,
+  isAudioContent,
+}: {
+  isTV: boolean;
+  isAudioContent: boolean;
+}): PlayerContentDataKeys | undefined => {
+  if (!isTV) {
+    return undefined;
+  }
+
+  return isAudioContent
+    ? AUDIO_PLAYER_CONTENT_DATA_KEYS
+    : VIDEO_PLAYER_CONTENT_DATA_KEYS;
+};

package/reactHooks/feed/__tests__/useInflatedUrl.test.tsx

@@ -242,4 +242,29 @@ describe("useGetUrlInflater", () => {
     const url = result.current(source, mapping);
     expect(url).toBe("https://foo.com/shows/A123?q=user%20query");
   });
+
+  it("handles search queries with apostrophes without HTML entity escaping or URL truncation", () => {
+    const source =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q={{q}}";
+
+    const mapping = {
+      q: { source: "search", property: "q" },
+    };
+
+    const searchContext = getSearchContext("L'aventure", mapping);
+
+    const result = getInflatedDataSourceUrl({
+      source,
+      contexts: {
+        search: searchContext,
+      },
+      mapping,
+    });
+
+    expect(result).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/mobile/search?q=L'aventure"
+    );
+
+    expect(result).not.toContain("'");
+  });
 });

package/reactHooks/layout/index.ts

@@ -49,7 +49,7 @@ export function useStatusBarHeight() {
   });
 }
 
-const getNavbarHeight = () => {
+export const getNavbarHeight = () => {
   return isTV() ? 60 : platformSelect({ ios: 44, android: 56 });
 };
 

package/stringUtils/__tests__/stringUtils.test.js

@@ -122,6 +122,48 @@ describe("inflate string", () => {
       "this is a string with custom separators"
     );
   });
+
+  it("does not HTML-escape search variables containing single quotes or apostrophes", () => {
+    const string = "https://api.example.com/search?q={{search.query}}";
+    const data = { search: { query: "L'aventure" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.example.com/search?q=L'aventure"
+    );
+  });
+
+  it("search context with straight apostrophe", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l'a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l'a"
+    );
+  });
+
+  it("search context with backtick apostrophe", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l`a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l`a"
+    );
+  });
+
+  it("search context with right single quotation mark", () => {
+    const string =
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q={{search.q}}";
+
+    const data = { search: { q: "l’a" } };
+
+    expect(inflateString({ string, data })).toBe(
+      "https://api.pc-cms.tele.quebec/api/applicaster/v1/tv/search?q=l’a"
+    );
+  });
 });
 
 describe("objectToReadableString", () => {

package/stringUtils/index.ts

@@ -72,8 +72,8 @@ const valueIsNull = (value) => () => value === null;
 const encodeHelper = "encodeURL";
 
 const encodeHandlebarsExpressions = R.compose(
-  R.replace(/{{([^}]+)}}/g, (match, p1) =>
-    p1.includes("search") ? match : `{{{${encodeHelper} ${p1}}}}`
+  R.replace(/{{([^}]+)}}/g, (_, p1) =>
+    p1.includes("search") ? `{{{${p1}}}}` : `{{{${encodeHelper} ${p1}}}}`
   )
 );
 

package/zappFrameworkUtils/__tests__/localStorageHelper.test.ts

@@ -0,0 +1,146 @@
+import {
+  batchSaveOwnedValues,
+  batchRemoveOwnedValues,
+} from "../localStorageHelper";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+
+// Mock localStorage
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+    },
+  })
+);
+
+describe("localStorageHelper", () => {
+  const ownershipKey = "test_ownership_key";
+  const ownershipNamespace = "test_namespace";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("addOwnedKeys via batchSaveOwnedValues", () => {
+    it("should add new keys to existing owned keys", async () => {
+      // Setup existing keys in storage
+      const existingKeys = {
+        namespace1: ["key1"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const newValues = {
+        namespace1: { key2: "value2" },
+        namespace2: { key3: "value3" },
+      };
+
+      await batchSaveOwnedValues({
+        storageValues: newValues,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      // Verify localStorage.setItem was called with correct updated keys
+      // Note: order of keys in array might vary depending on Set implementation, but usually insertion order
+      // However, to be safe, we can parse the argument and check contents
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toContain("key1");
+      expect(savedData.namespace1).toContain("key2");
+      expect(savedData.namespace2).toContain("key3");
+    });
+
+    it("should handle empty existing keys", async () => {
+      (localStorage.getItem as jest.Mock).mockResolvedValue(null);
+
+      const newValues = {
+        namespace1: { key1: "value1" },
+      };
+
+      await batchSaveOwnedValues({
+        storageValues: newValues,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toEqual(["key1"]);
+    });
+  });
+
+  describe("removeOwnedKeys via batchRemoveOwnedValues", () => {
+    it("should remove keys from owned keys", async () => {
+      const existingKeys = {
+        namespace1: ["key1", "key2"],
+        namespace2: ["key3"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const keysToRemove = {
+        namespace1: ["key1"],
+      };
+
+      await batchRemoveOwnedValues({
+        storageValues: keysToRemove,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      const lastCall = (localStorage.setItem as jest.Mock).mock.calls.find(
+        (call) => call[0] === ownershipKey
+      );
+
+      expect(lastCall).toBeDefined();
+      const savedData = JSON.parse(lastCall[1]);
+
+      expect(savedData.namespace1).toEqual(["key2"]);
+      expect(savedData.namespace2).toEqual(["key3"]);
+    });
+
+    it("should remove namespace if all keys removed", async () => {
+      const existingKeys = {
+        namespace1: ["key1"],
+      };
+
+      (localStorage.getItem as jest.Mock).mockResolvedValue(
+        JSON.stringify(existingKeys)
+      );
+
+      const keysToRemove = {
+        namespace1: ["key1"],
+      };
+
+      await batchRemoveOwnedValues({
+        storageValues: keysToRemove,
+        ownershipKey,
+        ownershipNamespace,
+      });
+
+      expect(localStorage.removeItem).toHaveBeenCalledWith(
+        ownershipKey,
+        ownershipNamespace
+      );
+    });
+  });
+});

package/zappFrameworkUtils/localStorageHelper.ts

@@ -2,10 +2,10 @@ import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/
 import { isNilOrEmpty } from "../reactUtils/helpers";
 import { parseJsonIfNeeded } from "@applicaster/zapp-react-native-utils/functionUtils";
 import {
-  StorageOwnedValues,
   NamespaceValues,
-  StorageValuesToRemove,
+  StorageOwnedValues,
   StorageValuesToAdd,
+  StorageValuesToRemove,
 } from "./types";
 import { Storage } from "@applicaster/zapp-react-native-bridge/ZappStorage/Storage";
 
@@ -43,10 +43,10 @@ function mapOwnedKeysToAdd(
 ): StorageOwnedValues {
   const mappedData = {};
 
-  Object.keys(storageValues).forEach((namespace: string) => {
+  for (const namespace of Object.keys(storageValues)) {
     const data = storageValues[namespace];
     mappedData[namespace] = Object.keys(data);
-  });
+  }
 
   return mappedData;
 }
@@ -59,6 +59,8 @@ export async function batchSave(
     return false;
   }
 
+  const promises = [];
+
   for (const namespace of Object.keys(storageValues)) {
     const namespaceData = storageValues[namespace];
 
@@ -66,10 +68,12 @@ export async function batchSave(
       const value = namespaceData[key];
 
       if (!isNilOrEmpty(value)) {
-        await storage.setItem(key, value, namespace);
+        promises.push(storage.setItem(key, value, namespace));
       }
     }
   }
+
+  await Promise.all(promises);
 }
 
 export async function batchSaveToLocalStorage(
@@ -82,13 +86,17 @@ export async function batchRemoveFromStorage(
   storageValues: StorageValuesToRemove,
   storage: Storage = localStorage
 ) {
+  const promises = [];
+
   for (const namespace of Object.keys(storageValues)) {
     const namespaceData = storageValues[namespace];
 
     for (const key of namespaceData) {
-      await storage.removeItem(key, namespace);
+      promises.push(storage.removeItem(key, namespace));
     }
   }
+
+  await Promise.all(promises);
 }
 
 export async function batchRemoveFromLocalStorage(
@@ -111,12 +119,12 @@ async function addOwnedKeys({
     ownershipNamespace
   );
 
-  Object.keys(newKeys).forEach(async (namespace: string) => {
+  for (const namespace of Object.keys(newKeys)) {
     const newOwnedKeys: string[] = newKeys[namespace];
     const currentKeys = allStoragedOwnedKeys[namespace] || [];
     const combinedSet = new Set([...currentKeys, ...newOwnedKeys]);
     allStoragedOwnedKeys[namespace] = Array.from(combinedSet);
-  });
+  }
 
   const data = JSON.stringify(allStoragedOwnedKeys);
   await localStorage.setItem(ownershipKey, data, ownershipNamespace);
@@ -136,18 +144,14 @@ async function removeOwnedKeys({
     ownershipNamespace
   );
 
-  Object.keys(toRemoveKeys).forEach(async (namespace: string) => {
+  for (const namespace of Object.keys(toRemoveKeys)) {
     const keysToRemove: string[] = toRemoveKeys[namespace] || [];
     const currentKeys: string[] = currentKeysList[namespace] || [];
 
     const storageOwnedSet = new Set(currentKeys);
     const keysToRemoveSet = new Set(keysToRemove);
 
-    function removeAll(originalSet, toBeRemovedSet) {
-      toBeRemovedSet.forEach(Set.prototype.delete, originalSet);
-    }
-
-    removeAll(storageOwnedSet, keysToRemoveSet);
+    keysToRemoveSet.forEach((key) => storageOwnedSet.delete(key));
     const newLoginKeys = Array.from(storageOwnedSet);
 
     if (isNilOrEmpty(newLoginKeys)) {
@@ -155,7 +159,7 @@ async function removeOwnedKeys({
     } else {
       currentKeysList[namespace] = newLoginKeys;
     }
-  });
+  }
 
   if (isNilOrEmpty(currentKeysList)) {
     await localStorage.removeItem(ownershipKey, ownershipNamespace);