@yh-ui/flow 0.1.21

package/dist/__tests__/edge.test.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _edge = require("../utils/edge.cjs");
+const params = {
+  sourceX: 0,
+  sourceY: 0,
+  targetX: 100,
+  targetY: 80,
+  sourcePosition: "right",
+  targetPosition: "left"
+};
+(0, _vitest.describe)("flow/utils/edge", () => {
+  (0, _vitest.it)("getStraightPath should return M and L", () => {
+    const d = (0, _edge.getStraightPath)(params);
+    (0, _vitest.expect)(d).toMatch(/^M\d+,\d+\s+L\d+,\d+$/);
+    (0, _vitest.expect)(d).toContain("M0,0");
+    (0, _vitest.expect)(d).toContain("L100,80");
+  });
+  (0, _vitest.it)("getBezierPath should return M and C", () => {
+    const d = (0, _edge.getBezierPath)(params);
+    (0, _vitest.expect)(d).toMatch(/^M\d+,\d+\s+C[\d.,\s]+$/);
+    (0, _vitest.expect)(d).toContain("M0,0");
+    (0, _vitest.expect)(d).toContain("C");
+  });
+  (0, _vitest.it)("getStepPath should return path with L segments", () => {
+    const d = (0, _edge.getStepPath)(params);
+    (0, _vitest.expect)(d).toMatch(/^M[\d.,]+(?:\s+L[\d.,]+)+$/);
+  });
+  (0, _vitest.it)("getSmoothStepPath should return path with M and L", () => {
+    const d = (0, _edge.getSmoothStepPath)(params);
+    (0, _vitest.expect)(d).toContain("M");
+    (0, _vitest.expect)(d).toContain("L");
+  });
+  (0, _vitest.it)("getEdgePath should dispatch by type", () => {
+    (0, _vitest.expect)((0, _edge.getEdgePath)("straight", params)).toContain("L");
+    (0, _vitest.expect)((0, _edge.getEdgePath)("bezier", params)).toContain("C");
+    (0, _vitest.expect)((0, _edge.getEdgePath)("step", params)).toContain("M");
+    (0, _vitest.expect)((0, _edge.getEdgePath)("smoothstep", params)).toContain("M");
+    (0, _vitest.expect)((0, _edge.getEdgePath)("default", params)).toContain("C");
+  });
+  (0, _vitest.it)("getEdgeCenter should return midpoint", () => {
+    const c = (0, _edge.getEdgeCenter)(params);
+    (0, _vitest.expect)(c.x).toBe(50);
+    (0, _vitest.expect)(c.y).toBe(40);
+    (0, _vitest.expect)(c.ox).toBe(50);
+    (0, _vitest.expect)(c.oy).toBe(40);
+  });
+  (0, _vitest.it)("getEdgePosition should return source/target with direction offset", () => {
+    const pos = (0, _edge.getEdgePosition)(params.sourceX, params.sourceY, params.targetX, params.targetY, params.sourcePosition, params.targetPosition);
+    (0, _vitest.expect)(pos).toHaveProperty("sx");
+    (0, _vitest.expect)(pos).toHaveProperty("sy");
+    (0, _vitest.expect)(pos).toHaveProperty("tx");
+    (0, _vitest.expect)(pos).toHaveProperty("ty");
+  });
+});

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

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

package/dist/__tests__/edge.test.mjs

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest";
+import {
+  getEdgePath,
+  getStraightPath,
+  getBezierPath,
+  getStepPath,
+  getSmoothStepPath,
+  getEdgeCenter,
+  getEdgePosition
+} from "../utils/edge.mjs";
+const params = {
+  sourceX: 0,
+  sourceY: 0,
+  targetX: 100,
+  targetY: 80,
+  sourcePosition: "right",
+  targetPosition: "left"
+};
+describe("flow/utils/edge", () => {
+  it("getStraightPath should return M and L", () => {
+    const d = getStraightPath(params);
+    expect(d).toMatch(/^M\d+,\d+\s+L\d+,\d+$/);
+    expect(d).toContain("M0,0");
+    expect(d).toContain("L100,80");
+  });
+  it("getBezierPath should return M and C", () => {
+    const d = getBezierPath(params);
+    expect(d).toMatch(/^M\d+,\d+\s+C[\d.,\s]+$/);
+    expect(d).toContain("M0,0");
+    expect(d).toContain("C");
+  });
+  it("getStepPath should return path with L segments", () => {
+    const d = getStepPath(params);
+    expect(d).toMatch(/^M[\d.,]+(?:\s+L[\d.,]+)+$/);
+  });
+  it("getSmoothStepPath should return path with M and L", () => {
+    const d = getSmoothStepPath(params);
+    expect(d).toContain("M");
+    expect(d).toContain("L");
+  });
+  it("getEdgePath should dispatch by type", () => {
+    expect(getEdgePath("straight", params)).toContain("L");
+    expect(getEdgePath("bezier", params)).toContain("C");
+    expect(getEdgePath("step", params)).toContain("M");
+    expect(getEdgePath("smoothstep", params)).toContain("M");
+    expect(getEdgePath("default", params)).toContain("C");
+  });
+  it("getEdgeCenter should return midpoint", () => {
+    const c = getEdgeCenter(params);
+    expect(c.x).toBe(50);
+    expect(c.y).toBe(40);
+    expect(c.ox).toBe(50);
+    expect(c.oy).toBe(40);
+  });
+  it("getEdgePosition should return source/target with direction offset", () => {
+    const pos = getEdgePosition(
+      params.sourceX,
+      params.sourceY,
+      params.targetX,
+      params.targetY,
+      params.sourcePosition,
+      params.targetPosition
+    );
+    expect(pos).toHaveProperty("sx");
+    expect(pos).toHaveProperty("sy");
+    expect(pos).toHaveProperty("tx");
+    expect(pos).toHaveProperty("ty");
+  });
+});

