@yh-ui/flow 1.0.25 → 1.0.30

package/dist/__tests__/flow.ssr.test.cjs

@@ -1,156 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _Flow = _interopRequireDefault(require("../Flow.vue"));
-var _ssr = require("./utils/ssr.cjs");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-(0, _vitest.describe)("Flow SSR", () => {
-  (0, _vitest.it)("should render Flow component in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: []
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with custom class in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      class: "custom-flow"
-    });
-    (0, _ssr.expectSSRHasClass)(html, "custom-flow");
-  });
-  (0, _vitest.it)("should render nodes in SSR", async () => {
-    const nodes = [{
-      id: "1",
-      type: "default",
-      position: {
-        x: 0,
-        y: 0
-      },
-      data: {
-        label: "Node 1"
-      }
-    }, {
-      id: "2",
-      type: "default",
-      position: {
-        x: 100,
-        y: 100
-      },
-      data: {
-        label: "Node 2"
-      }
-    }];
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes,
-      edges: []
-    });
-    (0, _ssr.expectSSRContains)(html, "Node 1");
-    (0, _ssr.expectSSRContains)(html, "Node 2");
-  });
-  (0, _vitest.it)("should render edges in SSR", async () => {
-    const nodes = [{
-      id: "1",
-      type: "default",
-      position: {
-        x: 0,
-        y: 0
-      },
-      data: {
-        label: "A"
-      }
-    }, {
-      id: "2",
-      type: "default",
-      position: {
-        x: 100,
-        y: 0
-      },
-      data: {
-        label: "B"
-      }
-    }];
-    const edges = [{
-      id: "e1",
-      source: "1",
-      target: "2"
-    }];
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes,
-      edges
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow-edge");
-  });
-  (0, _vitest.it)("should render with fitView props in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      fitView: true
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with minZoom and maxZoom in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      minZoom: 0.5,
-      maxZoom: 2
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with nodesDraggable false in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      nodesDraggable: false
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with edgesEditable false in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      edgesEditable: false
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with snapToGrid in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      snapToGrid: true,
-      snapGrid: [20, 20]
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should render with connection line style in SSR", async () => {
-    const html = await (0, _ssr.renderSSR)(_Flow.default, {
-      nodes: [],
-      edges: [],
-      connectionLineStyle: {
-        stroke: "#ff0000",
-        strokeWidth: 2
-      }
-    });
-    (0, _ssr.expectSSRContains)(html, "yh-flow");
-  });
-  (0, _vitest.it)("should hydrate without mismatch", async () => {
-    const nodes = [{
-      id: "1",
-      type: "default",
-      position: {
-        x: 0,
-        y: 0
-      },
-      data: {
-        label: "Test"
-      }
-    }];
-    const result = await (0, _ssr.testHydration)(_Flow.default, {
-      nodes,
-      edges: []
-    });
-    (0, _vitest.expect)(result.isMatch).toBe(true);
-  });
-});

package/dist/__tests__/flow.ssr.test.d.ts

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

package/dist/__tests__/flow.ssr.test.mjs

