@yh-ui/flow 1.0.26 → 1.0.30

package/dist/__tests__/edge-utils.test.mjs

@@ -1,376 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  getHandlePosition,
-  getBezierPath,
-  getStraightPath,
-  getStepPath,
-  getSmoothStepPath,
-  getEdgePath,
-  getEdgeCenter,
-  shortenEndpoint
-} from "../utils/edge.mjs";
-function createMockNode(x, y, width = 150, height = 80, style) {
-  return {
-    id: "test",
-    type: "default",
-    position: { x, y },
-    width,
-    height,
-    style,
-    data: {},
-    selected: false,
-    dragging: false
-  };
-}
-describe("flow/utils/edge", () => {
-  describe("getHandlePosition", () => {
-    it("should return center for unknown position", () => {
-      const node = createMockNode(0, 0, 100, 50);
-      const result = getHandlePosition(node, "unknown");
-      expect(result.x).toBe(50);
-      expect(result.y).toBe(25);
-    });
-    it("should return top handle position", () => {
-      const node = createMockNode(10, 20, 100, 50);
-      const result = getHandlePosition(node, "top");
-      expect(result.x).toBe(60);
-      expect(result.y).toBe(20);
-    });
-    it("should return bottom handle position", () => {
-      const node = createMockNode(10, 20, 100, 50);
-      const result = getHandlePosition(node, "bottom");
-      expect(result.x).toBe(60);
-      expect(result.y).toBe(70);
-    });
-    it("should return left handle position", () => {
-      const node = createMockNode(10, 20, 100, 50);
-      const result = getHandlePosition(node, "left");
-      expect(result.x).toBe(10);
-      expect(result.y).toBe(45);
-    });
-    it("should return right handle position", () => {
-      const node = createMockNode(10, 20, 100, 50);
-      const result = getHandlePosition(node, "right");
-      expect(result.x).toBe(110);
-      expect(result.y).toBe(45);
-    });
-    it("should fallback to default dimensions when width/height are undefined", () => {
-      const node = {
-        position: { x: 0, y: 0 },
-        data: {},
-        selected: false,
-        dragging: false
-      };
-      const result = getHandlePosition(node, "right");
-      expect(result.x).toBe(150);
-      expect(result.y).toBe(20);
-    });
-    it("should use right as default position", () => {
-      const node = createMockNode(0, 0, 100, 50);
-      const result = getHandlePosition(node);
-      expect(result.x).toBe(100);
-      expect(result.y).toBe(25);
-    });
-  });
-  describe("getBezierPath", () => {
-    it("should generate bezier path", () => {
-      const result = getBezierPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("100,50");
-      expect(result).toContain("C");
-    });
-    it("should use custom curvature", () => {
-      const result = getBezierPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left",
-        curvature: 0.5
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("100,50");
-    });
-    it("should handle vertical movement", () => {
-      const result = getBezierPath({
-        sourceX: 50,
-        sourceY: 0,
-        targetX: 50,
-        targetY: 100,
-        sourcePosition: "bottom",
-        targetPosition: "top"
-      });
-      expect(result).toContain("M50,0");
-      expect(result).toContain("50,100");
-    });
-    it("should handle top to bottom direction", () => {
-      const result = getBezierPath({
-        sourceX: 50,
-        sourceY: 0,
-        targetX: 50,
-        targetY: 100,
-        sourcePosition: "top",
-        targetPosition: "bottom"
-      });
-      expect(result).toContain("M50,0");
-    });
-  });
-  describe("getStraightPath", () => {
-    it("should generate straight line path", () => {
-      const result = getStraightPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toBe("M0,0 L100,50");
-    });
-    it("should handle diagonal line", () => {
-      const result = getStraightPath({
-        sourceX: 10,
-        sourceY: 20,
-        targetX: 300,
-        targetY: 400,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toBe("M10,20 L300,400");
-    });
-  });
-  describe("getStepPath", () => {
-    it("should generate step path when source is horizontal and target is vertical", () => {
-      const result = getStepPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "top"
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("L");
-      expect(result).toContain("100,50");
-    });
-    it("should generate step path when source is vertical and target is horizontal", () => {
-      const result = getStepPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "top",
-        targetPosition: "right"
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("L");
-    });
-    it("should handle both horizontal", () => {
-      const result = getStepPath({
-        sourceX: 0,
-        sourceY: 50,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toContain("M0,50");
-      expect(result).toContain("L");
-    });
-    it("should handle both vertical", () => {
-      const result = getStepPath({
-        sourceX: 50,
-        sourceY: 0,
-        targetX: 50,
-        targetY: 100,
-        sourcePosition: "bottom",
-        targetPosition: "top"
-      });
-      expect(result).toContain("M50,0");
-      expect(result).toContain("L");
-    });
-  });
-  describe("getSmoothStepPath", () => {
-    it("should generate smooth step path for horizontal source", () => {
-      const result = getSmoothStepPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "top"
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("Q");
-      expect(result).toContain("100,50");
-    });
-    it("should generate smooth step path for vertical source", () => {
-      const result = getSmoothStepPath({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "bottom",
-        targetPosition: "right"
-      });
-      expect(result).toContain("M0,0");
-      expect(result).toContain("Q");
-    });
-  });
-  describe("getEdgePath", () => {
-    it("should return bezier path for bezier type", () => {
-      const result = getEdgePath("bezier", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toContain("C");
-    });
-    it("should return straight path for straight type", () => {
-      const result = getEdgePath("straight", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toBe("M0,0 L100,50");
-    });
-    it("should return step path for step type", () => {
-      const result = getEdgePath("step", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "top"
-      });
-      expect(result).toContain("L");
-    });
-    it("should return smooth step path for smoothstep type", () => {
-      const result = getEdgePath("smoothstep", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "top"
-      });
-      expect(result).toContain("Q");
-    });
-    it("should default to bezier for unknown type", () => {
-      const result = getEdgePath("unknown", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toContain("C");
-    });
-    it("should default to bezier for default type", () => {
-      const result = getEdgePath("default", {
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toContain("C");
-    });
-  });
-  describe("getEdgeCenter", () => {
-    it("should return center for bezier type", () => {
-      const result = getEdgeCenter({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left",
-        type: "bezier"
-      });
-      expect(result).toHaveProperty("x");
-      expect(result).toHaveProperty("y");
-      expect(result).toHaveProperty("ox");
-      expect(result).toHaveProperty("oy");
-    });
-    it("should return center for straight type", () => {
-      const result = getEdgeCenter({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left",
-        type: "straight"
-      });
-      expect(result.x).toBe(50);
-      expect(result.y).toBe(25);
-    });
-    it("should return center for step type", () => {
-      const result = getEdgeCenter({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left",
-        type: "step"
-      });
-      expect(result.x).toBe(50);
-      expect(result.y).toBe(25);
-    });
-    it("should default to bezier when type is undefined", () => {
-      const result = getEdgeCenter({
-        sourceX: 0,
-        sourceY: 0,
-        targetX: 100,
-        targetY: 50,
-        sourcePosition: "right",
-        targetPosition: "left"
-      });
-      expect(result).toHaveProperty("x");
-    });
-  });
-  describe("shortenEndpoint", () => {
-    it("should shorten endpoint in the direction of source", () => {
-      const result = shortenEndpoint(100, 50, 0, 0, 10);
-      expect(result.x).toBeLessThan(100);
-      expect(result.y).toBeLessThan(50);
-    });
-    it("should not shorten when distance is too small", () => {
-      const result = shortenEndpoint(5, 5, 0, 0, 10);
-      expect(result.x).toBe(5);
-      expect(result.y).toBe(5);
-    });
-    it("should shorten towards source", () => {
-      const result = shortenEndpoint(200, 100, 100, 50, 10);
-      const dx = 200 - 100;
-      const dy = 100 - 50;
-      const dist = Math.sqrt(dx * dx + dy * dy);
-      const factor = 10 / dist;
-      expect(result.x).toBeCloseTo(200 - dx * factor, 5);
-      expect(result.y).toBeCloseTo(100 - dy * factor, 5);
-    });
-    it("should handle vertical movement", () => {
-      const result = shortenEndpoint(50, 100, 50, 0, 10);
-      expect(result.x).toBe(50);
-      expect(result.y).toBeCloseTo(90, 0);
-    });
-  });
-});

package/dist/__tests__/edge.test.cjs

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

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

package/dist/__tests__/edge.test.mjs

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

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

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

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

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