@applicaster/zapp-react-native-utils 16.0.0-alpha.2851031376 → 16.0.0-alpha.2963644197

package/uiActionsRegistrator/resolveActionIdentifiers.ts

@@ -0,0 +1,100 @@
+import { createLogger } from "../logger";
+
+import { RegisteredAction, uiActionsRegistry } from "./registry";
+
+const { log_warning } = createLogger({
+  subsystem: "UIActionsRegistry",
+  category: "ActionRegistration",
+});
+
+/** Identifier that stands for "whatever this entry declares", not a provider. */
+export const ENTRY_ACTIONS_IDENTIFIER = "entry_actions";
+
+export type ResolveActionIdentifiersParams = {
+  identifiers: string | string[];
+  entry: ZappEntry | ZappFeed;
+  /**
+   * Expands the `entry_actions` token.
+   *
+   * The registry maps an identifier to a provider, which is the right shape for
+   * a plugin: one installation, one implementation, looked up by id. Entry
+   * actions are not that - they are data on the entry being shown, and their
+   * execution context belongs to whoever is showing it. So the caller expands
+   * them, rather than the registry holding one global provider whose context
+   * was captured wherever it happened to be registered.
+   */
+  expandEntryActions?: (entry: ZappEntry | ZappFeed) => RegisteredAction[];
+};
+
+/**
+ * Identifiers already reported as having no provider.
+ *
+ * Resolution runs on every render of every surface that shows actions, so one
+ * uninstalled plugin would otherwise repeat its warning forever. An identifier
+ * is forgotten again as soon as it does resolve, so a provider that appears
+ * late and later disappears is still reported.
+ */
+const reportedMissingProviders = new Set<string>();
+
+export function parseActionIdentifiers(
+  config?: string | string[] | null
+): string[] {
+  // Deliberately not using the `utils` barrel: this module sits underneath the
+  // registry, and pulling that barrel in creates an import cycle.
+  if (config === null || config === undefined) {
+    return [];
+  }
+
+  return (Array.isArray(config) ? config : config.split(","))
+    .map((identifier) => identifier.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Resolves a *configured* list of action identifiers against the registry.
+ *
+ * Everything reaching this function was typed into an app configuration
+ * (`player_action_buttons`, `modal_bottom_sheet_actions`), so an identifier
+ * with no provider at all means a button the app was configured to show will
+ * not appear - a typo, or a plugin that is not installed. A provider that runs
+ * and returns nothing is a different matter: that is the action opting out for
+ * this entry, which is expected and stays silent.
+ */
+export function resolveActionIdentifiers({
+  identifiers,
+  entry,
+  expandEntryActions,
+}: ResolveActionIdentifiersParams): RegisteredAction[] {
+  return parseActionIdentifiers(identifiers).flatMap((identifier) => {
+    if (identifier === ENTRY_ACTIONS_IDENTIFIER) {
+      if (expandEntryActions) {
+        return expandEntryActions(entry);
+      }
+
+      log_warning(
+        `resolveActionIdentifiers: "${ENTRY_ACTIONS_IDENTIFIER}" is configured but this caller cannot expand it - the entry's own actions will not be shown`,
+        { entryId: (entry as ZappEntry)?.id }
+      );
+
+      return [];
+    }
+
+    const actions = uiActionsRegistry.getActions(identifier, entry);
+
+    // `hasAction` is only read to decide what to say; resolution itself is
+    // unchanged, so an identifier with no provider still resolves to nothing
+    // exactly as before.
+    if (uiActionsRegistry.hasAction(identifier)) {
+      reportedMissingProviders.delete(identifier);
+    } else if (!reportedMissingProviders.has(identifier)) {
+      reportedMissingProviders.add(identifier);
+
+      log_warning(
+        `resolveActionIdentifiers: configured action "${identifier}" has no registered provider - its button will not be shown`,
+        { identifier, entryId: (entry as ZappEntry)?.id }
+      );
+    }
+
+    return actions;
+  });
+}

package/uiActionsRegistrator/usableActionItems.ts

@@ -0,0 +1,66 @@
+import { createLogger } from "../logger";
+
+import { RegisteredAction } from "./registry";
+
+const { log_warning } = createLogger({
+  subsystem: "UIActionsRegistry",
+  category: "ActionRegistration",
+});
+
+/**
+ * Identifiers already reported as unusable. This runs on every render of the
+ * player overlay, so the warning is emitted once per identifier and forgotten
+ * again as soon as that action becomes invokable.
+ */
+const reportedUnusable = new Set<string>();
+
+function isInvokableAction(
+  item: RegisteredAction | undefined
+): item is RegisteredAction {
+  return typeof item?.action?.invokeAction === "function";
+}
+
+/**
+ * Narrows a resolved action list to what can actually be shown and invoked:
+ * anything without a usable `invokeAction` is dropped, and a repeated
+ * identifier keeps only its first occurrence. Order is preserved.
+ *
+ * Both the player overflow and the bottom sheet plugin build their list this
+ * way, and the player resolver applies it to `player_action_buttons` too - a
+ * hand-typed config string can name the same action twice.
+ */
+export function usableActionItems(
+  items: RegisteredAction[]
+): RegisteredAction[] {
+  const seen = new Set<string>();
+  const result: RegisteredAction[] = [];
+
+  for (const item of items ?? []) {
+    const identifier = item?.identifier;
+
+    // A duplicate is expected - a config string may name the same action twice
+    // - and an action with no identifier cannot be named in a log anyway.
+    if (!identifier || seen.has(identifier)) {
+      continue;
+    }
+
+    if (!isInvokableAction(item)) {
+      if (!reportedUnusable.has(identifier)) {
+        reportedUnusable.add(identifier);
+
+        log_warning(
+          `usableActionItems: dropping action "${identifier}" - its provider returned no invokeAction, so it cannot be shown`,
+          { identifier }
+        );
+      }
+
+      continue;
+    }
+
+    reportedUnusable.delete(identifier);
+    seen.add(identifier);
+    result.push(item);
+  }
+
+  return result;
+}

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

package/appUtils/playerManager/usePlayerTitleSummaryOverlay.tsx

@@ -1,56 +0,0 @@
-import { useEffect, useState } from "react";
-import { OverlaysObserver } from "./OverlayObserver/OverlaysObserver";
-import { useFeedLoader } from "../../reactHooks";
-import { usePlayer } from "./usePlayer";
-
-const getLiveUrl = (url: string) => {
-  // Use the replace method with a regular expression to replace all instances of subClass with livePage
-  return url.replace(new RegExp("subClass", "g"), "livePage");
-};
-
-export const useTitleSummaryOverlay = (
-  entry,
-  isLive = false,
-  interval: number
-) => {
-  // TODO: Have generic place for live url from configuration. Currently its hardcoded for client.
-  const feedUrl = getLiveUrl(entry?.extensions?.live?.channel_src ?? "");
-  const player = usePlayer();
-  const [title, setTitle] = useState<string | number>(entry?.title || "");
-  const [summary, setSummary] = useState<string | number>(entry?.summary || "");
-
-  // Hook to load feed data
-  const { data: feedData, reloadData } = useFeedLoader({ feedUrl });
-
-  useEffect(() => {
-    if (player && feedUrl && isLive) {
-      const observer = new OverlaysObserver({ player });
-
-      observer.setFeedDataHandlers(feedUrl, reloadData, interval, (entry) => {
-        setTitle(entry?.title || "");
-        setSummary(entry?.summary || "");
-      });
-
-      const subscription = observer
-        .getTitleSummaryObservable()
-        .subscribe(({ title, summary }) => {
-          setTitle(title);
-          setSummary(summary);
-        });
-
-      return () => {
-        subscription.unsubscribe();
-        observer.clearFeedDataInterval();
-      };
-    }
-  }, [player, feedUrl, reloadData, isLive]);
-
-  useEffect(() => {
-    if (isLive && feedData?.entry?.[0]) {
-      setTitle(feedData.entry[0].title || "");
-      setSummary(feedData.entry[0].summary || "");
-    }
-  }, [feedData]);
-
-  return { title, summary };
-};

package/playerUtils/__tests__/getPlayerActionButtons.test.ts

@@ -1,54 +0,0 @@
-import { getPlayerActionButtons } from "../getPlayerActionButtons";
-import { selectActionButtons } from "../../conf/player/selectors";
-
-jest.mock("../../conf/player/selectors", () => ({
-  selectActionButtons: jest.fn(),
-}));
-
-describe("getPlayerActionButtons", () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("returns an empty array if selectActionButtons returns undefined", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue(undefined);
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual([]);
-  });
-
-  it("returns an empty array if selectActionButtons returns null", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue(null);
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual([]);
-  });
-
-  it("returns an empty array if selectActionButtons returns empty string", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue("");
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual([]);
-  });
-
-  it("returns the first two trimmed action buttons", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue(" play , pause , stop ");
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual(["play", "pause"]);
-  });
-
-  it("returns only one button if only one is present", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue(" play ");
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual(["play"]);
-  });
-
-  it("trims whitespace from button names", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue("  play  ,   pause  ");
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual(["play", "pause"]);
-  });
-
-  it("returns an empty array if selectActionButtons returns only commas", () => {
-    (selectActionButtons as jest.Mock).mockReturnValue(" , , ");
-    const result = getPlayerActionButtons({});
-    expect(result).toEqual(["", ""]);
-  });
-});

package/playerUtils/getPlayerActionButtons.ts

@@ -1,17 +0,0 @@
-import { map, take, trim } from "../utils";
-import { selectActionButtons } from "../conf/player/selectors";
-
-/**
- * Returns the first two action buttons from the configuration.
- * @param {Object} configuration - The player configuration object.
- * @returns {Array} An array containing the first two action buttons.
- */
-export const getPlayerActionButtons = (configuration: any) => {
-  const buttonsString = selectActionButtons(configuration);
-
-  if (!buttonsString) {
-    return [];
-  }
-
-  return take(2, map(buttonsString.split(","), trim));
-};

package/reactHooks/feed/__mocks__/usePipesCacheReset.ts

@@ -1 +0,0 @@
-export const usePipesCacheReset = jest.fn();