@applicaster/zapp-react-native-utils 15.1.4 → 16.0.0-alpha.1042942411

package/time/__tests__/Timer.test.ts

@@ -0,0 +1,236 @@
+import { Timer } from "../Timer";
+import BackgroundTimer from "../BackgroundTimer";
+
+// Mock BackgroundTimer
+jest.mock("../BackgroundTimer", () => ({
+  __esModule: true,
+  default: {
+    setTimeout: jest.fn((callback, delay) => {
+      return setTimeout(callback, delay);
+    }),
+    clearTimeout: jest.fn((id) => {
+      clearTimeout(id as NodeJS.Timeout);
+    }),
+  },
+}));
+
+describe("Timer", () => {
+  let mockCallback: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.useFakeTimers();
+    mockCallback = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe("constructor", () => {
+    it("should create timer with callback and remaining time", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      expect(timer).toBeInstanceOf(Timer);
+    });
+
+    it("should create timer with callback only (optional remaining param)", () => {
+      const timer = new Timer(mockCallback);
+
+      expect(timer).toBeInstanceOf(Timer);
+    });
+
+    it("should not start automatically", () => {
+      // eslint-disable-next-line no-new
+      new Timer(mockCallback, 1000);
+
+      expect(BackgroundTimer.setTimeout).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("start", () => {
+    it("should call setTimeout with callback and remaining time", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.start();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledWith(
+        mockCallback,
+        1000
+      );
+    });
+
+    it("should reset remaining time to 0 after starting", () => {
+      const timer = new Timer(mockCallback, 5000);
+
+      timer.start();
+      timer.clear();
+      timer.start();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("pause", () => {
+    it("should clear timeout and calculate remaining time correctly", () => {
+      const startTime = 1000;
+      const pauseTime = 1500;
+
+      jest
+        .spyOn(Date, "now")
+        .mockReturnValueOnce(startTime) // start
+        .mockReturnValueOnce(pauseTime); // pause
+
+      const timer = new Timer(mockCallback, 2000);
+
+      timer.start();
+      timer.pause();
+
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalled();
+    });
+
+    it("should be safe to call pause multiple times", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.start();
+      timer.pause();
+      timer.pause();
+
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("resume", () => {
+    it("should restart timer with remaining time after pause", () => {
+      const startTime = 1000;
+      const pauseTime = 1500;
+
+      jest
+        .spyOn(Date, "now")
+        .mockReturnValueOnce(startTime)
+        .mockReturnValueOnce(pauseTime);
+
+      const timer = new Timer(mockCallback, 2000);
+
+      timer.start();
+      timer.pause();
+      timer.resume();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledTimes(2);
+    });
+
+    it("should be callable without prior pause", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.resume();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalled();
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear timeout and be safe to call without starting timer", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      expect(() => {
+        timer.clear();
+      }).not.toThrow();
+
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalled();
+    });
+
+    it("should be callable multiple times", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.start();
+      timer.clear();
+      timer.clear();
+
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("timer lifecycle", () => {
+    it("should support complete lifecycle: start -> pause -> resume -> clear", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.start();
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledTimes(1);
+
+      timer.pause();
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalledTimes(1);
+
+      timer.resume();
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledTimes(2);
+
+      timer.clear();
+      expect(BackgroundTimer.clearTimeout).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should handle zero delay", () => {
+      const timer = new Timer(mockCallback, 0);
+
+      timer.start();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledWith(mockCallback, 0);
+    });
+
+    it("should handle very long delays", () => {
+      const longDelay = Number.MAX_SAFE_INTEGER;
+      const timer = new Timer(mockCallback, longDelay);
+
+      timer.start();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledWith(
+        mockCallback,
+        longDelay
+      );
+    });
+
+    it("should handle negative delays gracefully", () => {
+      const timer = new Timer(mockCallback, -1000);
+
+      expect(() => {
+        timer.start();
+      }).not.toThrow();
+    });
+
+    it("should maintain callback reference through lifecycle", () => {
+      const specificCallback = jest.fn();
+      const timer = new Timer(specificCallback, 1000);
+
+      timer.start();
+
+      expect(BackgroundTimer.setTimeout).toHaveBeenCalledWith(
+        specificCallback,
+        1000
+      );
+    });
+  });
+
+  describe("callback execution safety", () => {
+    it("should not execute callback immediately on start", () => {
+      const timer = new Timer(mockCallback, 1000);
+
+      timer.start();
+
+      expect(mockCallback).not.toHaveBeenCalled();
+    });
+
+    it("should not execute callback when paused or cleared", () => {
+      const timer1 = new Timer(mockCallback, 100);
+      const timer2 = new Timer(mockCallback, 100);
+
+      timer1.start();
+      timer1.pause();
+      timer2.start();
+      timer2.clear();
+
+      jest.advanceTimersByTime(200);
+
+      expect(mockCallback).not.toHaveBeenCalled();
+    });
+  });
+});

package/typeGuards/__tests__/isString.test.ts

@@ -0,0 +1,21 @@
+import { isString } from "../index";
+
+describe("isString", () => {
+  it("should return true for string primitives", () => {
+    expect(isString("hello")).toBe(true);
+    expect(isString("")).toBe(true);
+  });
+
+  it("should return true for String object instances", () => {
+    // eslint-disable-next-line no-new-wrappers
+    expect(isString(new String("test"))).toBe(true);
+  });
+
+  it("should return false for non-string values", () => {
+    expect(isString(123)).toBe(false);
+    expect(isString(null)).toBe(false);
+    expect(isString(undefined)).toBe(false);
+    expect(isString({})).toBe(false);
+    expect(isString([])).toBe(false);
+  });
+});

package/typeGuards/index.ts

@@ -1,3 +1,7 @@
 export const isString = (value: unknown) => {
+  if (typeof value === "object" && value instanceof String) {
+    return true;
+  }
+
   return typeof value === "string";
 };

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/utils/__tests__/mergeRight.test.ts

@@ -0,0 +1,48 @@
+import { mergeRight } from "../mergeRight";
+
+describe("mergeRight", () => {
+  test("merges two objects with no overlapping keys", () => {
+    const a = { x: 1, y: 2 };
+    const b = { z: 3 };
+
+    const result = mergeRight(a, b);
+
+    expect(result).toEqual({ x: 1, y: 2, z: 3 });
+  });
+
+  test("overwrites keys from the second object", () => {
+    const a = { x: 1, y: 2 };
+    const b = { y: 10, z: 3 };
+
+    const result = mergeRight(a, b);
+
+    expect(result).toEqual({ x: 1, y: 10, z: 3 });
+  });
+
+  test("does not mutate the original objects", () => {
+    const a = { x: 1 };
+    const b = { y: 2 };
+
+    const result = mergeRight(a, b);
+
+    expect(result).not.toBe(a);
+    expect(result).not.toBe(b);
+    expect(a).toEqual({ x: 1 });
+    expect(b).toEqual({ y: 2 });
+  });
+
+  test("works with empty objects", () => {
+    expect(mergeRight({}, { a: 1 })).toEqual({ a: 1 });
+    expect(mergeRight({ a: 1 }, {})).toEqual({ a: 1 });
+    expect(mergeRight({}, {})).toEqual({});
+  });
+
+  test("works with nested objects (shallow merge only)", () => {
+    const a = { x: { nested: 1 }, y: 2 };
+    const b = { x: { nested: 10 }, z: 3 };
+
+    const result = mergeRight(a, b);
+
+    expect(result).toEqual({ x: { nested: 10 }, y: 2, z: 3 });
+  });
+});

package/utils/__tests__/path.test.ts

@@ -31,3 +31,10 @@ test("example 4", () => {
 
   expect(path(route, xs)).toBeUndefined();
 });
+
+test("example 5", () => {
+  const route = ["a", "b", 0];
+  const xs = { a: { b: [1, 2, 3] } };
+
+  expect(path(route, xs)).toBe(1);
+});

package/utils/__tests__/selectors.test.ts

@@ -0,0 +1,124 @@
+import {
+  createPluginsByPathSelector,
+  createPluginsByModuleSelector,
+  combinePluginSelectors,
+} from "../selectors";
+
+describe("Plugin Selectors", () => {
+  const mockPlugins = [
+    {
+      identifier: "plugin1",
+      module: {
+        urlScheme: { host: "test" },
+        player: { type: "default" },
+      },
+      customField: true,
+    },
+    {
+      identifier: "plugin2",
+      module: {
+        urlScheme: { host: "other" },
+      },
+    },
+    {
+      identifier: "plugin3",
+      module: {
+        player: { type: "custom" },
+      },
+    },
+  ];
+
+  const mockState = {
+    plugins: mockPlugins,
+  };
+
+  describe("createPluginsByPathSelector", () => {
+    it("filters plugins by string path", () => {
+      const selector = createPluginsByPathSelector("customField");
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].identifier).toBe("plugin1");
+    });
+
+    it("filters plugins by array path", () => {
+      const selector = createPluginsByPathSelector(["module", "urlScheme"]);
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(2);
+      expect(result.map((p) => p.identifier)).toEqual(["plugin1", "plugin2"]);
+    });
+
+    it("handles missing plugins array", () => {
+      const selector = createPluginsByPathSelector("customField");
+      const result = selector({});
+
+      expect(result).toEqual([]);
+    });
+
+    it("handles non-existent path", () => {
+      const selector = createPluginsByPathSelector("nonexistent");
+      const result = selector(mockState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("createPluginsByModuleSelector", () => {
+    it("filters plugins by module path", () => {
+      const selector = createPluginsByModuleSelector("player");
+      const result = selector(mockState);
+
+      expect(result).toHaveLength(2);
+      expect(result.map((p) => p.identifier)).toEqual(["plugin1", "plugin3"]);
+    });
+
+    it("handles non-existent module", () => {
+      const selector = createPluginsByModuleSelector("nonexistent");
+      const result = selector(mockState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("combinePluginSelectors", () => {
+    it("combines multiple selectors with AND logic", () => {
+      const urlSchemeSelector = createPluginsByModuleSelector("urlScheme");
+      const playerSelector = createPluginsByModuleSelector("player");
+
+      const combinedSelector = combinePluginSelectors(
+        urlSchemeSelector,
+        playerSelector
+      );
+
+      const result = combinedSelector(mockState);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].identifier).toBe("plugin1");
+    });
+
+    it("returns empty array when no plugins match all conditions", () => {
+      const urlSchemeSelector = createPluginsByModuleSelector("urlScheme");
+      const customSelector = createPluginsByPathSelector("nonexistent");
+
+      const combinedSelector = combinePluginSelectors(
+        urlSchemeSelector,
+        customSelector
+      );
+
+      const result = combinedSelector(mockState);
+
+      expect(result).toEqual([]);
+    });
+
+    it("handles empty state", () => {
+      const selector = combinePluginSelectors(
+        createPluginsByModuleSelector("urlScheme")
+      );
+
+      const result = selector({});
+
+      expect(result).toEqual([]);
+    });
+  });
+});

package/utils/index.ts

@@ -18,6 +18,8 @@ export { take } from "./take";
 
 export { mapAccum } from "./mapAccum";
 
+export { mergeRight } from "./mergeRight";
+
 export { clone } from "./clone";
 
 export {
@@ -37,9 +39,20 @@ export {
   last,
   toLower,
   isEqual as equals,
+  uniq,
   uniqWith,
   flowRight as compose,
   partial,
+  clamp,
   reverse,
+  takeRight,
+  fromPairs,
+  sortBy,
+  merge,
+  values,
+  head,
+  findIndex,
+  set,
   compact,
+  identity,
 } from "lodash";

package/utils/mergeRight.ts

@@ -0,0 +1,5 @@
+import { assign } from "lodash";
+
+export const mergeRight = (a, b) => {
+  return assign({}, a, b);
+};

package/utils/path.ts

@@ -1,5 +1,8 @@
-import { get } from "lodash";
+import { pathOr } from "./pathOr";
 
-export const path = (route, record) => {
-  return get(record, route, undefined);
+export const path = <T = any>(
+  route: (string | number) | (string | number)[],
+  record: any
+) => {
+  return pathOr<T>(undefined, route, record);
 };