@yh-ui/flow 0.1.56 → 1.0.4

package/dist/__tests__/transform.test.cjs

@@ -3,56 +3,382 @@
 var _vitest = require("vitest");
 var _transform = require("../utils/transform.cjs");
 (0, _vitest.describe)("flow/utils/transform", () => {
-  (0, _vitest.it)("screenToCanvas and canvasToScreen should be inverse (basic)", () => {
-    const t = {
-      x: 100,
-      y: 50,
-      zoom: 2
-    };
-    const screen = {
-      x: 300,
-      y: 250
-    };
-    const canvas = (0, _transform.screenToCanvas)(screen.x, screen.y, t);
-    const back = (0, _transform.canvasToScreen)(canvas.x, canvas.y, t);
-    (0, _vitest.expect)(back.x).toBe(screen.x);
-    (0, _vitest.expect)(back.y).toBe(screen.y);
-  });
-  (0, _vitest.it)("projectNodePosition should transform between viewports", () => {
-    const from = {
-      x: 10,
-      y: 20,
-      zoom: 2
-    };
-    const to = {
-      x: -5,
-      y: 15,
-      zoom: 1
-    };
-    const p = {
-      x: 110,
-      y: 220
-    };
-    const projected = (0, _transform.projectNodePosition)(p, from, to);
-    const canvas = (0, _transform.screenToCanvas)(p.x, p.y, from);
-    const expected = (0, _transform.canvasToScreen)(canvas.x, canvas.y, to);
-    (0, _vitest.expect)(projected).toEqual(expected);
-  });
-  (0, _vitest.it)("snapToGrid should round to nearest grid", () => {
-    (0, _vitest.expect)((0, _transform.snapToGrid)(0, 10)).toBe(0);
-    (0, _vitest.expect)((0, _transform.snapToGrid)(4, 10)).toBe(0);
-    (0, _vitest.expect)((0, _transform.snapToGrid)(5, 10)).toBe(10);
-    (0, _vitest.expect)((0, _transform.snapToGrid)(14, 10)).toBe(10);
-    (0, _vitest.expect)((0, _transform.snapToGrid)(15, 10)).toBe(20);
-  });
-  (0, _vitest.it)("snapPositionToGrid should snap x/y independently", () => {
-    const p = (0, _transform.snapPositionToGrid)({
-      x: 17,
-      y: 23
-    }, [10, 5]);
-    (0, _vitest.expect)(p).toEqual({
-      x: 20,
-      y: 25
+  (0, _vitest.describe)("screenToCanvas", () => {
+    (0, _vitest.it)("should convert screen coordinates to canvas coordinates", () => {
+      const transform = {
+        x: 100,
+        y: 50,
+        zoom: 2
+      };
+      const canvas = (0, _transform.screenToCanvas)(300, 250, transform);
+      (0, _vitest.expect)(canvas.x).toBe(100);
+      (0, _vitest.expect)(canvas.y).toBe(100);
+    });
+    (0, _vitest.it)("should handle zoom of 1", () => {
+      const transform = {
+        x: 0,
+        y: 0,
+        zoom: 1
+      };
+      const canvas = (0, _transform.screenToCanvas)(100, 200, transform);
+      (0, _vitest.expect)(canvas.x).toBe(100);
+      (0, _vitest.expect)(canvas.y).toBe(200);
+    });
+    (0, _vitest.it)("should handle negative transform offsets", () => {
+      const transform = {
+        x: -100,
+        y: -50,
+        zoom: 1
+      };
+      const canvas = (0, _transform.screenToCanvas)(50, 100, transform);
+      (0, _vitest.expect)(canvas.x).toBe(150);
+      (0, _vitest.expect)(canvas.y).toBe(150);
+    });
+    (0, _vitest.it)("should handle fractional zoom", () => {
+      const transform = {
+        x: 0,
+        y: 0,
+        zoom: 0.5
+      };
+      const canvas = (0, _transform.screenToCanvas)(100, 200, transform);
+      (0, _vitest.expect)(canvas.x).toBe(200);
+      (0, _vitest.expect)(canvas.y).toBe(400);
+    });
+  });
+  (0, _vitest.describe)("canvasToScreen", () => {
+    (0, _vitest.it)("should convert canvas coordinates to screen coordinates", () => {
+      const transform = {
+        x: 100,
+        y: 50,
+        zoom: 2
+      };
+      const screen = (0, _transform.canvasToScreen)(100, 100, transform);
+      (0, _vitest.expect)(screen.x).toBe(300);
+      (0, _vitest.expect)(screen.y).toBe(250);
+    });
+    (0, _vitest.it)("should handle zoom of 1", () => {
+      const transform = {
+        x: 0,
+        y: 0,
+        zoom: 1
+      };
+      const screen = (0, _transform.canvasToScreen)(100, 200, transform);
+      (0, _vitest.expect)(screen.x).toBe(100);
+      (0, _vitest.expect)(screen.y).toBe(200);
+    });
+    (0, _vitest.it)("should be inverse of screenToCanvas", () => {
+      const transform = {
+        x: 100,
+        y: 50,
+        zoom: 2
+      };
+      const original = {
+        x: 300,
+        y: 250
+      };
+      const canvas = (0, _transform.screenToCanvas)(original.x, original.y, transform);
+      const back = (0, _transform.canvasToScreen)(canvas.x, canvas.y, transform);
+      (0, _vitest.expect)(back.x).toBeCloseTo(original.x);
+      (0, _vitest.expect)(back.y).toBeCloseTo(original.y);
+    });
+  });
+  (0, _vitest.describe)("projectNodePosition", () => {
+    (0, _vitest.it)("should transform position between viewports", () => {
+      const from = {
+        x: 100,
+        y: 50,
+        zoom: 2
+      };
+      const to = {
+        x: -50,
+        y: 100,
+        zoom: 1
+      };
+      const position = {
+        x: 300,
+        y: 250
+      };
+      const projected = (0, _transform.projectNodePosition)(position, from, to);
+      (0, _vitest.expect)(projected).toHaveProperty("x");
+      (0, _vitest.expect)(projected).toHaveProperty("y");
+    });
+    (0, _vitest.it)("should handle identical viewports", () => {
+      const transform = {
+        x: 0,
+        y: 0,
+        zoom: 1
+      };
+      const position = {
+        x: 100,
+        y: 200
+      };
+      const projected = (0, _transform.projectNodePosition)(position, transform, transform);
+      (0, _vitest.expect)(projected).toEqual(position);
+    });
+  });
+  (0, _vitest.describe)("getElementPosition", () => {
+    (0, _vitest.it)("should calculate element position relative to container", () => {
+      const mockElement = {
+        getBoundingClientRect: () => ({
+          left: 100,
+          top: 50
+        })
+      };
+      const mockContainer = {
+        getBoundingClientRect: () => ({
+          left: 50,
+          top: 25
+        })
+      };
+      const pos = (0, _transform.getElementPosition)(mockElement, mockContainer);
+      (0, _vitest.expect)(pos.x).toBe(50);
+      (0, _vitest.expect)(pos.y).toBe(25);
+    });
+    (0, _vitest.it)("should handle element at container origin", () => {
+      const mockElement = {
+        getBoundingClientRect: () => ({
+          left: 100,
+          top: 100
+        })
+      };
+      const mockContainer = {
+        getBoundingClientRect: () => ({
+          left: 100,
+          top: 100
+        })
+      };
+      const pos = (0, _transform.getElementPosition)(mockElement, mockContainer);
+      (0, _vitest.expect)(pos.x).toBe(0);
+      (0, _vitest.expect)(pos.y).toBe(0);
+    });
+  });
+  (0, _vitest.describe)("getElementCanvasPosition", () => {
+    (0, _vitest.it)("should get element position in canvas coordinates", () => {
+      const mockElement = {
+        getBoundingClientRect: () => ({
+          left: 200,
+          top: 150
+        })
+      };
+      const mockContainer = {
+        getBoundingClientRect: () => ({
+          left: 100,
+          y: 50
+        })
+      };
+      const transform = {
+        x: 0,
+        y: 0,
+        zoom: 1
+      };
+      const pos = (0, _transform.getElementCanvasPosition)(mockElement, mockContainer, transform);
+      (0, _vitest.expect)(pos).toHaveProperty("x");
+      (0, _vitest.expect)(pos).toHaveProperty("y");
+    });
+  });
+  (0, _vitest.describe)("distanceBetweenPoints", () => {
+    (0, _vitest.it)("should calculate distance between two points", () => {
+      const p1 = {
+        x: 0,
+        y: 0
+      };
+      const p2 = {
+        x: 3,
+        y: 4
+      };
+      (0, _vitest.expect)((0, _transform.distanceBetweenPoints)(p1, p2)).toBe(5);
+    });
+    (0, _vitest.it)("should return 0 for same point", () => {
+      const p = {
+        x: 100,
+        y: 100
+      };
+      (0, _vitest.expect)((0, _transform.distanceBetweenPoints)(p, p)).toBe(0);
+    });
+    (0, _vitest.it)("should handle negative coordinates", () => {
+      const p1 = {
+        x: -3,
+        y: -4
+      };
+      const p2 = {
+        x: 0,
+        y: 0
+      };
+      (0, _vitest.expect)((0, _transform.distanceBetweenPoints)(p1, p2)).toBe(5);
+    });
+  });
+  (0, _vitest.describe)("getVector", () => {
+    (0, _vitest.it)("should calculate vector from source to target", () => {
+      const source = {
+        x: 10,
+        y: 20
+      };
+      const target = {
+        x: 30,
+        y: 50
+      };
+      const vector = (0, _transform.getVector)(source, target);
+      (0, _vitest.expect)(vector).toEqual({
+        x: 20,
+        y: 30
+      });
+    });
+    (0, _vitest.it)("should handle zero vector", () => {
+      const source = {
+        x: 100,
+        y: 100
+      };
+      const target = {
+        x: 100,
+        y: 100
+      };
+      const vector = (0, _transform.getVector)(source, target);
+      (0, _vitest.expect)(vector).toEqual({
+        x: 0,
+        y: 0
+      });
+    });
+    (0, _vitest.it)("should handle negative results", () => {
+      const source = {
+        x: 50,
+        y: 50
+      };
+      const target = {
+        x: 30,
+        y: 20
+      };
+      const vector = (0, _transform.getVector)(source, target);
+      (0, _vitest.expect)(vector).toEqual({
+        x: -20,
+        y: -30
+      });
+    });
+  });
+  (0, _vitest.describe)("getVectorMagnitude", () => {
+    (0, _vitest.it)("should calculate magnitude of vector", () => {
+      const vector = {
+        x: 3,
+        y: 4
+      };
+      (0, _vitest.expect)((0, _transform.getVectorMagnitude)(vector)).toBe(5);
+    });
+    (0, _vitest.it)("should return 0 for zero vector", () => {
+      const vector = {
+        x: 0,
+        y: 0
+      };
+      (0, _vitest.expect)((0, _transform.getVectorMagnitude)(vector)).toBe(0);
+    });
+    (0, _vitest.it)("should handle negative components", () => {
+      const vector = {
+        x: -3,
+        y: -4
+      };
+      (0, _vitest.expect)((0, _transform.getVectorMagnitude)(vector)).toBe(5);
+    });
+  });
+  (0, _vitest.describe)("normalizeVector", () => {
+    (0, _vitest.it)("should normalize a unit vector", () => {
+      const vector = {
+        x: 3,
+        y: 4
+      };
+      const normalized = (0, _transform.normalizeVector)(vector);
+      (0, _vitest.expect)(normalized.x).toBeCloseTo(0.6);
+      (0, _vitest.expect)(normalized.y).toBeCloseTo(0.8);
+    });
+    (0, _vitest.it)("should return zero vector for zero magnitude", () => {
+      const vector = {
+        x: 0,
+        y: 0
+      };
+      const normalized = (0, _transform.normalizeVector)(vector);
+      (0, _vitest.expect)(normalized).toEqual({
+        x: 0,
+        y: 0
+      });
+    });
+    (0, _vitest.it)("should produce unit magnitude vector", () => {
+      const vector = {
+        x: 5,
+        y: 12
+      };
+      const normalized = (0, _transform.normalizeVector)(vector);
+      const magnitude = (0, _transform.getVectorMagnitude)(normalized);
+      (0, _vitest.expect)(magnitude).toBeCloseTo(1);
+    });
+    (0, _vitest.it)("should handle negative components", () => {
+      const vector = {
+        x: -5,
+        y: 0
+      };
+      const normalized = (0, _transform.normalizeVector)(vector);
+      (0, _vitest.expect)(normalized.x).toBe(-1);
+      (0, _vitest.expect)(normalized.y).toBe(0);
+    });
+  });
+  (0, _vitest.describe)("snapToGrid", () => {
+    (0, _vitest.it)("should snap value to nearest grid point", () => {
+      (0, _vitest.expect)((0, _transform.snapToGrid)(0, 10)).toBe(0);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(5, 10)).toBe(10);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(10, 10)).toBe(10);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(15, 10)).toBe(20);
+    });
+    (0, _vitest.it)("should snap negative values toward zero", () => {
+      (0, _vitest.expect)((0, _transform.snapToGrid)(-15, 10)).toBe(-10);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(-25, 10)).toBe(-20);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(-55, 10)).toBe(-50);
+    });
+    (0, _vitest.it)("should snap very small negative values to zero", () => {
+      const result = (0, _transform.snapToGrid)(-5, 10);
+      (0, _vitest.expect)(Object.is(result, -0) || result === 0).toBe(true);
+    });
+    (0, _vitest.it)("should handle fractional values", () => {
+      (0, _vitest.expect)((0, _transform.snapToGrid)(2.5, 10)).toBe(0);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(7.5, 10)).toBe(10);
+    });
+    (0, _vitest.it)("should handle non-10 grid size", () => {
+      (0, _vitest.expect)((0, _transform.snapToGrid)(5, 5)).toBe(5);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(7, 5)).toBe(5);
+      (0, _vitest.expect)((0, _transform.snapToGrid)(8, 5)).toBe(10);
+    });
+  });
+  (0, _vitest.describe)("snapPositionToGrid", () => {
+    (0, _vitest.it)("should snap x and y independently", () => {
+      const pos = {
+        x: 17,
+        y: 23
+      };
+      const grid = [10, 5];
+      const snapped = (0, _transform.snapPositionToGrid)(pos, grid);
+      (0, _vitest.expect)(snapped).toEqual({
+        x: 20,
+        y: 25
+      });
+    });
+    (0, _vitest.it)("should handle zero coordinates", () => {
+      const pos = {
+        x: 0,
+        y: 0
+      };
+      const grid = [10, 5];
+      const snapped = (0, _transform.snapPositionToGrid)(pos, grid);
+      (0, _vitest.expect)(snapped).toEqual({
+        x: 0,
+        y: 0
+      });
+    });
+    (0, _vitest.it)("should handle different grid sizes for x and y", () => {
+      const pos = {
+        x: 100,
+        y: 200
+      };
+      const grid = [20, 25];
+      const snapped = (0, _transform.snapPositionToGrid)(pos, grid);
+      (0, _vitest.expect)(snapped).toEqual({
+        x: 100,
+        y: 200
+      });
     });
   });
 });