@yh-ui/flow 1.0.25 → 1.0.30

package/dist/__tests__/validation.test.cjs

@@ -1,95 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _validation = require("../utils/validation.cjs");
-(0, _vitest.describe)("flow/utils/validation", () => {
-  const nodeA = {
-    id: "A",
-    type: "default",
-    position: {
-      x: 0,
-      y: 0
-    },
-    data: {}
-  };
-  const nodeB = {
-    id: "B",
-    type: "default",
-    position: {
-      x: 0,
-      y: 0
-    },
-    data: {}
-  };
-  (0, _vitest.it)("isValidConnection should fail when source/target missing", () => {
-    (0, _vitest.expect)((0, _validation.isValidConnection)(void 0, nodeB, {
-      source: "A",
-      target: "B"
-    }).isValid).toBe(false);
-    (0, _vitest.expect)((0, _validation.isValidConnection)(nodeA, void 0, {
-      source: "A",
-      target: "B"
-    }).isValid).toBe(false);
-  });
-  (0, _vitest.it)("isValidConnection should reject self connection", () => {
-    const r = (0, _validation.isValidConnection)(nodeA, nodeA, {
-      source: "A",
-      target: "A"
-    });
-    (0, _vitest.expect)(r.isValid).toBe(false);
-  });
-  (0, _vitest.it)("createConnectionValidator should allow when no rules", () => {
-    const v = (0, _validation.createConnectionValidator)();
-    (0, _vitest.expect)(v({
-      source: "a",
-      target: "b"
-    })).toBe(true);
-  });
-  (0, _vitest.it)("createConnectionValidator should match by exact id / wildcard", () => {
-    const v = (0, _validation.createConnectionValidator)([{
-      source: "A",
-      target: "*"
-    }]);
-    (0, _vitest.expect)(v({
-      source: "A",
-      target: "B"
-    })).toBe(true);
-    (0, _vitest.expect)(v({
-      source: "X",
-      target: "B"
-    })).toBe(false);
-  });
-  (0, _vitest.it)("createConnectionValidator should match by regex string", () => {
-    const v = (0, _validation.createConnectionValidator)([{
-      source: "^node-\\d+$",
-      target: "^node-\\d+$"
-    }]);
-    (0, _vitest.expect)(v({
-      source: "node-1",
-      target: "node-2"
-    })).toBe(true);
-    (0, _vitest.expect)(v({
-      source: "A",
-      target: "node-2"
-    })).toBe(false);
-  });
-  (0, _vitest.it)("detectCycles should detect cycles after adding edge", () => {
-    const edges = [{
-      id: "e1",
-      source: "A",
-      target: "B"
-    }, {
-      id: "e2",
-      source: "B",
-      target: "C"
-    }];
-    (0, _vitest.expect)((0, _validation.detectCycles)(edges, {
-      source: "C",
-      target: "A"
-    })).toBe(true);
-    (0, _vitest.expect)((0, _validation.detectCycles)(edges, {
-      source: "C",
-      target: "D"
-    })).toBe(false);
-  });
-});

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

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

package/dist/__tests__/validation.test.mjs

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createConnectionValidator, detectCycles, isValidConnection } from "../utils/validation.mjs";
-describe("flow/utils/validation", () => {
-  const nodeA = { id: "A", type: "default", position: { x: 0, y: 0 }, data: {} };
-  const nodeB = { id: "B", type: "default", position: { x: 0, y: 0 }, data: {} };
-  it("isValidConnection should fail when source/target missing", () => {
-    expect(isValidConnection(void 0, nodeB, { source: "A", target: "B" }).isValid).toBe(false);
-    expect(isValidConnection(nodeA, void 0, { source: "A", target: "B" }).isValid).toBe(false);
-  });
-  it("isValidConnection should reject self connection", () => {
-    const r = isValidConnection(nodeA, nodeA, { source: "A", target: "A" });
-    expect(r.isValid).toBe(false);
-  });
-  it("createConnectionValidator should allow when no rules", () => {
-    const v = createConnectionValidator();
-    expect(v({ source: "a", target: "b" })).toBe(true);
-  });
-  it("createConnectionValidator should match by exact id / wildcard", () => {
-    const v = createConnectionValidator([{ source: "A", target: "*" }]);
-    expect(v({ source: "A", target: "B" })).toBe(true);
-    expect(v({ source: "X", target: "B" })).toBe(false);
-  });
-  it("createConnectionValidator should match by regex string", () => {
-    const v = createConnectionValidator([{ source: "^node-\\d+$", target: "^node-\\d+$" }]);
-    expect(v({ source: "node-1", target: "node-2" })).toBe(true);
-    expect(v({ source: "A", target: "node-2" })).toBe(false);
-  });
-  it("detectCycles should detect cycles after adding edge", () => {
-    const edges = [
-      { id: "e1", source: "A", target: "B" },
-      { id: "e2", source: "B", target: "C" }
-    ];
-    expect(detectCycles(edges, { source: "C", target: "A" })).toBe(true);
-    expect(detectCycles(edges, { source: "C", target: "D" })).toBe(false);
-  });
-});