@@ -1,112 +0,0 @@
-import { describe, it, expect } from "vitest";
-import Flow from "../Flow.vue";
-import { renderSSR, expectSSRHasClass, expectSSRContains, testHydration } from "./utils/ssr.mjs";
-describe("Flow SSR", () => {
-  it("should render Flow component in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: []
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with custom class in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      class: "custom-flow"
-    });
-    expectSSRHasClass(html, "custom-flow");
-  });
-  it("should render nodes in SSR", async () => {
-    const nodes = [
-      {
-        id: "1",
-        type: "default",
-        position: { x: 0, y: 0 },
-        data: { label: "Node 1" }
-      },
-      {
-        id: "2",
-        type: "default",
-        position: { x: 100, y: 100 },
-        data: { label: "Node 2" }
-      }
-    ];
-    const html = await renderSSR(Flow, {
-      nodes,
-      edges: []
-    });
-    expectSSRContains(html, "Node 1");
-    expectSSRContains(html, "Node 2");
-  });
-  it("should render edges in SSR", async () => {
-    const nodes = [
-      { id: "1", type: "default", position: { x: 0, y: 0 }, data: { label: "A" } },
-      { id: "2", type: "default", position: { x: 100, y: 0 }, data: { label: "B" } }
-    ];
-    const edges = [{ id: "e1", source: "1", target: "2" }];
-    const html = await renderSSR(Flow, {
-      nodes,
-      edges
-    });
-    expectSSRContains(html, "yh-flow-edge");
-  });
-  it("should render with fitView props in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      fitView: true
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with minZoom and maxZoom in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      minZoom: 0.5,
-      maxZoom: 2
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with nodesDraggable false in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      nodesDraggable: false
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with edgesEditable false in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      edgesEditable: false
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with snapToGrid in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      snapToGrid: true,
-      snapGrid: [20, 20]
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should render with connection line style in SSR", async () => {
-    const html = await renderSSR(Flow, {
-      nodes: [],
-      edges: [],
-      connectionLineStyle: { stroke: "#ff0000", strokeWidth: 2 }
-    });
-    expectSSRContains(html, "yh-flow");
-  });
-  it("should hydrate without mismatch", async () => {
-    const nodes = [{ id: "1", type: "default", position: { x: 0, y: 0 }, data: { label: "Test" } }];
-    const result = await testHydration(Flow, {
-      nodes,
-      edges: []
-    });
-    expect(result.isMatch).toBe(true);
-  });
-});

package/dist/__tests__/geometry.test.cjs

