@applicaster/zapp-react-native-utils 15.0.0-alpha.4153840309 → 15.0.0-alpha.4200413542

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/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__/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 {
   cloneDeep as clone,
   flatten,
@@ -40,5 +42,16 @@ export {
   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);
 };

package/utils/pathOr.ts

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

package/utils/selectors.ts

@@ -0,0 +1,46 @@
+import { get } from "lodash";
+
+export type Selector<T> = (state: any) => T;
+
+/**
+ * Creates a selector for filtering plugins by path
+ * @param path - Path to check in plugin. Can be a dot notation string or array
+ * @returns A selector function that returns matching plugins
+ */
+export const createPluginsByPathSelector = (
+  path: string | string[]
+): Selector<any[]> => {
+  return (state: any) => {
+    const plugins = state.plugins || [];
+
+    return plugins.filter((plugin: any) => get(plugin, path));
+  };
+};
+
+/**
+ * Creates a selector for filtering plugins by module path
+ * @param modulePath - Module path to check in plugin (e.g., "urlScheme", "player")
+ * @returns A selector function that returns plugins with specified module
+ */
+export const createPluginsByModuleSelector = (
+  modulePath: string
+): Selector<any[]> => {
+  return createPluginsByPathSelector(["module", modulePath]);
+};
+
+/**
+ * Creates a selector that combines multiple plugin selectors
+ * @param selectors - Array of plugin selectors to combine
+ * @returns A selector function that returns plugins matching all conditions
+ */
+export const combinePluginSelectors = (
+  ...selectors: Selector<any[]>[]
+): Selector<any[]> => {
+  return (state: any) => {
+    return selectors.reduce((filtered, selector) => {
+      const selected = selector(state);
+
+      return filtered.filter((plugin) => selected.includes(plugin));
+    }, state.plugins || []);
+  };
+};

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -1,6 +1,6 @@
 import { useNavigation, useRivers, useScreenContext } from "../../reactHooks";
 import { createLogger } from "../../logger";
-import { useCallback, useMemo } from "react";
+import { useCallback, useMemo, useRef, useEffect } from "react";
 
 export enum NavigationCallbackOptions {
   DEFAULT = "default",
@@ -17,6 +17,7 @@ export enum ResultType {
 export type CallbackResult = hookCallbackArgs & {
   options?: {
     resultType?: ResultType;
+    navigator?: QuickBrickAppNavigator;
   };
 };
 
@@ -45,7 +46,7 @@ const legacyMappingKeys = {
     actionType: "login_completion_action",
     targetScreen: "navigate_to_login_screen",
   },
-  "quick-brick-user-account-ui-component": {
+  "quick-brick-user-account-ui-component.login": {
     actionType: "callbackAction",
   },
   "quick-brick-login-multi-login-providers.login": {
@@ -83,7 +84,8 @@ export const getNavigationKeys = (
 ): NavKeys => {
   const general = (item?.general ?? {}) as General;
 
-  const pluginIdentifier = (item as any).identifier ?? item?.type ?? "";
+  const pluginIdentifier =
+    (item as any).identifier ?? item?.type ?? item?.component_type ?? "";
 
   const legacy =
     legacyMappingKeys[`${pluginIdentifier}.${resultType}`] ??
@@ -135,6 +137,12 @@ export const useCallbackNavigationAction = (
   const rivers = useRivers();
   const screenContext = useScreenContext();
 
+  const navigationRef = useRef(navigation);
+
+  useEffect(() => {
+    navigationRef.current = navigation;
+  }, [navigation]);
+
   const overrideCallbackFromComponent = useMemo(() => {
     log_verbose(`${LogPrefix}: overridden callbackAction by component`);
 
@@ -168,20 +176,35 @@ export const useCallbackNavigationAction = (
         return;
       }
 
-      const data = getNavigationKeys(item, args.options?.resultType ?? null);
+      let data = getNavigationKeys(item, args.options?.resultType ?? null);
 
       if (!data) {
-        hookCallback?.(args);
+        const isScreen = !hookCallback;
 
-        return;
+        if (isScreen && args.options?.resultType === ResultType.login) {
+          log_debug(
+            `${LogPrefix} no navigation data found, applying GO BACK for login screen`
+          );
+
+          data = {
+            action: NavigationCallbackOptions.GO_BACK,
+            targetScreenId: null,
+          };
+        } else {
+          hookCallback?.(args);
+
+          return;
+        }
       }
 
       hookCallback?.({ ...args, success: false, cancelled: true });
+      const currentNavigation = navigationRef.current;
 
       switch (data.action) {
         case NavigationCallbackOptions.GO_BACK: {
-          if (navigation.canGoBack()) {
-            navigation.goBack();
+          if (currentNavigation.canGoBack()) {
+            currentNavigation.goBack();
+
             log_info(`${LogPrefix} performing 'GO BACK' action`);
           } else {
             log_info(`${LogPrefix} cannot perform 'GO BACK' action — ignoring`);
@@ -191,7 +214,7 @@ export const useCallbackNavigationAction = (
         }
 
         case NavigationCallbackOptions.GO_HOME: {
-          navigation.goHome();
+          currentNavigation.goHome();
           log_info(`${LogPrefix} performing 'GO HOME' action`);
           break;
         }
@@ -207,7 +230,7 @@ export const useCallbackNavigationAction = (
           const screen = rivers[screenId];
 
           if (screen) {
-            navigation.replace(screen);
+            currentNavigation.replace(screen);
 
             log_info(
               `${LogPrefix} performing 'GO TO SCREEN' action to screen: ${screenId}`
@@ -224,7 +247,7 @@ export const useCallbackNavigationAction = (
         }
       }
     },
-    [item, navigation, rivers]
+    [item, rivers]
   );
 
   return overrideCallbackFromComponent || callbackAction;

package/zappFrameworkUtils/HookCallback/hookCallbackManifestExtensions.config.js

@@ -20,7 +20,7 @@ const callbackKeyPrefix = (key, prefix, keySeparator = "_") =>
 
 const extendManifestWithHookCallback = (prefix = null) => ({
   group: true,
-  label: "CallBack Navigation",
+  label: `CallBack Navigation: ${prefix}`,
   folded: true,
   fields: [
     {