@applicaster/zapp-react-native-utils 15.0.0-rc.12 → 15.0.0-rc.121

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