@applicaster/zapp-react-native-utils 15.0.0-rc.95 → 15.0.0-rc.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "15.0.0-rc.95",
+  "version": "15.0.0-rc.97",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "15.0.0-rc.95",
+    "@applicaster/applicaster-types": "15.0.0-rc.97",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/rectUtils/__tests__/index.test.ts

@@ -0,0 +1,549 @@
+import {
+  measureDimensionalIntersection,
+  measureVerticalIntersection,
+  measureHorizontalIntersection,
+  measureDistance,
+  measureEuclidianDistanceToCenter,
+  isOnDirection,
+} from "../index";
+
+describe("rectUtils", () => {
+  describe("measureVerticalIntersection", () => {
+    it("should return 0 when rectangles don't overlap vertically", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 150, bottom: 250, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(0);
+    });
+
+    it("should return 0 when target is above current", () => {
+      const current = { top: 100, bottom: 200, left: 0, right: 100 };
+      const target = { top: 0, bottom: 50, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(0);
+    });
+
+    it("should measure partial vertical overlap", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 50, bottom: 150, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(50);
+    });
+
+    it("should measure full vertical overlap when target inside current", () => {
+      const current = { top: 0, bottom: 200, left: 0, right: 100 };
+      const target = { top: 50, bottom: 150, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(100);
+    });
+
+    it("should measure full vertical overlap when current inside target", () => {
+      const current = { top: 50, bottom: 150, left: 0, right: 100 };
+      const target = { top: 0, bottom: 200, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(100);
+    });
+
+    it("should handle exact vertical alignment", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 0, bottom: 100, left: 100, right: 200 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(100);
+    });
+
+    it("should handle touching edges", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 100, bottom: 200, left: 0, right: 100 };
+
+      expect(measureVerticalIntersection(current, target)).toBe(0);
+    });
+  });
+
+  describe("measureHorizontalIntersection", () => {
+    it("should return 0 when rectangles don't overlap horizontally", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 150, right: 250, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(0);
+    });
+
+    it("should return 0 when target is to the left of current", () => {
+      const current = { left: 100, right: 200, top: 0, bottom: 100 };
+      const target = { left: 0, right: 50, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(0);
+    });
+
+    it("should measure partial horizontal overlap", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 50, right: 150, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(50);
+    });
+
+    it("should measure full horizontal overlap when target inside current", () => {
+      const current = { left: 0, right: 200, top: 0, bottom: 100 };
+      const target = { left: 50, right: 150, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(100);
+    });
+
+    it("should measure full horizontal overlap when current inside target", () => {
+      const current = { left: 50, right: 150, top: 0, bottom: 100 };
+      const target = { left: 0, right: 200, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(100);
+    });
+
+    it("should handle exact horizontal alignment", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 0, right: 100, top: 100, bottom: 200 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(100);
+    });
+
+    it("should handle touching edges", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 100, right: 200, top: 0, bottom: 100 };
+
+      expect(measureHorizontalIntersection(current, target)).toBe(0);
+    });
+  });
+
+  describe("measureDimensionalIntersection", () => {
+    it("should call measureVerticalIntersection for horizontal direction", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 50, bottom: 150, left: 0, right: 100 };
+      const direction = { isHorizontal: true };
+
+      const result = measureDimensionalIntersection(direction, current, target);
+
+      expect(result).toBe(50);
+    });
+
+    it("should call measureHorizontalIntersection for vertical direction", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 50, right: 150, top: 0, bottom: 100 };
+      const direction = { isHorizontal: false };
+
+      const result = measureDimensionalIntersection(direction, current, target);
+
+      expect(result).toBe(50);
+    });
+
+    it("should handle no intersection for horizontal movement", () => {
+      const current = { top: 0, bottom: 100, left: 0, right: 100 };
+      const target = { top: 200, bottom: 300, left: 0, right: 100 };
+      const direction = { isHorizontal: true };
+
+      const result = measureDimensionalIntersection(direction, current, target);
+
+      expect(result).toBe(0);
+    });
+
+    it("should handle no intersection for vertical movement", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 200, right: 300, top: 0, bottom: 100 };
+      const direction = { isHorizontal: false };
+
+      const result = measureDimensionalIntersection(direction, current, target);
+
+      expect(result).toBe(0);
+    });
+  });
+
+  describe("measureDistance", () => {
+    describe("right direction", () => {
+      it("should return positive distance when target is to the right", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 150, right: 250, top: 0, bottom: 100 };
+        const direction = { value: "right" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+
+      it("should return negative distance when target is to the left", () => {
+        const current = { left: 100, right: 200, top: 0, bottom: 100 };
+        const target = { left: 0, right: 50, top: 0, bottom: 100 };
+        const direction = { value: "right" };
+
+        const result = measureDistance(direction, current, target);
+
+        // Formula: -1 * (current.right - target.left) = -1 * (200 - 0) = -200
+        expect(result).toBe(-200);
+      });
+
+      it("should return 0 when target touches current", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 100, right: 200, top: 0, bottom: 100 };
+        const direction = { value: "right" };
+
+        const result = Number(measureDistance(direction, current, target));
+
+        // Formula: -1 * (100 - 100) = -0 (signed zero)
+        expect(Math.abs(result)).toBe(0);
+      });
+    });
+
+    describe("left direction", () => {
+      it("should return positive distance when target is to the left", () => {
+        const current = { left: 100, right: 200, top: 0, bottom: 100 };
+        const target = { left: 0, right: 50, top: 0, bottom: 100 };
+        const direction = { value: "left" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+
+      it("should return negative distance when target is to the right", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 150, right: 250, top: 0, bottom: 100 };
+        const direction = { value: "left" };
+
+        const result = measureDistance(direction, current, target);
+
+        // Formula: current.left - target.right = 0 - 250 = -250
+        expect(result).toBe(-250);
+      });
+
+      it("should return 0 when target touches current", () => {
+        const current = { left: 100, right: 200, top: 0, bottom: 100 };
+        const target = { left: 0, right: 100, top: 0, bottom: 100 };
+        const direction = { value: "left" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(0);
+      });
+    });
+
+    describe("up direction", () => {
+      it("should return positive distance when target is above", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+
+        const target = {
+          left: 0,
+          right: 100,
+          top: 0,
+          bottom: 50,
+          x: 0,
+          width: 100,
+        };
+
+        const direction = { value: "up" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+
+      it("should return negative distance when target is below", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+
+        const target = {
+          left: 0,
+          right: 100,
+          top: 150,
+          bottom: 250,
+          x: 0,
+          width: 100,
+        };
+
+        const direction = { value: "up" };
+
+        const result = measureDistance(direction, current, target);
+
+        // Formula: current.top - target.bottom = 0 - 250 = -250
+        expect(result).toBe(-250);
+      });
+
+      it("should return -10000 when target is offscreen to the left", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+
+        const target = {
+          left: -200,
+          right: -100,
+          top: 0,
+          bottom: 50,
+          x: -200,
+          width: 100,
+        };
+
+        const direction = { value: "up" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(-10000);
+      });
+
+      it("should handle target at x = 0", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+
+        const target = {
+          left: 0,
+          right: 100,
+          top: 0,
+          bottom: 50,
+          x: 0,
+          width: 100,
+        };
+
+        const direction = { value: "up" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+    });
+
+    describe("down direction", () => {
+      it("should return positive distance when target is below", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 0, right: 100, top: 150, bottom: 250, x: 0 };
+        const direction = { value: "down" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+
+      it("should return negative distance when target is above", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+        const target = { left: 0, right: 100, top: 0, bottom: 50, x: 0 };
+        const direction = { value: "down" };
+
+        const result = measureDistance(direction, current, target);
+
+        // Formula: -1 * (current.bottom - target.top) = -1 * (200 - 0) = -200
+        expect(result).toBe(-200);
+      });
+
+      it("should return -10000 when target is offscreen to the right", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+
+        const target = {
+          left: 2000,
+          right: 2100,
+          top: 150,
+          bottom: 250,
+          x: 2000,
+        };
+
+        const direction = { value: "down" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(-10000);
+      });
+
+      it("should handle target at x = 1920", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+
+        const target = {
+          left: 1920,
+          right: 2020,
+          top: 150,
+          bottom: 250,
+          x: 1920,
+        };
+
+        const direction = { value: "down" };
+
+        const result = measureDistance(direction, current, target);
+
+        expect(result).toBe(50);
+      });
+    });
+  });
+
+  describe("measureEuclidianDistanceToCenter", () => {
+    it("should calculate distance between centers", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 300, right: 400, top: 400, bottom: 500 };
+
+      const result = measureEuclidianDistanceToCenter(current, target);
+
+      // Current center: (50, 50)
+      // Target center: (350, 450)
+      // Distance: sqrt((350-50)^2 + (450-50)^2) = sqrt(90000 + 160000) = sqrt(250000) = 500
+      expect(result).toBe(500);
+    });
+
+    it("should return 0 for same rectangle", () => {
+      const rect = { left: 0, right: 100, top: 0, bottom: 100 };
+
+      const result = measureEuclidianDistanceToCenter(rect, rect);
+
+      expect(result).toBe(0);
+    });
+
+    it("should calculate distance for adjacent rectangles", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 100, right: 200, top: 0, bottom: 100 };
+
+      const result = measureEuclidianDistanceToCenter(current, target);
+
+      // Current center: (50, 50)
+      // Target center: (150, 50)
+      // Distance: sqrt((150-50)^2 + (50-50)^2) = sqrt(10000) = 100
+      expect(result).toBe(100);
+    });
+
+    it("should calculate distance for vertical separation", () => {
+      const current = { left: 0, right: 100, top: 0, bottom: 100 };
+      const target = { left: 0, right: 100, top: 100, bottom: 200 };
+
+      const result = measureEuclidianDistanceToCenter(current, target);
+
+      // Current center: (50, 50)
+      // Target center: (50, 150)
+      // Distance: sqrt((50-50)^2 + (150-50)^2) = sqrt(10000) = 100
+      expect(result).toBe(100);
+    });
+
+    it("should calculate distance for diagonal separation", () => {
+      const current = { left: 0, right: 60, top: 0, bottom: 80 };
+      const target = { left: 60, right: 120, top: 80, bottom: 160 };
+
+      const result = measureEuclidianDistanceToCenter(current, target);
+
+      // Current center: (30, 40)
+      // Target center: (90, 120)
+      // Distance: sqrt((90-30)^2 + (120-40)^2) = sqrt(3600 + 6400) = sqrt(10000) = 100
+      expect(result).toBe(100);
+    });
+
+    it("should handle rectangles with different sizes", () => {
+      const current = { left: 0, right: 50, top: 0, bottom: 50 };
+      const target = { left: 100, right: 300, top: 100, bottom: 300 };
+
+      const result = measureEuclidianDistanceToCenter(current, target);
+
+      // Current center: (25, 25)
+      // Target center: (200, 200)
+      // Distance: sqrt((200-25)^2 + (200-25)^2) = sqrt(175^2 + 175^2) = sqrt(61250) ≈ 247.49
+      expect(result).toBeCloseTo(247.49, 1);
+    });
+  });
+
+  describe("isOnDirection", () => {
+    describe("horizontal directions", () => {
+      it("should return true when target is to the right", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 150, right: 250, top: 0, bottom: 100 };
+        const direction = { value: "right", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should return false when target is to the left but direction is right", () => {
+        const current = { left: 100, right: 200, top: 0, bottom: 100 };
+        const target = { left: 0, right: 50, top: 0, bottom: 100 };
+        const direction = { value: "right", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(false);
+      });
+
+      it("should return true when target is to the left", () => {
+        const current = { left: 100, right: 200, top: 0, bottom: 100 };
+        const target = { left: 0, right: 50, top: 0, bottom: 100 };
+        const direction = { value: "left", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should return false when target is to the right but direction is left", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 150, right: 250, top: 0, bottom: 100 };
+        const direction = { value: "left", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("vertical directions", () => {
+      it("should return true when target is above", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+        const target = { left: 0, right: 100, top: 0, bottom: 50 };
+        const direction = { value: "up", isVertical: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should return false when target is below but direction is up", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 0, right: 100, top: 150, bottom: 250 };
+        const direction = { value: "up", isVertical: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(false);
+      });
+
+      it("should return true when target is below", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 0, right: 100, top: 150, bottom: 250 };
+        const direction = { value: "down", isVertical: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should return false when target is above but direction is down", () => {
+        const current = { left: 0, right: 100, top: 100, bottom: 200 };
+        const target = { left: 0, right: 100, top: 0, bottom: 50 };
+        const direction = { value: "down", isVertical: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("edge cases", () => {
+      it("should handle aligned centers", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 100, right: 200, top: 0, bottom: 100 };
+        const direction = { value: "right", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should handle overlapping rectangles", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 50, right: 150, top: 50, bottom: 150 };
+        const direction = { value: "right", isHorizontal: true };
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBe(true);
+      });
+
+      it("should return undefined for invalid direction", () => {
+        const current = { left: 0, right: 100, top: 0, bottom: 100 };
+        const target = { left: 150, right: 250, top: 0, bottom: 100 };
+        const direction = { value: "right" }; // No isHorizontal or isVertical
+
+        const result = isOnDirection(direction, current, target);
+
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+});

package/rectUtils/index.ts

@@ -9,7 +9,7 @@
  */
 export function measureDimensionalIntersection(direction, current, target) {
   if (direction.isHorizontal) {
-    return measureVerticalIntersectiont(current, target);
+    return measureVerticalIntersection(current, target);
   } else {
     return measureHorizontalIntersection(current, target);
   }
@@ -25,7 +25,7 @@ export function measureDimensionalIntersection(direction, current, target) {
  * @param {Object} target rect object {right, left, top, bottom, x, y, width. height}
  * @returns {Int} Returns vertical intersection of current and target object
  */
-export function measureVerticalIntersectiont(current, target) {
+export function measureVerticalIntersection(current, target) {
   if (target.top >= current.bottom || target.bottom <= current.top) {
     return 0;
   }

package/screenPickerUtils/__tests__/index.test.ts

@@ -0,0 +1,333 @@
+import {
+  getFocusableId,
+  getPickerSelectorId,
+  SCREEN_PICKER_CONTAINER,
+  getScreenPickerId,
+  getScreenPickerSelectorContainerId,
+  getScreenPickerContentContainerId,
+} from "../index";
+
+describe("screenPickerUtils", () => {
+  describe("getFocusableId", () => {
+    it("should generate focusable ID with PickerItem prefix", () => {
+      expect(getFocusableId("item1")).toBe("PickerItem.item1");
+    });
+
+    it("should handle numeric IDs", () => {
+      expect(getFocusableId(123)).toBe("PickerItem.123");
+    });
+
+    it("should handle string IDs with special characters", () => {
+      expect(getFocusableId("item-123_test")).toBe("PickerItem.item-123_test");
+    });
+
+    it("should handle empty string ID", () => {
+      expect(getFocusableId("")).toBe("PickerItem.");
+    });
+
+    it("should handle IDs with spaces", () => {
+      expect(getFocusableId("my item")).toBe("PickerItem.my item");
+    });
+
+    it("should handle IDs with dots", () => {
+      expect(getFocusableId("parent.child")).toBe("PickerItem.parent.child");
+    });
+
+    it("should handle null ID", () => {
+      expect(getFocusableId(null)).toBe("PickerItem.null");
+    });
+
+    it("should handle undefined ID", () => {
+      expect(getFocusableId(undefined)).toBe("PickerItem.undefined");
+    });
+  });
+
+  describe("getPickerSelectorId", () => {
+    it("should generate picker selector ID with PickerSelector prefix", () => {
+      expect(getPickerSelectorId("selector1")).toBe("PickerSelector.selector1");
+    });
+
+    it("should handle numeric IDs", () => {
+      expect(getPickerSelectorId(456)).toBe("PickerSelector.456");
+    });
+
+    it("should handle string IDs with special characters", () => {
+      expect(getPickerSelectorId("selector-abc_xyz")).toBe(
+        "PickerSelector.selector-abc_xyz"
+      );
+    });
+
+    it("should handle empty string ID", () => {
+      expect(getPickerSelectorId("")).toBe("PickerSelector.");
+    });
+
+    it("should handle IDs with spaces", () => {
+      expect(getPickerSelectorId("my selector")).toBe(
+        "PickerSelector.my selector"
+      );
+    });
+
+    it("should handle null ID", () => {
+      expect(getPickerSelectorId(null)).toBe("PickerSelector.null");
+    });
+
+    it("should handle undefined ID", () => {
+      expect(getPickerSelectorId(undefined)).toBe("PickerSelector.undefined");
+    });
+  });
+
+  describe("SCREEN_PICKER_CONTAINER", () => {
+    it("should have correct constant value", () => {
+      expect(SCREEN_PICKER_CONTAINER).toBe("ScreenPickerContainer");
+    });
+
+    it("should be a string", () => {
+      expect(typeof SCREEN_PICKER_CONTAINER).toBe("string");
+    });
+  });
+
+  describe("getScreenPickerId", () => {
+    it("should generate screen picker ID with container prefix", () => {
+      expect(getScreenPickerId("screen1")).toBe(
+        "ScreenPickerContainer.screen1"
+      );
+    });
+
+    it("should use SCREEN_PICKER_CONTAINER constant", () => {
+      const id = "test";
+      expect(getScreenPickerId(id)).toBe(`${SCREEN_PICKER_CONTAINER}.${id}`);
+    });
+
+    it("should handle numeric IDs", () => {
+      expect(getScreenPickerId(789)).toBe("ScreenPickerContainer.789");
+    });
+
+    it("should handle string IDs with special characters", () => {
+      expect(getScreenPickerId("screen-123_test")).toBe(
+        "ScreenPickerContainer.screen-123_test"
+      );
+    });
+
+    it("should handle empty string ID", () => {
+      expect(getScreenPickerId("")).toBe("ScreenPickerContainer.");
+    });
+
+    it("should handle IDs with spaces", () => {
+      expect(getScreenPickerId("my screen")).toBe(
+        "ScreenPickerContainer.my screen"
+      );
+    });
+
+    it("should handle null ID", () => {
+      expect(getScreenPickerId(null)).toBe("ScreenPickerContainer.null");
+    });
+
+    it("should handle undefined ID", () => {
+      expect(getScreenPickerId(undefined)).toBe(
+        "ScreenPickerContainer.undefined"
+      );
+    });
+  });
+
+  describe("getScreenPickerSelectorContainerId", () => {
+    it("should generate selector container ID with suffix", () => {
+      expect(getScreenPickerSelectorContainerId("screen1")).toBe(
+        "ScreenPickerContainer.screen1-screen-selector"
+      );
+    });
+
+    it("should build on top of getScreenPickerId", () => {
+      const id = "test";
+      const baseId = getScreenPickerId(id);
+
+      expect(getScreenPickerSelectorContainerId(id)).toBe(
+        `${baseId}-screen-selector`
+      );
+    });
+
+    it("should handle numeric IDs", () => {
+      expect(getScreenPickerSelectorContainerId(123)).toBe(
+        "ScreenPickerContainer.123-screen-selector"
+      );
+    });
+
+    it("should handle string IDs with special characters", () => {
+      expect(getScreenPickerSelectorContainerId("screen-abc_xyz")).toBe(
+        "ScreenPickerContainer.screen-abc_xyz-screen-selector"
+      );
+    });
+
+    it("should handle empty string ID", () => {
+      expect(getScreenPickerSelectorContainerId("")).toBe(
+        "ScreenPickerContainer.-screen-selector"
+      );
+    });
+
+    it("should handle IDs with spaces", () => {
+      expect(getScreenPickerSelectorContainerId("my screen")).toBe(
+        "ScreenPickerContainer.my screen-screen-selector"
+      );
+    });
+
+    it("should handle null ID", () => {
+      expect(getScreenPickerSelectorContainerId(null)).toBe(
+        "ScreenPickerContainer.null-screen-selector"
+      );
+    });
+
+    it("should handle undefined ID", () => {
+      expect(getScreenPickerSelectorContainerId(undefined)).toBe(
+        "ScreenPickerContainer.undefined-screen-selector"
+      );
+    });
+  });
+
+  describe("getScreenPickerContentContainerId", () => {
+    it("should generate content container ID with suffix", () => {
+      expect(getScreenPickerContentContainerId("screen1")).toBe(
+        "ScreenPickerContainer.screen1-screen-container"
+      );
+    });
+
+    it("should build on top of getScreenPickerId", () => {
+      const id = "test";
+      const baseId = getScreenPickerId(id);
+
+      expect(getScreenPickerContentContainerId(id)).toBe(
+        `${baseId}-screen-container`
+      );
+    });
+
+    it("should handle numeric IDs", () => {
+      expect(getScreenPickerContentContainerId(456)).toBe(
+        "ScreenPickerContainer.456-screen-container"
+      );
+    });
+
+    it("should handle string IDs with special characters", () => {
+      expect(getScreenPickerContentContainerId("content-abc_xyz")).toBe(
+        "ScreenPickerContainer.content-abc_xyz-screen-container"
+      );
+    });
+
+    it("should handle empty string ID", () => {
+      expect(getScreenPickerContentContainerId("")).toBe(
+        "ScreenPickerContainer.-screen-container"
+      );
+    });
+
+    it("should handle IDs with spaces", () => {
+      expect(getScreenPickerContentContainerId("my content")).toBe(
+        "ScreenPickerContainer.my content-screen-container"
+      );
+    });
+
+    it("should handle null ID", () => {
+      expect(getScreenPickerContentContainerId(null)).toBe(
+        "ScreenPickerContainer.null-screen-container"
+      );
+    });
+
+    it("should handle undefined ID", () => {
+      expect(getScreenPickerContentContainerId(undefined)).toBe(
+        "ScreenPickerContainer.undefined-screen-container"
+      );
+    });
+  });
+
+  describe("ID relationships", () => {
+    it("should generate different IDs for different functions", () => {
+      const id = "test";
+
+      const focusableId = getFocusableId(id);
+      const selectorId = getPickerSelectorId(id);
+      const screenPickerId = getScreenPickerId(id);
+
+      expect(focusableId).not.toBe(selectorId);
+      expect(focusableId).not.toBe(screenPickerId);
+      expect(selectorId).not.toBe(screenPickerId);
+    });
+
+    it("should have consistent prefixes across calls", () => {
+      expect(getFocusableId("a")).toContain("PickerItem.");
+      expect(getFocusableId("b")).toContain("PickerItem.");
+      expect(getPickerSelectorId("a")).toContain("PickerSelector.");
+      expect(getPickerSelectorId("b")).toContain("PickerSelector.");
+      expect(getScreenPickerId("a")).toContain("ScreenPickerContainer.");
+      expect(getScreenPickerId("b")).toContain("ScreenPickerContainer.");
+    });
+
+    it("should generate selector and content IDs from same base", () => {
+      const id = "common";
+      const baseId = getScreenPickerId(id);
+      const selectorId = getScreenPickerSelectorContainerId(id);
+      const contentId = getScreenPickerContentContainerId(id);
+
+      expect(selectorId).toContain(baseId);
+      expect(contentId).toContain(baseId);
+      expect(selectorId).not.toBe(contentId);
+    });
+
+    it("should distinguish between selector and content containers", () => {
+      const id = "test";
+
+      const selectorId = getScreenPickerSelectorContainerId(id);
+      const contentId = getScreenPickerContentContainerId(id);
+
+      expect(selectorId).toContain("-screen-selector");
+      expect(contentId).toContain("-screen-container");
+      expect(selectorId).not.toBe(contentId);
+    });
+  });
+
+  describe("special characters and edge cases", () => {
+    it("should handle IDs with slashes", () => {
+      const id = "path/to/screen";
+
+      expect(getFocusableId(id)).toBe("PickerItem.path/to/screen");
+      expect(getPickerSelectorId(id)).toBe("PickerSelector.path/to/screen");
+
+      expect(getScreenPickerId(id)).toBe(
+        "ScreenPickerContainer.path/to/screen"
+      );
+    });
+
+    it("should handle IDs with Unicode characters", () => {
+      const id = "écran-日本語";
+
+      expect(getFocusableId(id)).toBe("PickerItem.écran-日本語");
+      expect(getPickerSelectorId(id)).toBe("PickerSelector.écran-日本語");
+      expect(getScreenPickerId(id)).toBe("ScreenPickerContainer.écran-日本語");
+    });
+
+    it("should handle very long IDs", () => {
+      const id = "a".repeat(1000);
+
+      expect(getFocusableId(id)).toContain("PickerItem.");
+      expect(getPickerSelectorId(id)).toContain("PickerSelector.");
+      expect(getScreenPickerId(id)).toContain("ScreenPickerContainer.");
+    });
+
+    it("should handle IDs with equals signs", () => {
+      const id = "key=value";
+
+      expect(getFocusableId(id)).toBe("PickerItem.key=value");
+      expect(getPickerSelectorId(id)).toBe("PickerSelector.key=value");
+      expect(getScreenPickerId(id)).toBe("ScreenPickerContainer.key=value");
+    });
+
+    it("should handle boolean values", () => {
+      expect(getFocusableId(true)).toBe("PickerItem.true");
+      expect(getPickerSelectorId(false)).toBe("PickerSelector.false");
+      expect(getScreenPickerId(true)).toBe("ScreenPickerContainer.true");
+    });
+
+    it("should handle object IDs", () => {
+      const obj = { toString: () => "customId" };
+
+      expect(getFocusableId(obj)).toContain("PickerItem.");
+      expect(getPickerSelectorId(obj)).toContain("PickerSelector.");
+      expect(getScreenPickerId(obj)).toContain("ScreenPickerContainer.");
+    });
+  });
+});

package/time/__tests__/BackgroundTimer.test.ts

@@ -0,0 +1,156 @@
+const mockBackgroundTimerModule = {
+  setTimeout: jest.fn(),
+  clearTimeout: jest.fn(),
+};
+
+jest.mock("../../reactUtils", () => ({
+  platformSelect: jest.fn((options) => options.android || options.default),
+}));
+
+describe("BackgroundTimer", () => {
+  let BackgroundTimer: any;
+
+  const setupTimer = (withNativeModule = true) => {
+    jest.resetModules();
+
+    jest.doMock("react-native", () => ({
+      NativeModules: {
+        BackgroundTimer: withNativeModule
+          ? mockBackgroundTimerModule
+          : undefined,
+      },
+      DeviceEventEmitter: {
+        addListener: jest.fn(),
+        removeListener: jest.fn(),
+      },
+    }));
+
+    BackgroundTimer = require("../BackgroundTimer").default;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("Native Module Environment", () => {
+    beforeEach(() => {
+      setupTimer(true);
+    });
+
+    it("should initialize device event listener on startup", () => {
+      const { DeviceEventEmitter } = require("react-native");
+
+      expect(DeviceEventEmitter.addListener).toHaveBeenCalledWith(
+        "BackgroundTimer.timer.fired",
+        expect.any(Function)
+      );
+    });
+
+    it("should delegate setTimeout to native module and return a unique ID", () => {
+      const callback1 = jest.fn();
+      const callback2 = jest.fn();
+      const timeout = 1000;
+
+      const id1 = BackgroundTimer.setTimeout(callback1, timeout);
+      const id2 = BackgroundTimer.setTimeout(callback2, timeout);
+
+      expect(mockBackgroundTimerModule.setTimeout).toHaveBeenCalledWith(
+        id1,
+        timeout
+      );
+
+      expect(mockBackgroundTimerModule.setTimeout).toHaveBeenCalledWith(
+        id2,
+        timeout
+      );
+
+      expect(id1).not.toBe(id2);
+      expect(typeof id1).toBe("number");
+    });
+
+    it("should delegate clearTimeout to native module", () => {
+      const id = BackgroundTimer.setTimeout(jest.fn(), 1000);
+      BackgroundTimer.clearTimeout(id);
+
+      expect(mockBackgroundTimerModule.clearTimeout).toHaveBeenCalledWith(id);
+    });
+
+    it("should execute callback when native timer fires", () => {
+      const { DeviceEventEmitter } = require("react-native");
+      const callback = jest.fn();
+
+      const id = BackgroundTimer.setTimeout(callback, 1000);
+
+      const listener = DeviceEventEmitter.addListener.mock.calls[0][1];
+
+      listener(id);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("should cleanup callback after execution (prevent double firing)", () => {
+      const { DeviceEventEmitter } = require("react-native");
+      const callback = jest.fn();
+
+      const id = BackgroundTimer.setTimeout(callback, 1000);
+      const listener = DeviceEventEmitter.addListener.mock.calls[0][1];
+
+      listener(id);
+      listener(id);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("should not execute callback if cleared before firing", () => {
+      const { DeviceEventEmitter } = require("react-native");
+      const callback = jest.fn();
+
+      const id = BackgroundTimer.setTimeout(callback, 1000);
+      BackgroundTimer.clearTimeout(id);
+
+      const listener = DeviceEventEmitter.addListener.mock.calls[0][1];
+      listener(id);
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+
+    it("should ignore events for unknown/invalid IDs", () => {
+      const { DeviceEventEmitter } = require("react-native");
+      const callback = jest.fn();
+
+      BackgroundTimer.setTimeout(callback, 1000);
+
+      const listener = DeviceEventEmitter.addListener.mock.calls[0][1];
+      listener(99999);
+
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("Fallback Environment (No Native Module)", () => {
+    beforeEach(() => {
+      setupTimer(false);
+    });
+
+    it("should use global setTimeout when native module is missing", () => {
+      const callback = jest.fn();
+      const timeout = 500;
+
+      const globalSpy = jest.spyOn(global, "setTimeout");
+
+      BackgroundTimer.setTimeout(callback, timeout);
+
+      expect(globalSpy).toHaveBeenCalledWith(callback, timeout);
+    });
+
+    it("should use global clearTimeout when native module is missing", () => {
+      const callback = jest.fn();
+      const globalSpy = jest.spyOn(global, "clearTimeout");
+
+      const id = BackgroundTimer.setTimeout(callback, 500);
+      BackgroundTimer.clearTimeout(id);
+
+      expect(globalSpy).toHaveBeenCalledWith(id);
+    });
+  });
+});

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";
 };