@@ -1,191 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _geometry = require("../utils/geometry.cjs");
-(0, _vitest.describe)("flow/utils/geometry", () => {
-  (0, _vitest.it)("isPointInRect", () => {
-    (0, _vitest.expect)((0, _geometry.isPointInRect)({
-      x: 50,
-      y: 50
-    }, {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100
-    })).toBe(true);
-    (0, _vitest.expect)((0, _geometry.isPointInRect)({
-      x: 150,
-      y: 50
-    }, {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100
-    })).toBe(false);
-  });
-  (0, _vitest.it)("rectIntersect", () => {
-    (0, _vitest.expect)((0, _geometry.rectIntersect)({
-      x: 0,
-      y: 0,
-      width: 50,
-      height: 50
-    }, {
-      x: 25,
-      y: 25,
-      width: 50,
-      height: 50
-    })).toBe(true);
-    (0, _vitest.expect)((0, _geometry.rectIntersect)({
-      x: 0,
-      y: 0,
-      width: 10,
-      height: 10
-    }, {
-      x: 20,
-      y: 20,
-      width: 10,
-      height: 10
-    })).toBe(false);
-  });
-  (0, _vitest.it)("getRectIntersection", () => {
-    const r = (0, _geometry.getRectIntersection)({
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100
-    }, {
-      x: 50,
-      y: 50,
-      width: 100,
-      height: 100
-    });
-    (0, _vitest.expect)(r).not.toBeNull();
-    (0, _vitest.expect)(r.x).toBe(50);
-    (0, _vitest.expect)(r.y).toBe(50);
-    (0, _vitest.expect)(r.width).toBe(50);
-    (0, _vitest.expect)(r.height).toBe(50);
-  });
-  (0, _vitest.it)("getBoundingBox empty returns zeros", () => {
-    const box = (0, _geometry.getBoundingBox)([]);
-    (0, _vitest.expect)(box).toEqual({
-      x: 0,
-      y: 0,
-      width: 0,
-      height: 0
-    });
-  });
-  (0, _vitest.it)("getBoundingBox multiple points", () => {
-    const box = (0, _geometry.getBoundingBox)([{
-      x: 10,
-      y: 20
-    }, {
-      x: 30,
-      y: 5
-    }]);
-    (0, _vitest.expect)(box.x).toBe(10);
-    (0, _vitest.expect)(box.y).toBe(5);
-    (0, _vitest.expect)(box.width).toBe(20);
-    (0, _vitest.expect)(box.height).toBe(15);
-  });
-  (0, _vitest.it)("getNodeBounds", () => {
-    const nodes = [{
-      position: {
-        x: 0,
-        y: 0
-      },
-      width: 50,
-      height: 50
-    }, {
-      position: {
-        x: 100,
-        y: 100
-      },
-      width: 50,
-      height: 50
-    }];
-    const bounds = (0, _geometry.getNodeBounds)(nodes);
-    (0, _vitest.expect)(bounds.x).toBe(0);
-    (0, _vitest.expect)(bounds.y).toBe(0);
-    (0, _vitest.expect)(bounds.width).toBe(150);
-    (0, _vitest.expect)(bounds.height).toBe(150);
-  });
-  (0, _vitest.it)("pointToLineDistance", () => {
-    const d = (0, _geometry.pointToLineDistance)({
-      x: 0,
-      y: 0
-    }, {
-      x: 10,
-      y: 0
-    }, {
-      x: 10,
-      y: 10
-    });
-    (0, _vitest.expect)(d).toBeGreaterThanOrEqual(0);
-  });
-  (0, _vitest.it)("pointToPointDistance", () => {
-    (0, _vitest.expect)((0, _geometry.pointToPointDistance)({
-      x: 0,
-      y: 0
-    }, {
-      x: 3,
-      y: 4
-    })).toBe(5);
-  });
-  (0, _vitest.it)("degToRad and radToDeg", () => {
-    (0, _vitest.expect)((0, _geometry.degToRad)(180)).toBeCloseTo(Math.PI);
-    (0, _vitest.expect)((0, _geometry.radToDeg)(Math.PI)).toBeCloseTo(180);
-  });
-  (0, _vitest.it)("getLineIntersection", () => {
-    const p = (0, _geometry.getLineIntersection)({
-      x: 0,
-      y: 0
-    }, {
-      x: 10,
-      y: 10
-    }, {
-      x: 0,
-      y: 10
-    }, {
-      x: 10,
-      y: 0
-    });
-    (0, _vitest.expect)(p).not.toBeNull();
-    (0, _vitest.expect)(typeof p.x).toBe("number");
-    (0, _vitest.expect)(typeof p.y).toBe("number");
-  });
-  (0, _vitest.it)("getAngle", () => {
-    const a = (0, _geometry.getAngle)({
-      x: 0,
-      y: 0
-    }, {
-      x: 1,
-      y: 0
-    });
-    (0, _vitest.expect)(a).toBe(0);
-  });
-  (0, _vitest.it)("pointToRectDistance", () => {
-    const d = (0, _geometry.pointToRectDistance)({
-      x: -10,
-      y: 50
-    }, {
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100
-    });
-    (0, _vitest.expect)(d).toBe(10);
-  });
-  (0, _vitest.it)("viewportIntersectsBounds", () => {
-    (0, _vitest.expect)((0, _geometry.viewportIntersectsBounds)({
-      x: 0,
-      y: 0,
-      width: 800,
-      height: 600
-    }, {
-      x: 0,
-      y: 0,
-      width: 1e3,
-      height: 1e3
-    }, 1)).toBe(true);
-  });
-});

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

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

package/dist/__tests__/geometry.test.mjs

