@applicaster/zapp-react-native-utils 15.0.0-alpha.2004137882 → 15.0.0-alpha.2060204268

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/index.ts

@@ -18,6 +18,8 @@ export { take } from "./take";
 
 export { mapAccum } from "./mapAccum";
 
+export { mergeRight } from "./mergeRight";
+
 export {
   cloneDeep as clone,
   flatten,
@@ -51,4 +53,5 @@ export {
   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/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,
-    }),
-    []
-  );
-};