@applicaster/zapp-react-native-utils 16.0.0-alpha.6861239588 → 16.0.0-alpha.6918106967

package/uiActionsRegistrator/__tests__/subscribe.test.ts

@@ -0,0 +1,107 @@
+import { isActionAvailableFor, uiActionsRegistry } from "../registry";
+
+const value = { invokeAction: jest.fn() };
+
+describe("uiActionsRegistry.subscribe", () => {
+  it("fires on registration and on unregistration", () => {
+    const listener = jest.fn();
+    const unsubscribe = uiActionsRegistry.subscribe(listener);
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    unregister();
+
+    expect(listener).toHaveBeenCalledTimes(2);
+
+    unsubscribe();
+  });
+
+  it("lets a listener see the action it was told about", () => {
+    let seen: string[] = [];
+
+    const unsubscribe = uiActionsRegistry.subscribe(() => {
+      seen = uiActionsRegistry
+        .getActions("late-action", { id: "e1" } as any)
+        .map((item) => item.identifier);
+    });
+
+    const unregister = uiActionsRegistry.registerAction("late-action", value);
+
+    expect(seen).toEqual(["late-action"]);
+
+    unregister();
+    unsubscribe();
+  });
+
+  it("stops calling a listener once unsubscribed", () => {
+    const listener = jest.fn();
+
+    uiActionsRegistry.subscribe(listener)();
+
+    uiActionsRegistry.registerAction("another-action", value)();
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("survives a listener that unsubscribes itself while being notified", () => {
+    const other = jest.fn();
+
+    const unsubscribeOther = uiActionsRegistry.subscribe(other);
+
+    const unsubscribeSelf = uiActionsRegistry.subscribe(() => {
+      unsubscribeSelf();
+    });
+
+    expect(() =>
+      uiActionsRegistry.registerAction("self-removing", value)()
+    ).not.toThrow();
+
+    expect(other).toHaveBeenCalled();
+
+    unsubscribeOther();
+  });
+});
+
+describe("isActionAvailableFor", () => {
+  const entry = { id: "e1" } as any;
+
+  it("shows an action that states no opinion", () => {
+    expect(isActionAvailableFor({ invokeAction: jest.fn() }, entry)).toBe(true);
+  });
+
+  it.each([
+    ["isSupportDownloads"],
+    ["isActionSupported"],
+    ["isActionAvailable"],
+  ])("honours %s", (predicate) => {
+    expect(
+      isActionAvailableFor(
+        { invokeAction: jest.fn(), [predicate]: () => false } as any,
+        entry
+      )
+    ).toBe(false);
+  });
+
+  it("asks only the first predicate the action defines", () => {
+    const isActionAvailable = jest.fn(() => true);
+
+    expect(
+      isActionAvailableFor(
+        {
+          invokeAction: jest.fn(),
+          isSupportDownloads: () => false,
+          isActionAvailable,
+        } as any,
+        entry
+      )
+    ).toBe(false);
+
+    expect(isActionAvailable).not.toHaveBeenCalled();
+  });
+
+  it("treats a missing action as unavailable-free", () => {
+    expect(isActionAvailableFor(undefined, entry)).toBe(true);
+  });
+});

package/uiActionsRegistrator/__tests__/usableActionItems.test.ts

@@ -0,0 +1,52 @@
+import { usableActionItems } from "../usableActionItems";
+
+const action = (identifier: string) =>
+  ({ identifier, action: { invokeAction: jest.fn() } }) as any;
+
+describe("usableActionItems", () => {
+  it("keeps a usable list untouched, in order", () => {
+    const base = [action("share"), action("favorites")];
+
+    expect(usableActionItems(base).map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+  });
+
+  it("keeps the first of a repeated identifier", () => {
+    const firstShare = action("share");
+    const secondShare = action("share");
+
+    const result = usableActionItems([
+      firstShare,
+      action("favorites"),
+      secondShare,
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "favorites",
+    ]);
+
+    expect(result[0]).toBe(firstShare);
+  });
+
+  it("drops items that cannot be invoked or have no identifier", () => {
+    const result = usableActionItems([
+      action("share"),
+      { identifier: "blank" } as any,
+      { identifier: "no-invoke", action: {} } as any,
+      { action: { invokeAction: jest.fn() } } as any,
+      action("entry_action_0"),
+    ]);
+
+    expect(result.map((item) => item.identifier)).toEqual([
+      "share",
+      "entry_action_0",
+    ]);
+  });
+
+  it("tolerates a missing list", () => {
+    expect(usableActionItems(undefined as any)).toEqual([]);
+  });
+});

package/uiActionsRegistrator/index.ts

@@ -1,203 +1,25 @@
-/* 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();
+export {
+  canRenderActionIcon,
+  resolveActionAsset,
+  isActionAvailableFor,
+  observeEntryState,
+  uiActionsRegistry,
+} from "./registry";
+
+export type {
+  RegisteredAction,
+  RegisteredActionSource,
+  RegisteredActionValue,
+  RegistryChangeListener,
+  UIActionProvider,
+} from "./registry";
+
+export { usableActionItems } from "./usableActionItems";
+
+export {
+  ENTRY_ACTIONS_IDENTIFIER,
+  parseActionIdentifiers,
+  resolveActionIdentifiers,
+} from "./resolveActionIdentifiers";
+
+export type { ResolveActionIdentifiersParams } from "./resolveActionIdentifiers";