@applicaster/zapp-react-native-utils 15.1.0-rc.1 → 16.0.0-alpha.9803580571

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__/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);
 };

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

@@ -85,7 +85,7 @@ export const getNavigationKeys = (
   const general = (item?.general ?? {}) as General;
 
   const pluginIdentifier =
-    (item as any)?.identifier ?? item?.type ?? item?.component_type ?? "";
+    (item as any).identifier ?? item?.type ?? item?.component_type ?? "";
 
   const legacy =
     legacyMappingKeys[`${pluginIdentifier}.${resultType}`] ??

package/zappFrameworkUtils/HookCallback/hookCallbackManifestExtensions.config.js

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

package/zappFrameworkUtils/loginPluginUtils.ts

@@ -20,7 +20,7 @@ const isAuthenticationRequired = ({ payload, logs }) => {
 
   if (!payload) {
     log_info(
-      "isAuthenticationRequired: No payload exists, authentication required"
+      "isAuthenticationRequired: No payload exist, authentication required"
     );
 
     return true;

package/reactHooks/componentsMap/index.ts

@@ -1,55 +0,0 @@
-import * as React from "react";
-
-const layoutReducer = (state, { payload }) => {
-  return state.map((item, index, _state) => ({
-    height: index === payload.index ? payload.height : item.height,
-    y:
-      index > 0
-        ? _state.slice(0, index).reduce((acc, value) => acc + value.height, 0)
-        : 0,
-  }));
-};
-
-export const useComponentsLayout = (count, onFinishLoadingVisible) => {
-  const [itemsLayout, dispatchItemLayout] = React.useReducer(
-    layoutReducer,
-    Array.from({ length: count }, () => ({ height: 0, y: 0 }))
-  );
-
-  const notified = React.useRef(false);
-  const [listHeight, setListHeight] = React.useState<number>(0);
-
-  const onItemLayout = React.useCallback(
-    (index) => (event) => {
-      const { height } = event.nativeEvent.layout;
-      dispatchItemLayout({ payload: { index, height } });
-    },
-    []
-  );
-
-  const onListLayout = React.useCallback((event) => {
-    const { height } = event.nativeEvent.layout;
-    setListHeight(height);
-  }, []);
-
-  React.useEffect(() => {
-    if (!notified.current) {
-      const finishLoadingVisible = !!itemsLayout.find(
-        (item) => item.y > listHeight
-      );
-
-      if (finishLoadingVisible) {
-        notified.current = true;
-        onFinishLoadingVisible?.();
-      }
-    }
-  }, [itemsLayout, listHeight]);
-
-  return React.useMemo(
-    () => ({
-      onItemLayout,
-      onListLayout,
-    }),
-    []
-  );
-};