@@ -1,105 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  isPointInRect,
-  rectIntersect,
-  getRectIntersection,
-  getBoundingBox,
-  getNodeBounds,
-  pointToLineDistance,
-  pointToPointDistance,
-  degToRad,
-  radToDeg,
-  getLineIntersection,
-  getAngle,
-  pointToRectDistance,
-  viewportIntersectsBounds
-} from "../utils/geometry.mjs";
-describe("flow/utils/geometry", () => {
-  it("isPointInRect", () => {
-    expect(isPointInRect({ x: 50, y: 50 }, { x: 0, y: 0, width: 100, height: 100 })).toBe(true);
-    expect(isPointInRect({ x: 150, y: 50 }, { x: 0, y: 0, width: 100, height: 100 })).toBe(false);
-  });
-  it("rectIntersect", () => {
-    expect(
-      rectIntersect({ x: 0, y: 0, width: 50, height: 50 }, { x: 25, y: 25, width: 50, height: 50 })
-    ).toBe(true);
-    expect(
-      rectIntersect({ x: 0, y: 0, width: 10, height: 10 }, { x: 20, y: 20, width: 10, height: 10 })
-    ).toBe(false);
-  });
-  it("getRectIntersection", () => {
-    const r = getRectIntersection(
-      { x: 0, y: 0, width: 100, height: 100 },
-      { x: 50, y: 50, width: 100, height: 100 }
-    );
-    expect(r).not.toBeNull();
-    expect(r.x).toBe(50);
-    expect(r.y).toBe(50);
-    expect(r.width).toBe(50);
-    expect(r.height).toBe(50);
-  });
-  it("getBoundingBox empty returns zeros", () => {
-    const box = getBoundingBox([]);
-    expect(box).toEqual({ x: 0, y: 0, width: 0, height: 0 });
-  });
-  it("getBoundingBox multiple points", () => {
-    const box = getBoundingBox([
-      { x: 10, y: 20 },
-      { x: 30, y: 5 }
-    ]);
-    expect(box.x).toBe(10);
-    expect(box.y).toBe(5);
-    expect(box.width).toBe(20);
-    expect(box.height).toBe(15);
-  });
-  it("getNodeBounds", () => {
-    const nodes = [
-      { position: { x: 0, y: 0 }, width: 50, height: 50 },
-      { position: { x: 100, y: 100 }, width: 50, height: 50 }
-    ];
-    const bounds = getNodeBounds(nodes);
-    expect(bounds.x).toBe(0);
-    expect(bounds.y).toBe(0);
-    expect(bounds.width).toBe(150);
-    expect(bounds.height).toBe(150);
-  });
-  it("pointToLineDistance", () => {
-    const d = pointToLineDistance({ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 10, y: 10 });
-    expect(d).toBeGreaterThanOrEqual(0);
-  });
-  it("pointToPointDistance", () => {
-    expect(pointToPointDistance({ x: 0, y: 0 }, { x: 3, y: 4 })).toBe(5);
-  });
-  it("degToRad and radToDeg", () => {
-    expect(degToRad(180)).toBeCloseTo(Math.PI);
-    expect(radToDeg(Math.PI)).toBeCloseTo(180);
-  });
-  it("getLineIntersection", () => {
-    const p = getLineIntersection(
-      { x: 0, y: 0 },
-      { x: 10, y: 10 },
-      { x: 0, y: 10 },
-      { x: 10, y: 0 }
-    );
-    expect(p).not.toBeNull();
-    expect(typeof p.x).toBe("number");
-    expect(typeof p.y).toBe("number");
-  });
-  it("getAngle", () => {
-    const a = getAngle({ x: 0, y: 0 }, { x: 1, y: 0 });
-    expect(a).toBe(0);
-  });
-  it("pointToRectDistance", () => {
-    const d = pointToRectDistance({ x: -10, y: 50 }, { x: 0, y: 0, width: 100, height: 100 });
-    expect(d).toBe(10);
-  });
-  it("viewportIntersectsBounds", () => {
-    expect(
-      viewportIntersectsBounds(
-        { x: 0, y: 0, width: 800, height: 600 },
-        { x: 0, y: 0, width: 1e3, height: 1e3 },
-        1
-      )
-    ).toBe(true);
-  });
-});

package/dist/__tests__/graph.test.cjs