package/dist/__tests__/viewport-types.test.cjs

@@ -1,324 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _viewport = require("../types/viewport.cjs");
-(0, _vitest.describe)("flow/types/viewport", () => {
-  (0, _vitest.describe)("ViewportTransform", () => {
-    (0, _vitest.it)("should define viewport with x, y, zoom", () => {
-      const transform = {
-        x: 100,
-        y: 50,
-        zoom: 1.5
-      };
-      (0, _vitest.expect)(transform.x).toBe(100);
-      (0, _vitest.expect)(transform.y).toBe(50);
-      (0, _vitest.expect)(transform.zoom).toBe(1.5);
-    });
-    (0, _vitest.it)("should allow negative coordinates", () => {
-      const transform = {
-        x: -100,
-        y: -50,
-        zoom: 0.5
-      };
-      (0, _vitest.expect)(transform.x).toBe(-100);
-      (0, _vitest.expect)(transform.y).toBe(-50);
-    });
-    (0, _vitest.it)("should allow zoom less than 1", () => {
-      const transform = {
-        x: 0,
-        y: 0,
-        zoom: 0.1
-      };
-      (0, _vitest.expect)(transform.zoom).toBe(0.1);
-    });
-    (0, _vitest.it)("should allow zoom greater than 1", () => {
-      const transform = {
-        x: 0,
-        y: 0,
-        zoom: 5
-      };
-      (0, _vitest.expect)(transform.zoom).toBe(5);
-    });
-  });
-  (0, _vitest.describe)("ViewportOptions", () => {
-    (0, _vitest.it)("should define full viewport options", () => {
-      const options = {
-        minZoom: 0.1,
-        maxZoom: 5,
-        translateExtent: [[0, 0], [1e3, 1e3]],
-        zoomStep: 0.1,
-        panZoomSpeed: 1,
-        zoomInMultiplier: 1.2,
-        zoomOutMultiplier: 0.8,
-        panning: true,
-        zooming: true,
-        zoomOnScroll: true,
-        zoomOnPinch: true,
-        panOnScroll: true,
-        panOnDrag: true,
-        fitViewOnInit: true,
-        fitViewOnInitOptions: {
-          padding: 0.2
-        }
-      };
-      (0, _vitest.expect)(options.minZoom).toBe(0.1);
-      (0, _vitest.expect)(options.maxZoom).toBe(5);
-      (0, _vitest.expect)(options.fitViewOnInit).toBe(true);
-    });
-    (0, _vitest.it)("should allow partial options", () => {
-      const options = {
-        minZoom: 0.2,
-        maxZoom: 3
-      };
-      (0, _vitest.expect)(options.minZoom).toBe(0.2);
-      (0, _vitest.expect)(options.maxZoom).toBe(3);
-    });
-  });
-  (0, _vitest.describe)("FitViewOptions", () => {
-    (0, _vitest.it)("should define fit view options", () => {
-      const options = {
-        padding: 0.3,
-        includeHiddenNodes: false,
-        minZoom: 0.5,
-        maxZoom: 2
-      };
-      (0, _vitest.expect)(options.padding).toBe(0.3);
-      (0, _vitest.expect)(options.includeHiddenNodes).toBe(false);
-    });
-  });
-  (0, _vitest.describe)("ScreenToFlowPositionOptions", () => {
-    (0, _vitest.it)("should define screen to flow position options", () => {
-      const options = {
-        offset: {
-          x: 10,
-          y: 20
-        },
-        snapToGrid: true,
-        gridSize: 15
-      };
-      (0, _vitest.expect)(options.offset?.x).toBe(10);
-      (0, _vitest.expect)(options.snapToGrid).toBe(true);
-      (0, _vitest.expect)(options.gridSize).toBe(15);
-    });
-  });
-  (0, _vitest.describe)("getViewportForBounds", () => {
-    (0, _vitest.it)("should calculate viewport to fit bounds within container", () => {
-      const bounds = {
-        x: 0,
-        y: 0,
-        width: 200,
-        height: 200
-      };
-      const viewport = (0, _viewport.getViewportForBounds)(bounds, 800, 600, 0.1, 5, 0.2);
-      (0, _vitest.expect)(viewport).toHaveProperty("x");
-      (0, _vitest.expect)(viewport).toHaveProperty("y");
-      (0, _vitest.expect)(viewport).toHaveProperty("zoom");
-      (0, _vitest.expect)(viewport.zoom).toBeGreaterThanOrEqual(0.1);
-      (0, _vitest.expect)(viewport.zoom).toBeLessThanOrEqual(5);
-    });
-    (0, _vitest.it)("should use default padding of 0.2", () => {
-      const bounds = {
-        x: 100,
-        y: 100,
-        width: 100,
-        height: 100
-      };
-      const viewport1 = (0, _viewport.getViewportForBounds)(bounds, 400, 300, 0.1, 5);
-      const viewport2 = (0, _viewport.getViewportForBounds)(bounds, 400, 300, 0.1, 5, 0.2);
-      (0, _vitest.expect)(viewport1.zoom).toBe(viewport2.zoom);
-    });
-    (0, _vitest.it)("should handle bounds at origin", () => {
-      const bounds = {
-        x: 0,
-        y: 0,
-        width: 100,
-        height: 50
-      };
-      const viewport = (0, _viewport.getViewportForBounds)(bounds, 800, 400, 0.1, 5, 0.1);
-      (0, _vitest.expect)(viewport.zoom).toBeGreaterThan(0);
-    });
-    (0, _vitest.it)("should respect minZoom constraint", () => {
-      const bounds = {
-        x: 0,
-        y: 0,
-        width: 1e4,
-        height: 1e4
-      };
-      const viewport = (0, _viewport.getViewportForBounds)(bounds, 800, 600, 0.5, 5, 0.2);
-      (0, _vitest.expect)(viewport.zoom).toBeGreaterThanOrEqual(0.5);
-    });
-    (0, _vitest.it)("should respect maxZoom constraint", () => {
-      const bounds = {
-        x: 0,
-        y: 0,
-        width: 10,
-        height: 10
-      };
-      const viewport = (0, _viewport.getViewportForBounds)(bounds, 800, 600, 0.1, 2, 0.2);
-      (0, _vitest.expect)(viewport.zoom).toBeLessThanOrEqual(2);
-    });
-  });
-  (0, _vitest.describe)("project", () => {
-    (0, _vitest.it)("should project screen coordinates to canvas coordinates", () => {
-      const transform = {
-        x: 100,
-        y: 50,
-        zoom: 2
-      };
-      const screenPos = {
-        x: 300,
-        y: 250
-      };
-      const canvasPos = (0, _viewport.project)(screenPos, transform);
-      (0, _vitest.expect)(canvasPos).toEqual({
-        x: 100,
-        y: 100
-      });
-    });
-    (0, _vitest.it)("should handle zoom of 1", () => {
-      const transform = {
-        x: 0,
-        y: 0,
-        zoom: 1
-      };
-      const screenPos = {
-        x: 100,
-        y: 200
-      };
-      const canvasPos = (0, _viewport.project)(screenPos, transform);
-      (0, _vitest.expect)(canvasPos).toEqual({
-        x: 100,
-        y: 200
-      });
-    });
-    (0, _vitest.it)("should handle negative viewport offset", () => {
-      const transform = {
-        x: -100,
-        y: -50,
-        zoom: 1
-      };
-      const screenPos = {
-        x: 0,
-        y: 0
-      };
-      const canvasPos = (0, _viewport.project)(screenPos, transform);
-      (0, _vitest.expect)(canvasPos.x).toBe(100);
-      (0, _vitest.expect)(canvasPos.y).toBe(50);
-    });
-    (0, _vitest.it)("should handle fractional zoom", () => {
-      const transform = {
-        x: 0,
-        y: 0,
-        zoom: 0.5
-      };
-      const screenPos = {
-        x: 100,
-        y: 100
-      };
-      const canvasPos = (0, _viewport.project)(screenPos, transform);
-      (0, _vitest.expect)(canvasPos.x).toBe(200);
-      (0, _vitest.expect)(canvasPos.y).toBe(200);
-    });
-  });
-  (0, _vitest.describe)("unproject", () => {
-    (0, _vitest.it)("should unproject canvas coordinates to screen coordinates", () => {
-      const transform = {
-        x: 100,
-        y: 50,
-        zoom: 2
-      };
-      const canvasPos = {
-        x: 100,
-        y: 100
-      };
-      const screenPos = (0, _viewport.unproject)(canvasPos, transform);
-      (0, _vitest.expect)(screenPos).toEqual({
-        x: 300,
-        y: 250
-      });
-    });
-    (0, _vitest.it)("should be inverse of project", () => {
-      const transform = {
-        x: 100,
-        y: 50,
-        zoom: 2
-      };
-      const originalScreen = {
-        x: 500,
-        y: 300
-      };
-      const canvas = (0, _viewport.project)(originalScreen, transform);
-      const restored = (0, _viewport.unproject)(canvas, transform);
-      (0, _vitest.expect)(restored).toEqual(originalScreen);
-    });
-  });
-  (0, _vitest.describe)("isNodeVisible", () => {
-    const transform = {
-      x: 0,
-      y: 0,
-      zoom: 1
-    };
-    const viewportWidth = 800;
-    const viewportHeight = 600;
-    (0, _vitest.it)("should return true for node within viewport", () => {
-      const node = {
-        position: {
-          x: 100,
-          y: 100
-        },
-        width: 100,
-        height: 100
-      };
-      (0, _vitest.expect)((0, _viewport.isNodeVisible)(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    (0, _vitest.it)("should return true for node at viewport edge", () => {
-      const node = {
-        position: {
-          x: 0,
-          y: 0
-        },
-        width: 100,
-        height: 100
-      };
-      (0, _vitest.expect)((0, _viewport.isNodeVisible)(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    (0, _vitest.it)("should return false for node completely outside viewport", () => {
-      const node = {
-        position: {
-          x: 2e3,
-          y: 2e3
-        },
-        width: 100,
-        height: 100
-      };
-      (0, _vitest.expect)((0, _viewport.isNodeVisible)(node, transform, viewportWidth, viewportHeight)).toBe(false);
-    });
-    (0, _vitest.it)("should return true for node with zero dimensions", () => {
-      const node = {
-        position: {
-          x: 100,
-          y: 100
-        },
-        width: 0,
-        height: 0
-      };
-      (0, _vitest.expect)((0, _viewport.isNodeVisible)(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    (0, _vitest.it)("should handle zoomed viewport", () => {
-      const zoomedTransform = {
-        x: 0,
-        y: 0,
-        zoom: 2
-      };
-      const node = {
-        position: {
-          x: 100,
-          y: 100
-        },
-        width: 100,
-        height: 100
-      };
-      (0, _vitest.expect)((0, _viewport.isNodeVisible)(node, zoomedTransform, viewportWidth, viewportHeight)).toBe(true);
-    });
-  });
-});

package/dist/__tests__/viewport-types.test.d.ts

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

package/dist/__tests__/viewport-types.test.mjs

@@ -1,207 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  getViewportForBounds,
-  project,
-  unproject,
-  isNodeVisible
-} from "../types/viewport.mjs";
-describe("flow/types/viewport", () => {
-  describe("ViewportTransform", () => {
-    it("should define viewport with x, y, zoom", () => {
-      const transform = { x: 100, y: 50, zoom: 1.5 };
-      expect(transform.x).toBe(100);
-      expect(transform.y).toBe(50);
-      expect(transform.zoom).toBe(1.5);
-    });
-    it("should allow negative coordinates", () => {
-      const transform = { x: -100, y: -50, zoom: 0.5 };
-      expect(transform.x).toBe(-100);
-      expect(transform.y).toBe(-50);
-    });
-    it("should allow zoom less than 1", () => {
-      const transform = { x: 0, y: 0, zoom: 0.1 };
-      expect(transform.zoom).toBe(0.1);
-    });
-    it("should allow zoom greater than 1", () => {
-      const transform = { x: 0, y: 0, zoom: 5 };
-      expect(transform.zoom).toBe(5);
-    });
-  });
-  describe("ViewportOptions", () => {
-    it("should define full viewport options", () => {
-      const options = {
-        minZoom: 0.1,
-        maxZoom: 5,
-        translateExtent: [[0, 0], [1e3, 1e3]],
-        zoomStep: 0.1,
-        panZoomSpeed: 1,
-        zoomInMultiplier: 1.2,
-        zoomOutMultiplier: 0.8,
-        panning: true,
-        zooming: true,
-        zoomOnScroll: true,
-        zoomOnPinch: true,
-        panOnScroll: true,
-        panOnDrag: true,
-        fitViewOnInit: true,
-        fitViewOnInitOptions: { padding: 0.2 }
-      };
-      expect(options.minZoom).toBe(0.1);
-      expect(options.maxZoom).toBe(5);
-      expect(options.fitViewOnInit).toBe(true);
-    });
-    it("should allow partial options", () => {
-      const options = {
-        minZoom: 0.2,
-        maxZoom: 3
-      };
-      expect(options.minZoom).toBe(0.2);
-      expect(options.maxZoom).toBe(3);
-    });
-  });
-  describe("FitViewOptions", () => {
-    it("should define fit view options", () => {
-      const options = {
-        padding: 0.3,
-        includeHiddenNodes: false,
-        minZoom: 0.5,
-        maxZoom: 2
-      };
-      expect(options.padding).toBe(0.3);
-      expect(options.includeHiddenNodes).toBe(false);
-    });
-  });
-  describe("ScreenToFlowPositionOptions", () => {
-    it("should define screen to flow position options", () => {
-      const options = {
-        offset: { x: 10, y: 20 },
-        snapToGrid: true,
-        gridSize: 15
-      };
-      expect(options.offset?.x).toBe(10);
-      expect(options.snapToGrid).toBe(true);
-      expect(options.gridSize).toBe(15);
-    });
-  });
-  describe("getViewportForBounds", () => {
-    it("should calculate viewport to fit bounds within container", () => {
-      const bounds = { x: 0, y: 0, width: 200, height: 200 };
-      const viewport = getViewportForBounds(bounds, 800, 600, 0.1, 5, 0.2);
-      expect(viewport).toHaveProperty("x");
-      expect(viewport).toHaveProperty("y");
-      expect(viewport).toHaveProperty("zoom");
-      expect(viewport.zoom).toBeGreaterThanOrEqual(0.1);
-      expect(viewport.zoom).toBeLessThanOrEqual(5);
-    });
-    it("should use default padding of 0.2", () => {
-      const bounds = { x: 100, y: 100, width: 100, height: 100 };
-      const viewport1 = getViewportForBounds(bounds, 400, 300, 0.1, 5);
-      const viewport2 = getViewportForBounds(bounds, 400, 300, 0.1, 5, 0.2);
-      expect(viewport1.zoom).toBe(viewport2.zoom);
-    });
-    it("should handle bounds at origin", () => {
-      const bounds = { x: 0, y: 0, width: 100, height: 50 };
-      const viewport = getViewportForBounds(bounds, 800, 400, 0.1, 5, 0.1);
-      expect(viewport.zoom).toBeGreaterThan(0);
-    });
-    it("should respect minZoom constraint", () => {
-      const bounds = { x: 0, y: 0, width: 1e4, height: 1e4 };
-      const viewport = getViewportForBounds(bounds, 800, 600, 0.5, 5, 0.2);
-      expect(viewport.zoom).toBeGreaterThanOrEqual(0.5);
-    });
-    it("should respect maxZoom constraint", () => {
-      const bounds = { x: 0, y: 0, width: 10, height: 10 };
-      const viewport = getViewportForBounds(bounds, 800, 600, 0.1, 2, 0.2);
-      expect(viewport.zoom).toBeLessThanOrEqual(2);
-    });
-  });
-  describe("project", () => {
-    it("should project screen coordinates to canvas coordinates", () => {
-      const transform = { x: 100, y: 50, zoom: 2 };
-      const screenPos = { x: 300, y: 250 };
-      const canvasPos = project(screenPos, transform);
-      expect(canvasPos).toEqual({ x: 100, y: 100 });
-    });
-    it("should handle zoom of 1", () => {
-      const transform = { x: 0, y: 0, zoom: 1 };
-      const screenPos = { x: 100, y: 200 };
-      const canvasPos = project(screenPos, transform);
-      expect(canvasPos).toEqual({ x: 100, y: 200 });
-    });
-    it("should handle negative viewport offset", () => {
-      const transform = { x: -100, y: -50, zoom: 1 };
-      const screenPos = { x: 0, y: 0 };
-      const canvasPos = project(screenPos, transform);
-      expect(canvasPos.x).toBe(100);
-      expect(canvasPos.y).toBe(50);
-    });
-    it("should handle fractional zoom", () => {
-      const transform = { x: 0, y: 0, zoom: 0.5 };
-      const screenPos = { x: 100, y: 100 };
-      const canvasPos = project(screenPos, transform);
-      expect(canvasPos.x).toBe(200);
-      expect(canvasPos.y).toBe(200);
-    });
-  });
-  describe("unproject", () => {
-    it("should unproject canvas coordinates to screen coordinates", () => {
-      const transform = { x: 100, y: 50, zoom: 2 };
-      const canvasPos = { x: 100, y: 100 };
-      const screenPos = unproject(canvasPos, transform);
-      expect(screenPos).toEqual({ x: 300, y: 250 });
-    });
-    it("should be inverse of project", () => {
-      const transform = { x: 100, y: 50, zoom: 2 };
-      const originalScreen = { x: 500, y: 300 };
-      const canvas = project(originalScreen, transform);
-      const restored = unproject(canvas, transform);
-      expect(restored).toEqual(originalScreen);
-    });
-  });
-  describe("isNodeVisible", () => {
-    const transform = { x: 0, y: 0, zoom: 1 };
-    const viewportWidth = 800;
-    const viewportHeight = 600;
-    it("should return true for node within viewport", () => {
-      const node = {
-        position: { x: 100, y: 100 },
-        width: 100,
-        height: 100
-      };
-      expect(isNodeVisible(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    it("should return true for node at viewport edge", () => {
-      const node = {
-        position: { x: 0, y: 0 },
-        width: 100,
-        height: 100
-      };
-      expect(isNodeVisible(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    it("should return false for node completely outside viewport", () => {
-      const node = {
-        position: { x: 2e3, y: 2e3 },
-        width: 100,
-        height: 100
-      };
-      expect(isNodeVisible(node, transform, viewportWidth, viewportHeight)).toBe(false);
-    });
-    it("should return true for node with zero dimensions", () => {
-      const node = {
-        position: { x: 100, y: 100 },
-        width: 0,
-        height: 0
-      };
-      expect(isNodeVisible(node, transform, viewportWidth, viewportHeight)).toBe(true);
-    });
-    it("should handle zoomed viewport", () => {
-      const zoomedTransform = { x: 0, y: 0, zoom: 2 };
-      const node = {
-        position: { x: 100, y: 100 },
-        width: 100,
-        height: 100
-      };
-      expect(isNodeVisible(node, zoomedTransform, viewportWidth, viewportHeight)).toBe(true);
-    });
-  });
-});