@yh-ui/flow 0.1.21

package/dist/__tests__/geometry.test.cjs

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

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

package/dist/__tests__/geometry.test.mjs

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

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

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

package/dist/__tests__/graph.test.mjs

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import {
+  hasCycle,
+  topologicalSort,
+  findAllPaths,
+  findConnectedComponents,
+  bfs,
+  dfs
+} from "../utils/graph.mjs";
+describe("flow/utils/graph", () => {
+  it("hasCycle should detect cycle", () => {
+    const edges = [
+      { source: "A", target: "B" },
+      { source: "B", target: "C" },
+      { source: "C", target: "A" }
+    ];
+    expect(hasCycle(edges, "A")).toBe(true);
+  });
+  it("hasCycle should return false for DAG", () => {
+    const edges = [
+      { source: "A", target: "B" },
+      { source: "B", target: "C" }
+    ];
+    expect(hasCycle(edges, "A")).toBe(false);
+  });
+  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 = topologicalSort(nodes, edges);
+    expect(order).toHaveLength(3);
+    const ai = order.indexOf("A");
+    const bi = order.indexOf("B");
+    const ci = order.indexOf("C");
+    expect(ai).toBeLessThan(bi);
+    expect(bi).toBeLessThan(ci);
+  });
+  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 = findAllPaths(edges, "1", "4");
+    expect(paths.length).toBeGreaterThanOrEqual(1);
+    expect(paths.every((p) => p[0] === "1" && p[p.length - 1] === "4")).toBe(true);
+  });
+  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 = findConnectedComponents(nodes, edges);
+    expect(components).toHaveLength(2);
+    expect(components.some((c) => c.includes("A") && c.includes("B"))).toBe(true);
+    expect(components.some((c) => c.includes("C") && c.includes("D"))).toBe(true);
+  });
+  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 = bfs(adj, "1");
+    expect(result).toContain("1");
+    expect(result).toContain("2");
+    expect(result).toContain("3");
+    expect(result).toContain("4");
+    expect(result[0]).toBe("1");
+  });
+  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 = dfs(adj, "1");
+    expect(result).toHaveLength(4);
+    expect(result[0]).toBe("1");
+  });
+});

package/dist/__tests__/history-plugin.test.cjs

