@yh-ui/flow 1.0.25 → 1.0.30

package/dist/__tests__/transform.test.cjs

@@ -1,384 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _transform = require("../utils/transform.cjs");
-(0, _vitest.describe)("flow/utils/transform", () => {
-  (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
-      });
-    });
-  });
-});

package/dist/__tests__/transform.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/transform.test.mjs

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