package/dist/__tests__/event-bus.test.cjs

@@ -0,0 +1,80 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _eventBus = require("../utils/event-bus.cjs");
+(0, _vitest.describe)("flow/utils/event-bus", () => {
+  (0, _vitest.it)("should subscribe and emit", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const fn = _vitest.vi.fn();
+    bus.on("viewport:change", fn);
+    bus.emit("viewport:change", {
+      transform: {
+        x: 10,
+        y: 20,
+        zoom: 1
+      }
+    });
+    (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+    (0, _vitest.expect)(fn).toHaveBeenCalledWith({
+      transform: {
+        x: 10,
+        y: 20,
+        zoom: 1
+      }
+    });
+  });
+  (0, _vitest.it)("should off unsubscribe", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const fn = _vitest.vi.fn();
+    bus.on("viewport:change", fn);
+    bus.off("viewport:change", fn);
+    bus.emit("viewport:change", {
+      transform: {
+        x: 0,
+        y: 0,
+        zoom: 1
+      }
+    });
+    (0, _vitest.expect)(fn).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("should once call handler only once", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const fn = _vitest.vi.fn();
+    bus.once("selection:change", fn);
+    bus.emit("selection:change", {
+      selectedNodes: [],
+      selectedEdges: []
+    });
+    (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+  });
+  (0, _vitest.it)("should emit void event without payload", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const fn = _vitest.vi.fn();
+    bus.on("connect:cancel", fn);
+    bus.emit("connect:cancel");
+    (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+  });
+  (0, _vitest.it)("listenerCount", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const f1 = _vitest.vi.fn();
+    const f2 = _vitest.vi.fn();
+    bus.on("node:click", f1);
+    bus.on("node:click", f2);
+    (0, _vitest.expect)(bus.listenerCount("node:click")).toBe(2);
+    (0, _vitest.expect)(bus.listenerCount()).toBe(2);
+  });
+  (0, _vitest.it)("clear should remove all handlers", () => {
+    const bus = (0, _eventBus.createEventBus)();
+    const fn = _vitest.vi.fn();
+    bus.on("viewport:change", fn);
+    bus.clear();
+    bus.emit("viewport:change", {
+      transform: {
+        x: 0,
+        y: 0,
+        zoom: 1
+      }
+    });
+    (0, _vitest.expect)(fn).not.toHaveBeenCalled();
+  });
+});

package/dist/__tests__/event-bus.test.d.ts

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

package/dist/__tests__/event-bus.test.mjs

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi } from "vitest";
+import { createEventBus } from "../utils/event-bus.mjs";
+describe("flow/utils/event-bus", () => {
+  it("should subscribe and emit", () => {
+    const bus = createEventBus();
+    const fn = vi.fn();
+    bus.on("viewport:change", fn);
+    bus.emit("viewport:change", { transform: { x: 10, y: 20, zoom: 1 } });
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith({ transform: { x: 10, y: 20, zoom: 1 } });
+  });
+  it("should off unsubscribe", () => {
+    const bus = createEventBus();
+    const fn = vi.fn();
+    bus.on("viewport:change", fn);
+    bus.off("viewport:change", fn);
+    bus.emit("viewport:change", { transform: { x: 0, y: 0, zoom: 1 } });
+    expect(fn).not.toHaveBeenCalled();
+  });
+  it("should once call handler only once", () => {
+    const bus = createEventBus();
+    const fn = vi.fn();
+    bus.once("selection:change", fn);
+    bus.emit("selection:change", { selectedNodes: [], selectedEdges: [] });
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+  it("should emit void event without payload", () => {
+    const bus = createEventBus();
+    const fn = vi.fn();
+    bus.on("connect:cancel", fn);
+    bus.emit("connect:cancel");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+  it("listenerCount", () => {
+    const bus = createEventBus();
+    const f1 = vi.fn();
+    const f2 = vi.fn();
+    bus.on("node:click", f1);
+    bus.on("node:click", f2);
+    expect(bus.listenerCount("node:click")).toBe(2);
+    expect(bus.listenerCount()).toBe(2);
+  });
+  it("clear should remove all handlers", () => {
+    const bus = createEventBus();
+    const fn = vi.fn();
+    bus.on("viewport:change", fn);
+    bus.clear();
+    bus.emit("viewport:change", { transform: { x: 0, y: 0, zoom: 1 } });
+    expect(fn).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,156 @@
+"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

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

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

@@ -0,0 +1,112 @@
+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);
+  });
+});