@@ -0,0 +1,191 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _history = require("../plugins/plugins/history.cjs");
+function createMockFlow() {
+  const nodes = (0, _vue.ref)([{
+    id: "1",
+    type: "default",
+    position: {
+      x: 0,
+      y: 0
+    },
+    data: {
+      label: "A"
+    }
+  }]);
+  const edges = (0, _vue.ref)([]);
+  const eventHandlers = {};
+  const flow = {
+    nodes,
+    edges,
+    viewport: (0, _vue.ref)({
+      x: 0,
+      y: 0,
+      zoom: 1
+    }),
+    addNode: _vitest.vi.fn(),
+    removeNode: _vitest.vi.fn(),
+    updateNode: _vitest.vi.fn(),
+    getNode: _vitest.vi.fn(),
+    addEdge: _vitest.vi.fn(),
+    removeEdge: _vitest.vi.fn(),
+    updateEdge: _vitest.vi.fn(),
+    getEdge: _vitest.vi.fn(),
+    setViewport: _vitest.vi.fn(),
+    fitView: _vitest.vi.fn(),
+    zoomIn: _vitest.vi.fn(),
+    zoomOut: _vitest.vi.fn(),
+    centerView: _vitest.vi.fn(),
+    selectNode: _vitest.vi.fn(),
+    selectEdge: _vitest.vi.fn(),
+    clearSelection: _vitest.vi.fn(),
+    getNodes: () => nodes.value,
+    getEdges: () => edges.value,
+    getViewport: () => ({
+      x: 0,
+      y: 0,
+      zoom: 1
+    }),
+    screenToCanvas: _vitest.vi.fn().mockReturnValue({
+      x: 0,
+      y: 0
+    }),
+    canvasToScreen: _vitest.vi.fn().mockReturnValue({
+      x: 0,
+      y: 0
+    }),
+    on: _vitest.vi.fn((event, handler) => {
+      if (!eventHandlers[event]) eventHandlers[event] = [];
+      eventHandlers[event].push(handler);
+    }),
+    off: _vitest.vi.fn(),
+    emit: _vitest.vi.fn(),
+    isValidConnection: _vitest.vi.fn().mockReturnValue(true),
+    $el: void 0,
+    draggingNodeId: (0, _vue.ref)(null),
+    draggingPosition: (0, _vue.ref)(null),
+    usePlugin: _vitest.vi.fn(),
+    removePlugin: _vitest.vi.fn()
+  };
+  return flow;
+}
+(0, _vitest.describe)("createHistoryPlugin", () => {
+  (0, _vitest.it)("should be created with correct metadata", () => {
+    const plugin = (0, _history.createHistoryPlugin)();
+    (0, _vitest.expect)(plugin.id).toBe("history");
+    (0, _vitest.expect)(plugin.name).toBe("History");
+    (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+  });
+  (0, _vitest.it)("should install and expose undo/redo on flow instance", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    (0, _vitest.expect)(typeof flow.undo).toBe("function");
+    (0, _vitest.expect)(typeof flow.redo).toBe("function");
+    (0, _vitest.expect)(typeof flow.saveSnapshot).toBe("function");
+    (0, _vitest.expect)(typeof flow.clearHistory).toBe("function");
+    (0, _vitest.expect)(typeof flow.jumpToStep).toBe("function");
+    (0, _vitest.expect)(typeof flow.getHistory).toBe("function");
+  });
+  (0, _vitest.it)("should save initial snapshot on install", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    const history = plugin.getHistory();
+    (0, _vitest.expect)(history.length).toBe(1);
+    (0, _vitest.expect)(history[0].description).toBe("initial");
+  });
+  (0, _vitest.it)("should correctly undo and redo node position changes", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("move node");
+    (0, _vitest.expect)(plugin.canUndo.value).toBe(true);
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(false);
+    plugin.undo();
+    (0, _vitest.expect)(flow.nodes.value[0].position.x).toBe(0);
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(true);
+    plugin.redo();
+    (0, _vitest.expect)(flow.nodes.value[0].position.x).toBe(100);
+  });
+  (0, _vitest.it)("should clear redo stack when new snapshot is pushed after undo", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 50;
+    plugin.saveSnapshot("step1");
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("step2");
+    plugin.undo();
+    (0, _vitest.expect)(flow.nodes.value[0].position.x).toBe(50);
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(true);
+    flow.nodes.value[0].position.x = 200;
+    plugin.saveSnapshot("step3");
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(false);
+  });
+  (0, _vitest.it)("should respect maxHistory limit", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)({
+      maxHistory: 3
+    });
+    plugin.install(flow);
+    for (let i = 1; i <= 5; i++) {
+      flow.nodes.value[0].position.x = i * 10;
+      plugin.saveSnapshot(`step${i}`);
+    }
+    (0, _vitest.expect)(plugin.getHistory().length).toBe(3);
+  });
+  (0, _vitest.it)("should clear history", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("move");
+    plugin.clearHistory();
+    (0, _vitest.expect)(plugin.getHistory().length).toBe(0);
+    (0, _vitest.expect)(plugin.canUndo.value).toBe(false);
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(false);
+  });
+  (0, _vitest.it)("should call onHistoryChange callback", () => {
+    const onHistoryChange = _vitest.vi.fn();
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)({
+      onHistoryChange
+    });
+    plugin.install(flow);
+    (0, _vitest.expect)(onHistoryChange).toHaveBeenCalled();
+  });
+  (0, _vitest.it)("should jump to a specific step", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("step1");
+    flow.nodes.value[0].position.x = 200;
+    plugin.saveSnapshot("step2");
+    plugin.jumpToStep(0);
+    (0, _vitest.expect)(flow.nodes.value[0].position.x).toBe(0);
+  });
+  (0, _vitest.it)("should not undo below 0 or redo beyond end", () => {
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)();
+    plugin.install(flow);
+    (0, _vitest.expect)(plugin.canUndo.value).toBe(false);
+    plugin.undo();
+    (0, _vitest.expect)(plugin.canRedo.value).toBe(false);
+    plugin.redo();
+  });
+  (0, _vitest.it)("should destroy and cleanup", () => {
+    const removeEventListener = _vitest.vi.spyOn(window, "removeEventListener");
+    const flow = createMockFlow();
+    const plugin = (0, _history.createHistoryPlugin)({
+      enableKeyboard: true
+    });
+    plugin.install(flow);
+    plugin.destroy?.();
+    (0, _vitest.expect)(removeEventListener).toHaveBeenCalledWith("keydown", _vitest.expect.any(Function));
+  });
+});

package/dist/__tests__/history-plugin.test.d.ts

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