@yh-ui/flow 0.1.21

package/dist/__tests__/plugin.test.cjs

@@ -0,0 +1,151 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _plugin = require("../plugins/plugin.cjs");
+function createMockFlowInstance() {
+  const nodes = (0, _vue.ref)([]);
+  const edges = (0, _vue.ref)([]);
+  const viewport = (0, _vue.ref)({
+    x: 0,
+    y: 0,
+    zoom: 1
+  });
+  const draggingNodeId = (0, _vue.ref)(null);
+  return {
+    nodes,
+    edges,
+    viewport,
+    draggingNodeId,
+    addNode: _vitest.vi.fn(node => {
+      nodes.value = [...nodes.value, node];
+    }),
+    removeNode: _vitest.vi.fn(),
+    updateNode: _vitest.vi.fn(),
+    getNode: _vitest.vi.fn(id => nodes.value.find(n => n.id === id)),
+    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: _vitest.vi.fn(() => nodes.value),
+    getEdges: _vitest.vi.fn(() => edges.value),
+    getViewport: _vitest.vi.fn(() => viewport.value),
+    screenToCanvas: _vitest.vi.fn((x, y) => ({
+      x,
+      y
+    })),
+    canvasToScreen: _vitest.vi.fn((x, y) => ({
+      x,
+      y
+    })),
+    on: _vitest.vi.fn(),
+    off: _vitest.vi.fn(),
+    emit: _vitest.vi.fn(),
+    isValidConnection: _vitest.vi.fn(() => true),
+    $el: void 0,
+    usePlugin: _vitest.vi.fn(),
+    removePlugin: _vitest.vi.fn()
+  };
+}
+(0, _vitest.describe)("flow/plugins/plugin", () => {
+  (0, _vitest.it)("PluginManager should register and unregister plugin", () => {
+    const flow = createMockFlowInstance();
+    const pm = new _plugin.PluginManager();
+    pm.init(flow);
+    const install = _vitest.vi.fn();
+    const plugin = {
+      id: "test-plugin",
+      name: "Test",
+      install
+    };
+    pm.register(plugin);
+    (0, _vitest.expect)(install).toHaveBeenCalledWith(flow, void 0);
+    (0, _vitest.expect)(pm.hasPlugin("test-plugin")).toBe(true);
+    (0, _vitest.expect)(pm.getPlugin("test-plugin")).toBe(plugin);
+    pm.unregister("test-plugin");
+    (0, _vitest.expect)(pm.hasPlugin("test-plugin")).toBe(false);
+    (0, _vitest.expect)(pm.getPlugin("test-plugin")).toBeUndefined();
+  });
+  (0, _vitest.it)("PluginManager should call destroy on unregister", () => {
+    const flow = createMockFlowInstance();
+    const pm = new _plugin.PluginManager();
+    pm.init(flow);
+    const destroy = _vitest.vi.fn();
+    pm.register({
+      id: "d",
+      name: "D",
+      install: _vitest.vi.fn(),
+      destroy
+    });
+    pm.unregister("d");
+    (0, _vitest.expect)(destroy).toHaveBeenCalledTimes(1);
+  });
+  (0, _vitest.it)("PluginManager should not register same id twice", () => {
+    const flow = createMockFlowInstance();
+    const pm = new _plugin.PluginManager();
+    pm.init(flow);
+    const install = _vitest.vi.fn();
+    const plugin = {
+      id: "dup",
+      name: "Dup",
+      install
+    };
+    pm.register(plugin);
+    pm.register(plugin);
+    (0, _vitest.expect)(install).toHaveBeenCalledTimes(1);
+  });
+  (0, _vitest.it)("createPlugin should produce plugin with install", () => {
+    const flow = createMockFlowInstance();
+    const installFn = _vitest.vi.fn();
+    const plugin = (0, _plugin.createPlugin)({
+      id: "factory",
+      name: "Factory"
+    }, installFn);
+    (0, _vitest.expect)(plugin.id).toBe("factory");
+    (0, _vitest.expect)(plugin.name).toBe("Factory");
+    plugin.install(flow);
+    (0, _vitest.expect)(installFn).toHaveBeenCalledWith(flow, {
+      id: "factory",
+      name: "Factory"
+    });
+  });
+  (0, _vitest.it)("createPlugin with enabled false should not call install", () => {
+    const flow = createMockFlowInstance();
+    const installFn = _vitest.vi.fn();
+    const plugin = (0, _plugin.createPlugin)({
+      id: "disabled",
+      name: "Disabled",
+      enabled: false
+    }, installFn);
+    plugin.install(flow);
+    (0, _vitest.expect)(installFn).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("destroyAll should clear all and call destroy", () => {
+    const flow = createMockFlowInstance();
+    const pm = new _plugin.PluginManager();
+    pm.init(flow);
+    const destroy = _vitest.vi.fn();
+    pm.register({
+      id: "a",
+      name: "A",
+      install: _vitest.vi.fn(),
+      destroy
+    });
+    pm.register({
+      id: "b",
+      name: "B",
+      install: _vitest.vi.fn()
+    });
+    pm.destroyAll();
+    (0, _vitest.expect)(destroy).toHaveBeenCalledTimes(1);
+    (0, _vitest.expect)(pm.getPlugins()).toHaveLength(0);
+  });
+});

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

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

package/dist/__tests__/plugin.test.mjs

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { PluginManager, createPlugin } from "../plugins/plugin.mjs";
+function createMockFlowInstance() {
+  const nodes = ref([]);
+  const edges = ref([]);
+  const viewport = ref({ x: 0, y: 0, zoom: 1 });
+  const draggingNodeId = ref(null);
+  return {
+    nodes,
+    edges,
+    viewport,
+    draggingNodeId,
+    addNode: vi.fn((node) => {
+      nodes.value = [...nodes.value, node];
+    }),
+    removeNode: vi.fn(),
+    updateNode: vi.fn(),
+    getNode: vi.fn((id) => nodes.value.find((n) => n.id === id)),
+    addEdge: vi.fn(),
+    removeEdge: vi.fn(),
+    updateEdge: vi.fn(),
+    getEdge: vi.fn(),
+    setViewport: vi.fn(),
+    fitView: vi.fn(),
+    zoomIn: vi.fn(),
+    zoomOut: vi.fn(),
+    centerView: vi.fn(),
+    selectNode: vi.fn(),
+    selectEdge: vi.fn(),
+    clearSelection: vi.fn(),
+    getNodes: vi.fn(() => nodes.value),
+    getEdges: vi.fn(() => edges.value),
+    getViewport: vi.fn(() => viewport.value),
+    screenToCanvas: vi.fn((x, y) => ({ x, y })),
+    canvasToScreen: vi.fn((x, y) => ({ x, y })),
+    on: vi.fn(),
+    off: vi.fn(),
+    emit: vi.fn(),
+    isValidConnection: vi.fn(() => true),
+    $el: void 0,
+    usePlugin: vi.fn(),
+    removePlugin: vi.fn()
+  };
+}
+describe("flow/plugins/plugin", () => {
+  it("PluginManager should register and unregister plugin", () => {
+    const flow = createMockFlowInstance();
+    const pm = new PluginManager();
+    pm.init(flow);
+    const install = vi.fn();
+    const plugin = {
+      id: "test-plugin",
+      name: "Test",
+      install
+    };
+    pm.register(plugin);
+    expect(install).toHaveBeenCalledWith(flow, void 0);
+    expect(pm.hasPlugin("test-plugin")).toBe(true);
+    expect(pm.getPlugin("test-plugin")).toBe(plugin);
+    pm.unregister("test-plugin");
+    expect(pm.hasPlugin("test-plugin")).toBe(false);
+    expect(pm.getPlugin("test-plugin")).toBeUndefined();
+  });
+  it("PluginManager should call destroy on unregister", () => {
+    const flow = createMockFlowInstance();
+    const pm = new PluginManager();
+    pm.init(flow);
+    const destroy = vi.fn();
+    pm.register({
+      id: "d",
+      name: "D",
+      install: vi.fn(),
+      destroy
+    });
+    pm.unregister("d");
+    expect(destroy).toHaveBeenCalledTimes(1);
+  });
+  it("PluginManager should not register same id twice", () => {
+    const flow = createMockFlowInstance();
+    const pm = new PluginManager();
+    pm.init(flow);
+    const install = vi.fn();
+    const plugin = { id: "dup", name: "Dup", install };
+    pm.register(plugin);
+    pm.register(plugin);
+    expect(install).toHaveBeenCalledTimes(1);
+  });
+  it("createPlugin should produce plugin with install", () => {
+    const flow = createMockFlowInstance();
+    const installFn = vi.fn();
+    const plugin = createPlugin({ id: "factory", name: "Factory" }, installFn);
+    expect(plugin.id).toBe("factory");
+    expect(plugin.name).toBe("Factory");
+    plugin.install(flow);
+    expect(installFn).toHaveBeenCalledWith(flow, { id: "factory", name: "Factory" });
+  });
+  it("createPlugin with enabled false should not call install", () => {
+    const flow = createMockFlowInstance();
+    const installFn = vi.fn();
+    const plugin = createPlugin({ id: "disabled", name: "Disabled", enabled: false }, installFn);
+    plugin.install(flow);
+    expect(installFn).not.toHaveBeenCalled();
+  });
+  it("destroyAll should clear all and call destroy", () => {
+    const flow = createMockFlowInstance();
+    const pm = new PluginManager();
+    pm.init(flow);
+    const destroy = vi.fn();
+    pm.register({ id: "a", name: "A", install: vi.fn(), destroy });
+    pm.register({ id: "b", name: "B", install: vi.fn() });
+    pm.destroyAll();
+    expect(destroy).toHaveBeenCalledTimes(1);
+    expect(pm.getPlugins()).toHaveLength(0);
+  });
+});

package/dist/__tests__/transform.test.cjs

@@ -0,0 +1,58 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _transform = require("../utils/transform.cjs");
+(0, _vitest.describe)("flow/utils/transform", () => {
+  (0, _vitest.it)("screenToCanvas and canvasToScreen should be inverse (basic)", () => {
+    const t = {
+      x: 100,
+      y: 50,
+      zoom: 2
+    };
+    const screen = {
+      x: 300,
+      y: 250
+    };
+    const canvas = (0, _transform.screenToCanvas)(screen.x, screen.y, t);
+    const back = (0, _transform.canvasToScreen)(canvas.x, canvas.y, t);
+    (0, _vitest.expect)(back.x).toBe(screen.x);
+    (0, _vitest.expect)(back.y).toBe(screen.y);
+  });
+  (0, _vitest.it)("projectNodePosition should transform between viewports", () => {
+    const from = {
+      x: 10,
+      y: 20,
+      zoom: 2
+    };
+    const to = {
+      x: -5,
+      y: 15,
+      zoom: 1
+    };
+    const p = {
+      x: 110,
+      y: 220
+    };
+    const projected = (0, _transform.projectNodePosition)(p, from, to);
+    const canvas = (0, _transform.screenToCanvas)(p.x, p.y, from);
+    const expected = (0, _transform.canvasToScreen)(canvas.x, canvas.y, to);
+    (0, _vitest.expect)(projected).toEqual(expected);
+  });
+  (0, _vitest.it)("snapToGrid should round to nearest grid", () => {
+    (0, _vitest.expect)((0, _transform.snapToGrid)(0, 10)).toBe(0);
+    (0, _vitest.expect)((0, _transform.snapToGrid)(4, 10)).toBe(0);
+    (0, _vitest.expect)((0, _transform.snapToGrid)(5, 10)).toBe(10);
+    (0, _vitest.expect)((0, _transform.snapToGrid)(14, 10)).toBe(10);
+    (0, _vitest.expect)((0, _transform.snapToGrid)(15, 10)).toBe(20);
+  });
+  (0, _vitest.it)("snapPositionToGrid should snap x/y independently", () => {
+    const p = (0, _transform.snapPositionToGrid)({
+      x: 17,
+      y: 23
+    }, [10, 5]);
+    (0, _vitest.expect)(p).toEqual({
+      x: 20,
+      y: 25
+    });
+  });
+});

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

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

package/dist/__tests__/transform.test.mjs

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import {
+  canvasToScreen,
+  screenToCanvas,
+  projectNodePosition,
+  snapToGrid,
+  snapPositionToGrid
+} from "../utils/transform.mjs";
+describe("flow/utils/transform", () => {
+  it("screenToCanvas and canvasToScreen should be inverse (basic)", () => {
+    const t = { x: 100, y: 50, zoom: 2 };
+    const screen = { x: 300, y: 250 };
+    const canvas = screenToCanvas(screen.x, screen.y, t);
+    const back = canvasToScreen(canvas.x, canvas.y, t);
+    expect(back.x).toBe(screen.x);
+    expect(back.y).toBe(screen.y);
+  });
+  it("projectNodePosition should transform between viewports", () => {
+    const from = { x: 10, y: 20, zoom: 2 };
+    const to = { x: -5, y: 15, zoom: 1 };
+    const p = { x: 110, y: 220 };
+    const projected = projectNodePosition(p, from, to);
+    const canvas = screenToCanvas(p.x, p.y, from);
+    const expected = canvasToScreen(canvas.x, canvas.y, to);
+    expect(projected).toEqual(expected);
+  });
+  it("snapToGrid should round to nearest grid", () => {
+    expect(snapToGrid(0, 10)).toBe(0);
+    expect(snapToGrid(4, 10)).toBe(0);
+    expect(snapToGrid(5, 10)).toBe(10);
+    expect(snapToGrid(14, 10)).toBe(10);
+    expect(snapToGrid(15, 10)).toBe(20);
+  });
+  it("snapPositionToGrid should snap x/y independently", () => {
+    const p = snapPositionToGrid({ x: 17, y: 23 }, [10, 5]);
+    expect(p).toEqual({ x: 20, y: 25 });
+  });
+});

package/dist/__tests__/useAlignment.test.cjs

@@ -0,0 +1,91 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useAlignment = require("../core/useAlignment.cjs");
+const node = (id, x, y, w = 200, h = 50) => ({
+  id,
+  type: "default",
+  position: {
+    x,
+    y
+  },
+  data: {},
+  width: w,
+  height: h
+});
+(0, _vitest.describe)("flow/core/useAlignment", () => {
+  (0, _vitest.it)("should return same position when no other nodes", () => {
+    const nodes = (0, _vue.ref)([node("1", 100, 50)]);
+    const a = (0, _useAlignment.useAlignment)({
+      nodes,
+      snapThreshold: 10
+    });
+    const result = a.getAlignmentSnap("1", {
+      x: 100,
+      y: 50
+    });
+    (0, _vitest.expect)(result.x).toBe(100);
+    (0, _vitest.expect)(result.y).toBe(50);
+    (0, _vitest.expect)(result.snappedX).toBe(false);
+    (0, _vitest.expect)(result.snappedY).toBe(false);
+  });
+  (0, _vitest.it)("should snap Y when dragging node center aligns with other center", () => {
+    const nodes = (0, _vue.ref)([node("1", 0, 0), node("2", 300, 100)]);
+    const a = (0, _useAlignment.useAlignment)({
+      nodes,
+      snapThreshold: 10
+    });
+    const pos = {
+      x: 300,
+      y: 100
+    };
+    const result = a.getAlignmentSnap("1", pos);
+    (0, _vitest.expect)(result.snappedY).toBe(true);
+    (0, _vitest.expect)(result.y).toBe(100);
+  });
+  (0, _vitest.it)("should snap X when left edges align", () => {
+    const nodes = (0, _vue.ref)([node("1", 0, 0), node("2", 100, 200)]);
+    const a = (0, _useAlignment.useAlignment)({
+      nodes,
+      snapThreshold: 15
+    });
+    const pos = {
+      x: 98,
+      y: 200
+    };
+    const result = a.getAlignmentSnap("1", pos);
+    (0, _vitest.expect)(result.snappedX).toBe(true);
+    (0, _vitest.expect)(result.x).toBe(100);
+  });
+  (0, _vitest.it)("snapToAlignment should return only x,y", () => {
+    const nodes = (0, _vue.ref)([node("1", 0, 0), node("2", 100, 100)]);
+    const a = (0, _useAlignment.useAlignment)({
+      nodes,
+      snapThreshold: 20
+    });
+    const out = a.snapToAlignment("1", {
+      x: 105,
+      y: 105
+    });
+    (0, _vitest.expect)(out).toHaveProperty("x");
+    (0, _vitest.expect)(out).toHaveProperty("y");
+    (0, _vitest.expect)(Object.keys(out)).toHaveLength(2);
+  });
+  (0, _vitest.it)("should return position when nodeId not found", () => {
+    const nodes = (0, _vue.ref)([node("1", 0, 0)]);
+    const a = (0, _useAlignment.useAlignment)({
+      nodes
+    });
+    const result = a.getAlignmentSnap("missing", {
+      x: 50,
+      y: 50
+    });
+    (0, _vitest.expect)(result).toEqual({
+      x: 50,
+      y: 50,
+      snappedX: false,
+      snappedY: false
+    });
+  });
+});

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

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

package/dist/__tests__/useAlignment.test.mjs

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { ref } from "vue";
+import { useAlignment } from "../core/useAlignment.mjs";
+const node = (id, x, y, w = 200, h = 50) => ({
+  id,
+  type: "default",
+  position: { x, y },
+  data: {},
+  width: w,
+  height: h
+});
+describe("flow/core/useAlignment", () => {
+  it("should return same position when no other nodes", () => {
+    const nodes = ref([node("1", 100, 50)]);
+    const a = useAlignment({ nodes, snapThreshold: 10 });
+    const result = a.getAlignmentSnap("1", { x: 100, y: 50 });
+    expect(result.x).toBe(100);
+    expect(result.y).toBe(50);
+    expect(result.snappedX).toBe(false);
+    expect(result.snappedY).toBe(false);
+  });
+  it("should snap Y when dragging node center aligns with other center", () => {
+    const nodes = ref([node("1", 0, 0), node("2", 300, 100)]);
+    const a = useAlignment({ nodes, snapThreshold: 10 });
+    const pos = { x: 300, y: 100 };
+    const result = a.getAlignmentSnap("1", pos);
+    expect(result.snappedY).toBe(true);
+    expect(result.y).toBe(100);
+  });
+  it("should snap X when left edges align", () => {
+    const nodes = ref([node("1", 0, 0), node("2", 100, 200)]);
+    const a = useAlignment({ nodes, snapThreshold: 15 });
+    const pos = { x: 98, y: 200 };
+    const result = a.getAlignmentSnap("1", pos);
+    expect(result.snappedX).toBe(true);
+    expect(result.x).toBe(100);
+  });
+  it("snapToAlignment should return only x,y", () => {
+    const nodes = ref([node("1", 0, 0), node("2", 100, 100)]);
+    const a = useAlignment({ nodes, snapThreshold: 20 });
+    const out = a.snapToAlignment("1", { x: 105, y: 105 });
+    expect(out).toHaveProperty("x");
+    expect(out).toHaveProperty("y");
+    expect(Object.keys(out)).toHaveLength(2);
+  });
+  it("should return position when nodeId not found", () => {
+    const nodes = ref([node("1", 0, 0)]);
+    const a = useAlignment({ nodes });
+    const result = a.getAlignmentSnap("missing", { x: 50, y: 50 });
+    expect(result).toEqual({ x: 50, y: 50, snappedX: false, snappedY: false });
+  });
+});

package/dist/__tests__/useEdges.test.cjs

@@ -0,0 +1,117 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useEdges = require("../core/useEdges.cjs");
+const node = id => ({
+  id,
+  type: "default",
+  position: {
+    x: 0,
+    y: 0
+  },
+  data: {}
+});
+const edge = (id, source, target) => ({
+  id,
+  source,
+  target,
+  type: "bezier"
+});
+(0, _vitest.describe)("flow/core/useEdges", () => {
+  (0, _vitest.it)("should add and remove edge", () => {
+    const edges = (0, _vue.ref)([]);
+    const nodes = (0, _vue.ref)([node("1"), node("2")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    e.addEdge(edge("e1", "1", "2"));
+    (0, _vitest.expect)(edges.value).toHaveLength(1);
+    (0, _vitest.expect)(e.getEdge("e1")).toBeDefined();
+    e.removeEdge("e1");
+    (0, _vitest.expect)(edges.value).toHaveLength(0);
+  });
+  (0, _vitest.it)("should not add duplicate connection", () => {
+    const edges = (0, _vue.ref)([edge("e1", "1", "2")]);
+    const nodes = (0, _vue.ref)([node("1"), node("2")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    e.addEdge(edge("e2", "1", "2"));
+    (0, _vitest.expect)(edges.value).toHaveLength(1);
+  });
+  (0, _vitest.it)("should respect isValidConnection", () => {
+    const edges = (0, _vue.ref)([]);
+    const nodes = (0, _vue.ref)([node("1"), node("2"), node("3")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes,
+      isValidConnection: c => c.target !== "2"
+    });
+    e.addEdge(edge("e1", "1", "2"));
+    (0, _vitest.expect)(edges.value).toHaveLength(0);
+    e.addEdge(edge("e2", "1", "3"));
+    (0, _vitest.expect)(edges.value).toHaveLength(1);
+  });
+  (0, _vitest.it)("should update edge", () => {
+    const edges = (0, _vue.ref)([edge("e1", "1", "2")]);
+    const nodes = (0, _vue.ref)([node("1"), node("2")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    e.updateEdge("e1", {
+      label: "updated",
+      type: "straight"
+    });
+    (0, _vitest.expect)(edges.value[0].label).toBe("updated");
+    (0, _vitest.expect)(edges.value[0].type).toBe("straight");
+  });
+  (0, _vitest.it)("should select edge single and multi", () => {
+    const edges = (0, _vue.ref)([{
+      ...edge("e1", "1", "2"),
+      selected: true
+    }, {
+      ...edge("e2", "2", "3"),
+      selected: false
+    }]);
+    const nodes = (0, _vue.ref)([node("1"), node("2"), node("3")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    e.selectEdge("e2", true, false);
+    (0, _vitest.expect)(edges.value.find(x => x.id === "e1")?.selected).toBe(false);
+    (0, _vitest.expect)(edges.value.find(x => x.id === "e2")?.selected).toBe(true);
+    e.selectEdge("e1", true, true);
+    (0, _vitest.expect)(edges.value.filter(x => x.selected)).toHaveLength(2);
+  });
+  (0, _vitest.it)("should getEdgesForNode and getConnectedEdges", () => {
+    const edges = (0, _vue.ref)([edge("e1", "1", "2"), edge("e2", "2", "3"), edge("e3", "1", "3")]);
+    const nodes = (0, _vue.ref)([node("1"), node("2"), node("3")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    (0, _vitest.expect)(e.getEdgesForNode("1")).toHaveLength(2);
+    (0, _vitest.expect)(e.getConnectedEdges("2")).toHaveLength(2);
+  });
+  (0, _vitest.it)("should clearSelection and setEdges", () => {
+    const edges = (0, _vue.ref)([{
+      ...edge("e1", "1", "2"),
+      selected: true
+    }]);
+    const nodes = (0, _vue.ref)([node("1"), node("2")]);
+    const e = (0, _useEdges.useEdges)({
+      edges,
+      nodes
+    });
+    e.clearSelection();
+    (0, _vitest.expect)(edges.value[0].selected).toBeFalsy();
+    e.setEdges([edge("e2", "1", "2")]);
+    (0, _vitest.expect)(edges.value).toHaveLength(1);
+    (0, _vitest.expect)(edges.value[0].id).toBe("e2");
+  });
+});

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

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