@@ -1,115 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _graph = require("../utils/graph.cjs");
-(0, _vitest.describe)("flow/utils/graph", () => {
-  (0, _vitest.it)("hasCycle should detect cycle", () => {
-    const edges = [{
-      source: "A",
-      target: "B"
-    }, {
-      source: "B",
-      target: "C"
-    }, {
-      source: "C",
-      target: "A"
-    }];
-    (0, _vitest.expect)((0, _graph.hasCycle)(edges, "A")).toBe(true);
-  });
-  (0, _vitest.it)("hasCycle should return false for DAG", () => {
-    const edges = [{
-      source: "A",
-      target: "B"
-    }, {
-      source: "B",
-      target: "C"
-    }];
-    (0, _vitest.expect)((0, _graph.hasCycle)(edges, "A")).toBe(false);
-  });
-  (0, _vitest.it)("topologicalSort should return order for DAG", () => {
-    const nodes = [{
-      id: "A"
-    }, {
-      id: "B"
-    }, {
-      id: "C"
-    }];
-    const edges = [{
-      source: "A",
-      target: "B"
-    }, {
-      source: "B",
-      target: "C"
-    }];
-    const order = (0, _graph.topologicalSort)(nodes, edges);
-    (0, _vitest.expect)(order).toHaveLength(3);
-    const ai = order.indexOf("A");
-    const bi = order.indexOf("B");
-    const ci = order.indexOf("C");
-    (0, _vitest.expect)(ai).toBeLessThan(bi);
-    (0, _vitest.expect)(bi).toBeLessThan(ci);
-  });
-  (0, _vitest.it)("findAllPaths should return paths between two nodes", () => {
-    const edges = [{
-      source: "1",
-      target: "2"
-    }, {
-      source: "1",
-      target: "3"
-    }, {
-      source: "2",
-      target: "4"
-    }, {
-      source: "3",
-      target: "4"
-    }];
-    const paths = (0, _graph.findAllPaths)(edges, "1", "4");
-    (0, _vitest.expect)(paths.length).toBeGreaterThanOrEqual(1);
-    (0, _vitest.expect)(paths.every(p => p[0] === "1" && p[p.length - 1] === "4")).toBe(true);
-  });
-  (0, _vitest.it)("findConnectedComponents should return components", () => {
-    const nodes = [{
-      id: "A"
-    }, {
-      id: "B"
-    }, {
-      id: "C"
-    }, {
-      id: "D"
-    }];
-    const edges = [{
-      source: "A",
-      target: "B"
-    }, {
-      source: "C",
-      target: "D"
-    }];
-    const components = (0, _graph.findConnectedComponents)(nodes, edges);
-    (0, _vitest.expect)(components).toHaveLength(2);
-    (0, _vitest.expect)(components.some(c => c.includes("A") && c.includes("B"))).toBe(true);
-    (0, _vitest.expect)(components.some(c => c.includes("C") && c.includes("D"))).toBe(true);
-  });
-  (0, _vitest.it)("bfs should traverse in breadth order", () => {
-    const adj = /* @__PURE__ */new Map();
-    adj.set("1", ["2", "3"]);
-    adj.set("2", ["4"]);
-    adj.set("3", []);
-    adj.set("4", []);
-    const result = (0, _graph.bfs)(adj, "1");
-    (0, _vitest.expect)(result).toContain("1");
-    (0, _vitest.expect)(result).toContain("2");
-    (0, _vitest.expect)(result).toContain("3");
-    (0, _vitest.expect)(result).toContain("4");
-    (0, _vitest.expect)(result[0]).toBe("1");
-  });
-  (0, _vitest.it)("dfs should traverse in depth order", () => {
-    const adj = /* @__PURE__ */new Map();
-    adj.set("1", ["2", "3"]);
-    adj.set("2", ["4"]);
-    adj.set("3", []);
-    adj.set("4", []);
-    const result = (0, _graph.dfs)(adj, "1");
-    (0, _vitest.expect)(result).toHaveLength(4);
-    (0, _vitest.expect)(result[0]).toBe("1");
-  });
-});

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

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