@applicaster/zapp-react-native-utils 15.1.13-alpha.1034774223 → 15.1.13

package/reactHooks/usePluginConfiguration.ts

@@ -1,7 +1,7 @@
 import * as R from "ramda";
 import { useMemo } from "react";
 
-import { usePlugins } from "@applicaster/zapp-react-native-redux/hooks";
+import { usePickFromState } from "@applicaster/zapp-react-native-redux/hooks";
 
 // importing this way prevents typescript packages importing from this
 // file to go crazy reporting errors on JS
@@ -24,11 +24,8 @@ export function parsePluginConfiguration(plugin, manifest) {
   return populateFields(plugin, manifest.custom_configuration_fields);
 }
 
-export function usePluginConfiguration<T = any, S = Record<string, any>>(
-  identifier: string,
-  manifest?: any
-) {
-  const plugins = usePlugins();
+export function usePluginConfiguration<T, S>(identifier, manifest) {
+  const { plugins } = usePickFromState(["plugins"]);
 
   const plugin = useMemo(
     () => R.find(R.propEq("identifier", identifier), plugins),

package/uiActionsRegistrator/index.ts

@@ -1,25 +1,203 @@
-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";
+/* 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/actionsExecutor/actions/__tests__/dismissBottomSheet.test.ts

@@ -1,25 +0,0 @@
-import { dismissBottomSheetAction } from "../dismissBottomSheet";
-import { dismissModal } from "../../../modalState";
-import { ActionResult } from "../../ActionExecutor";
-
-jest.mock("../../../modalState", () => ({
-  dismissModal: jest.fn(),
-  modalOrchestrator: {
-    close: jest.fn(),
-  },
-}));
-
-describe("dismissBottomSheetAction", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("calls dismissModal and returns ActionResult.Success", async () => {
-    const result = await dismissBottomSheetAction({
-      type: "dismissBottomSheet",
-    });
-
-    expect(dismissModal).toHaveBeenCalledTimes(1);
-    expect(result).toBe(ActionResult.Success);
-  });
-});

package/actionsExecutor/actions/__tests__/loadItemsFromSource.test.ts

@@ -1,88 +0,0 @@
-import { loadItemsFromSource } from "../openBottomSheet";
-
-const mockCall = jest.fn();
-
-jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
-  RequestBuilder: jest.fn().mockImplementation(() => ({
-    setEntryContext: jest.fn().mockReturnThis(),
-    setScreenContext: jest.fn().mockReturnThis(),
-    setUrl: jest.fn().mockReturnThis(),
-    buildAxiosRequest: jest.fn().mockResolvedValue(undefined),
-    call: (...args: any[]) => mockCall(...args),
-  })),
-  PipesClientResponseHelper: jest.fn().mockImplementation(() => ({
-    error: null,
-  })),
-}));
-
-describe("loadItemsFromSource", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("returns items plus role and behavior from feed.extensions", async () => {
-    mockCall.mockResolvedValueOnce({
-      response: {
-        entry: [{ id: "a", title: "Playlist A", media_group: [] }],
-        extensions: {
-          role: "collection_selector",
-          behavior: {
-            select_mode: "multi",
-            current_selection: ["a"],
-            selector: "extensions.tag",
-          },
-        },
-      },
-    });
-
-    const result = await loadItemsFromSource("https://example.com/feed");
-
-    expect(result.role).toBe("collection_selector");
-
-    expect(result.behavior).toEqual({
-      selectMode: "multi",
-      currentSelection: ["a"],
-      selector: "extensions.tag",
-    });
-
-    expect(result.items).toHaveLength(1);
-    expect(result.items[0].isSelected).toBe(true);
-    expect(result.items[0].title).toBe("Playlist A");
-  });
-
-  it("returns undefined role/behavior when feed has no extensions", async () => {
-    mockCall.mockResolvedValueOnce({
-      response: {
-        entry: [{ id: "1", title: "Plain", media_group: [] }],
-      },
-    });
-
-    const result = await loadItemsFromSource("https://example.com/plain");
-
-    expect(result.role).toBeUndefined();
-    expect(result.behavior).toBeUndefined();
-    expect(result.items).toHaveLength(1);
-  });
-
-  it("preserves events in dynamic_collection_options", async () => {
-    mockCall.mockResolvedValueOnce({
-      response: {
-        entry: [],
-        extensions: {
-          dynamic_collection_options: {
-            operations: "add,remove",
-            events: {
-              add: [{ type: "showTextInput", options: {} }],
-            },
-          },
-        },
-      },
-    });
-
-    const result = await loadItemsFromSource("https://example.com/feed");
-
-    expect(result.dynamicCollection?.events).toEqual({
-      add: [{ type: "showTextInput", options: {} }],
-    });
-  });
-});

package/actionsExecutor/actions/__tests__/openBottomSheet.customContent.test.ts

@@ -1,76 +0,0 @@
-import { openBottomSheetAction } from "../openBottomSheet";
-import { ActionResult } from "../../ActionExecutor";
-import { openBottomSheetModal } from "../../../modalState/store";
-import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
-
-jest.mock("../../../modalState/store", () => ({
-  openBottomSheetModal: jest.fn(),
-}));
-
-jest.mock("../../../modalState/ModalOrchestrator", () => ({
-  modalOrchestrator: {
-    open: jest.fn(),
-  },
-  isPresentSubMenuAction: jest.requireActual("../../../modalState/types")
-    .isPresentSubMenuAction,
-}));
-
-describe("openBottomSheetAction custom content", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("opens default sheet with contentComponent body props", async () => {
-    const CustomContent = function CustomContent() {
-      return null;
-    };
-
-    const result = await openBottomSheetAction({
-      type: "openBottomSheet",
-      options: {
-        header: { title: "Create Playlist" },
-        content: {
-          component: CustomContent,
-          props: {
-            inputLabel: "Name your playlist",
-            buttonLabel: "Create",
-            defaultValue: "",
-            submitAction: { type: "sendCloudEvent", options: {} },
-          },
-        },
-      },
-    } as any);
-
-    expect(result).toBe(ActionResult.Success);
-    expect(openBottomSheetModal).toHaveBeenCalledTimes(1);
-    expect(modalOrchestrator.open).not.toHaveBeenCalled();
-
-    const args = (openBottomSheetModal as jest.Mock).mock.calls[0][0];
-    // Default ModalComponent provides the standard header
-    expect(args.ModalBottomSheetContent).toBeUndefined();
-
-    expect(args.modalBottomSheetContentProps).toMatchObject({
-      title: "Create Playlist",
-      contentComponent: CustomContent,
-      contentComponentProps: {
-        inputLabel: "Name your playlist",
-        buttonLabel: "Create",
-        defaultValue: "",
-      },
-    });
-  });
-
-  it("returns Error when neither list data nor content.component is provided", async () => {
-    const result = await openBottomSheetAction({
-      type: "openBottomSheet",
-      options: {
-        header: { title: "Empty" },
-        content: {},
-      },
-    } as any);
-
-    expect(result).toBe(ActionResult.Error);
-    expect(openBottomSheetModal).not.toHaveBeenCalled();
-    expect(modalOrchestrator.open).not.toHaveBeenCalled();
-  });
-});

package/actionsExecutor/actions/__tests__/openBottomSheet.inlineItems.test.ts

@@ -1,212 +0,0 @@
-import { openBottomSheetAction } from "../openBottomSheet";
-import { actionExecutor, ActionResult } from "../../ActionExecutor";
-import { modalOrchestrator } from "../../../modalState/ModalOrchestrator";
-
-jest.mock("../../../modalState/store", () => ({
-  openBottomSheetModal: jest.fn(),
-}));
-
-jest.mock("../../../modalState/ModalOrchestrator", () => ({
-  modalOrchestrator: {
-    open: jest.fn(),
-    replace: jest.fn(),
-    stackSize: 0,
-  },
-  isPresentSubMenuAction: jest.requireActual("../../../modalState/types")
-    .isPresentSubMenuAction,
-}));
-
-describe("openBottomSheetAction inline items", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    (modalOrchestrator as any).stackSize = 0;
-  });
-
-  const speedSheetAction = {
-    type: "openBottomSheet",
-    options: {
-      header: { title: "Playback Speed" },
-      content: {
-        role: "collection_selector",
-        behavior: {
-          selectMode: "single",
-          currentSelection: ["1"],
-        },
-        items: [
-          {
-            id: "0.8",
-            title: "0.8x",
-            extensions: {
-              tap_actions: {
-                actions: [
-                  { type: "setPlaybackSpeed", options: { value: 0.8 } },
-                ],
-              },
-            },
-          },
-          {
-            id: "1",
-            title: "1x",
-            extensions: {
-              tap_actions: {
-                actions: [{ type: "setPlaybackSpeed", options: { value: 1 } }],
-              },
-            },
-          },
-        ],
-      },
-    },
-  } as any;
-
-  it("opens orchestrator with inline items and marks current selection", async () => {
-    const result = await openBottomSheetAction(speedSheetAction);
-
-    expect(result).toBe(ActionResult.Success);
-    expect(modalOrchestrator.open).toHaveBeenCalledTimes(1);
-    expect(modalOrchestrator.replace).not.toHaveBeenCalled();
-
-    const [menu] = (modalOrchestrator.open as jest.Mock).mock.calls[0];
-
-    expect(menu.content.items[0].isSelected).toBe(false);
-
-    expect(menu.content.items[1]).toMatchObject({
-      id: "1",
-      title: "1x",
-      isSelected: true,
-      action: { type: "setPlaybackSpeed", options: { value: 1 } },
-    });
-  });
-
-  it("pushes a new sheet by default even when another sheet is already open", async () => {
-    (modalOrchestrator as any).stackSize = 1;
-
-    await openBottomSheetAction(speedSheetAction);
-
-    expect(modalOrchestrator.open).toHaveBeenCalledTimes(1);
-    expect(modalOrchestrator.replace).not.toHaveBeenCalled();
-  });
-
-  it("replaces the current sheet when options.replace is true", async () => {
-    (modalOrchestrator as any).stackSize = 1;
-
-    await openBottomSheetAction({
-      ...speedSheetAction,
-      options: { ...speedSheetAction.options, replace: true },
-    });
-
-    expect(modalOrchestrator.replace).toHaveBeenCalledTimes(1);
-    expect(modalOrchestrator.open).not.toHaveBeenCalled();
-  });
-
-  it("executes all actions in tap_actions when onItemPress is called", async () => {
-    const multiActionSheet = {
-      type: "openBottomSheet",
-      options: {
-        header: { title: "Target Playlists" },
-        content: {
-          role: "collection_selector",
-          behavior: { selectMode: "none", currentSelection: [] },
-          items: [
-            {
-              id: "playlist-1",
-              title: "My Playlist",
-              extensions: {
-                tap_actions: {
-                  actions: [
-                    {
-                      type: "sendCloudEvent",
-                      options: { subject: "add_collection_to_collection" },
-                    },
-                    {
-                      type: "showToast",
-                      options: { message: "Added to playlist" },
-                    },
-                    { type: "dismissBottomSheet", options: {} },
-                  ],
-                },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    await openBottomSheetAction(multiActionSheet);
-
-    const [menu, onItemPress] = (modalOrchestrator.open as jest.Mock).mock
-      .calls[0];
-
-    expect(menu.content.items[0].actions).toHaveLength(3);
-
-    const handleActionsSpy = jest
-      .spyOn(actionExecutor, "handleActions")
-      .mockResolvedValue(ActionResult.Success);
-
-    await onItemPress(menu.content.items[0]);
-
-    expect(handleActionsSpy).toHaveBeenCalledWith(
-      [
-        {
-          type: "sendCloudEvent",
-          options: { subject: "add_collection_to_collection" },
-        },
-        {
-          type: "showToast",
-          options: { message: "Added to playlist" },
-        },
-        { type: "dismissBottomSheet", options: {} },
-      ],
-      expect.objectContaining({
-        entry: menu.content.items[0],
-      })
-    );
-
-    handleActionsSpy.mockRestore();
-  });
-
-  it("executes preceding actions and excludes presentSubMenu from actionExecutor", async () => {
-    const subMenuSheet = {
-      type: "openBottomSheet",
-      options: {
-        header: { title: "Menu" },
-        content: {
-          items: [
-            {
-              id: "item-with-submenu",
-              title: "More Options",
-              extensions: {
-                tap_actions: {
-                  actions: [
-                    { type: "sendAnalytics", options: { event: "click_more" } },
-                    {
-                      type: "presentSubMenu",
-                      menu: { content: { title: "Sub Options", items: [] } },
-                    },
-                  ],
-                },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    await openBottomSheetAction(subMenuSheet);
-
-    const [menu, onItemPress] = (modalOrchestrator.open as jest.Mock).mock
-      .calls[0];
-
-    const handleActionsSpy = jest
-      .spyOn(actionExecutor, "handleActions")
-      .mockResolvedValue(ActionResult.Success);
-
-    await onItemPress(menu.content.items[0]);
-
-    expect(handleActionsSpy).toHaveBeenCalledWith(
-      [{ type: "sendAnalytics", options: { event: "click_more" } }],
-      expect.objectContaining({ entry: menu.content.items[0] })
-    );
-
-    handleActionsSpy.mockRestore();
-  });
-});

package/actionsExecutor/actions/dismissBottomSheet.ts

@@ -1,23 +0,0 @@
-/// <reference types="@applicaster/applicaster-types" />
-import { dismissModal, modalOrchestrator } from "../../modalState";
-import { ActionResult } from "../ActionExecutor";
-import { ActionHandler } from "../types";
-import { createLogger } from "../../logger";
-
-const { log_info } = createLogger({
-  subsystem: "ActionExecutorContext",
-  category: "General",
-});
-
-/**
- * Dismisses the active bottom sheet / modal.
- */
-export const dismissBottomSheetAction: ActionHandler<
-  any
-> = async (): Promise<ActionResult> => {
-  log_info("handleAction: dismissBottomSheet");
-  modalOrchestrator.close();
-  dismissModal();
-
-  return ActionResult.Success;
-};