@applicaster/zapp-react-native-utils 16.0.0-rc.5 → 16.0.0-rc.50

package/uiActionsRegistrator/index.ts

@@ -0,0 +1,203 @@
+/* eslint-disable no-dupe-class-members */
+import { Observable } from "rxjs";
+import { createLogger } from "../logger";
+
+const { log_debug, log_warning, log_verbose } = createLogger({
+  subsystem: "UIActionsRegistry",
+  category: "ActionRegistration",
+});
+
+/**
+ * The runtime value of a UI action.
+ *
+ * This is the object that consumers interact with (render buttons for,
+ * invoke on press, read initial state from, etc.). It intentionally keeps an
+ * open shape (`[K: string]: any`) so that both the modern registry-based
+ * actions and the legacy context-provider based actions can be represented by
+ * the same structure.
+ */
+export type RegisteredActionValue = {
+  state?: any;
+  getInitialState?: () => Promise<void>;
+  initialEntryState?: (item: ZappEntry | ZappFeed) => CellActionEntryState;
+  invokeAction: (
+    item: ZappEntry | ZappFeed,
+    options?: InvokeArgsOptions
+  ) => void;
+  isActionAvailable?: (item: ZappEntry | ZappFeed) => boolean;
+  addListener?: (
+    entryId: string,
+    listener: CellActionStateListenerFunction
+  ) => CellActionStateRemoveListenerFunction;
+  /**
+   * Optional RX stream of the action state for a given entry. When not
+   * provided, `observeEntryState` derives one from `initialEntryState` +
+   * `addListener` (see below).
+   */
+  observeEntryState?: (
+    entry: ZappEntry | ZappFeed
+  ) => Observable<CellActionEntryState>;
+  [K: string]: any;
+};
+
+export type RegisteredAction = {
+  identifier: string; // Plugin identifier or synthetic name
+  action: RegisteredActionValue;
+};
+
+/**
+ * A function that, given an optional context (currently just the `entry`),
+ * returns the list of actions it wants to contribute.
+ *
+ * Returning an array is what allows a single provider (plugin or otherwise) to
+ * expose more than one action, and to compute those actions based on the entry.
+ */
+export type UIActionProvider = (params: {
+  entry?: ZappEntry | ZappFeed;
+}) => RegisteredAction[];
+
+/**
+ * Returns an RX `Observable` that emits the action state for `entry`.
+ *
+ * If the action already exposes its own `observeEntryState`, it is used as-is.
+ * Otherwise we build the stream from the legacy imperative API:
+ *  - it immediately emits `initialEntryState(entry)` (if available), and
+ *  - it subscribes to further changes via `addListener(entryId, listener)`,
+ *    unsubscribing automatically when the observable is torn down.
+ *
+ * This lets every action - old or new - be consumed reactively through a single
+ * mechanism, without each consumer having to wire up `addListener` manually.
+ */
+export function observeEntryState(
+  action: RegisteredActionValue | undefined,
+  entry: ZappEntry | ZappFeed
+): Observable<CellActionEntryState> {
+  if (typeof action?.observeEntryState === "function") {
+    return action.observeEntryState(entry);
+  }
+
+  return new Observable<CellActionEntryState>((subscriber) => {
+    const initialState = action?.initialEntryState?.(entry);
+
+    if (initialState !== undefined) {
+      subscriber.next(initialState);
+    }
+
+    const removeListener = action?.addListener?.(
+      String((entry as ZappEntry)?.id),
+      (state: CellActionEntryState) => subscriber.next(state)
+    );
+
+    return () => removeListener?.();
+  });
+}
+
+class UIActionsRegistry {
+  private registeredActions: Record<string, UIActionProvider> = {};
+
+  /**
+   * Register a dynamic action provider under a unique `name`.
+   * The provider can return one or more actions and may use the passed `entry`.
+   * Returns an unregister function.
+   */
+  registerActionProvider(
+    name: string,
+    actionProvider: UIActionProvider
+  ): () => void {
+    const isOverride = Boolean(this.registeredActions[name]);
+
+    if (isOverride) {
+      log_warning(
+        `registerActionProvider: overriding existing provider for "${name}"`,
+        { name }
+      );
+    } else {
+      log_debug(`registerActionProvider: registered "${name}"`, { name });
+    }
+
+    this.registeredActions[name] = actionProvider;
+
+    return () => {
+      // Only remove if it's still the same provider to avoid races where a
+      // newer registration replaced this one.
+      if (this.registeredActions[name] === actionProvider) {
+        delete this.registeredActions[name];
+        log_debug(`registerActionProvider: unregistered "${name}"`, { name });
+      } else {
+        log_debug(
+          `registerActionProvider: skipped unregister for "${name}" – newer provider is active`,
+          { name }
+        );
+      }
+    };
+  }
+
+  /**
+   * Convenience helper to register a single, static action from anywhere in the
+   * app (it does not need to be a plugin). Returns an unregister function.
+   */
+  registerAction(
+    identifier: string,
+    action: RegisteredActionValue
+  ): () => void {
+    log_debug(`registerAction: registering single action "${identifier}"`, {
+      identifier,
+    });
+
+    return this.registerActionProvider(identifier, () => [
+      { identifier, action },
+    ]);
+  }
+
+  getEntryActions(entry: ZappEntry): RegisteredAction[] {
+    const results = Object.keys(this.registeredActions)
+      .map((key) => this.registeredActions[key]({ entry }))
+      .flatMap((a) => a);
+
+    log_verbose(
+      `getEntryActions: resolved ${results.length} action(s) for entry "${entry?.id}"`,
+      { entryId: entry?.id, identifiers: results.map((r) => r.identifier) }
+    );
+
+    return results;
+  }
+
+  getActions(name: string, entry?: ZappEntry | ZappFeed): RegisteredAction[] {
+    if (!this.registeredActions[name]) {
+      log_warning(`getActions: no provider found for "${name}"`, { name });
+
+      return [];
+    }
+
+    const results = this.registeredActions[name]({ entry }) ?? [];
+
+    log_verbose(
+      `getActions: resolved ${results.length} action(s) for "${name}"`,
+      {
+        name,
+        entryId: (entry as ZappEntry)?.id,
+        identifiers: results.map((r) => r.identifier),
+      }
+    );
+
+    return results;
+  }
+
+  /**
+   * Returns the runtime value of the first action registered under `name`, or
+   * `undefined`. This mirrors the shape returned by the legacy `useActions`
+   * hook, easing migration of single-action consumers.
+   */
+  getAction(
+    name: string,
+    entry?: ZappEntry | ZappFeed
+  ): RegisteredActionValue | undefined {
+    return this.getActions(name, entry)[0]?.action;
+  }
+
+  hasAction(name: string): boolean {
+    return Boolean(this.registeredActions[name]);
+  }
+}
+
+export const uiActionsRegistry = new UIActionsRegistry();

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;
 }
@@ -111,12 +111,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 +136,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 +151,7 @@ async function removeOwnedKeys({
     } else {
       currentKeysList[namespace] = newLoginKeys;
     }
-  });
+  }
 
   if (isNilOrEmpty(currentKeysList)) {
     await localStorage.removeItem(ownershipKey, ownershipNamespace);

package/reactHooks/feed/__mocks__/usePipesCacheReset.ts

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