@applicaster/zapp-react-native-utils 15.0.0-rc.98 → 15.1.0-alpha.1852552014

package/time/__tests__/Timer.test.ts

@@ -1,236 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/utils/__tests__/mergeRight.test.ts

@@ -1,48 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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/mergeRight.ts

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

package/utils/selectors.ts

@@ -1,46 +0,0 @@
-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 || []);
-  };
-};