@yh-ui/flow 1.0.25 → 1.0.30

package/dist/__tests__/useNodeDistribution.test.mjs

@@ -1,297 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ref } from "vue";
-import { useNodeDistribution } from "../core/useNodeDistribution.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(),
-    removeNode: vi.fn(),
-    updateNode: vi.fn(),
-    getNode: vi.fn(),
-    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(),
-    canvasToScreen: vi.fn(),
-    on: vi.fn(),
-    off: vi.fn(),
-    emit: vi.fn(),
-    isValidConnection: vi.fn(() => true),
-    $el: void 0,
-    usePlugin: vi.fn(),
-    removePlugin: vi.fn()
-  };
-}
-describe("flow/core/useNodeDistribution", () => {
-  it("should return all distribution functions", () => {
-    const flow = createMockFlowInstance();
-    const {
-      distributeHorizontally,
-      distributeVertically,
-      alignNodesHorizontal,
-      alignNodesVertical
-    } = useNodeDistribution({ nodes: flow.nodes });
-    expect(typeof distributeHorizontally).toBe("function");
-    expect(typeof distributeVertically).toBe("function");
-    expect(typeof alignNodesHorizontal).toBe("function");
-    expect(typeof alignNodesVertical).toBe("function");
-  });
-  describe("distributeHorizontally", () => {
-    it("should not distribute when fewer than 3 nodes", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {} },
-        { id: "2", type: "default", position: { x: 100, y: 0 }, data: {} }
-      ];
-      const { distributeHorizontally } = useNodeDistribution({ nodes: flow.nodes });
-      distributeHorizontally(["1", "2"]);
-      expect(flow.nodes.value[0].position.x).toBe(0);
-      expect(flow.nodes.value[1].position.x).toBe(100);
-    });
-    it("should distribute 3 nodes horizontally with custom gap", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "2", type: "default", position: { x: 50, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "3", type: "default", position: { x: 100, y: 0 }, data: {}, width: 50, height: 50 }
-      ];
-      const { distributeHorizontally } = useNodeDistribution({ nodes: flow.nodes });
-      distributeHorizontally(["1", "2", "3"], 100);
-      const positions = flow.nodes.value.map((n) => n.position.x);
-      expect(positions[0]).toBe(0);
-      expect(positions[1]).toBe(150);
-      expect(positions[2]).toBe(300);
-    });
-    it("should distribute nodes that are too close", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "2", type: "default", position: { x: 10, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "3", type: "default", position: { x: 20, y: 0 }, data: {}, width: 50, height: 50 }
-      ];
-      const { distributeHorizontally } = useNodeDistribution({ nodes: flow.nodes });
-      distributeHorizontally(["1", "2", "3"], 50);
-      const positions = flow.nodes.value.map((n) => n.position.x);
-      expect(positions[0]).toBe(0);
-      expect(positions[1]).toBeGreaterThan(positions[0]);
-      expect(positions[2]).toBeGreaterThan(positions[1]);
-    });
-    it("should use selected nodes when no nodeIds provided", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        {
-          id: "1",
-          type: "default",
-          position: { x: 0, y: 0 },
-          data: {},
-          width: 50,
-          height: 50,
-          selected: true
-        },
-        {
-          id: "2",
-          type: "default",
-          position: { x: 50, y: 0 },
-          data: {},
-          width: 50,
-          height: 50,
-          selected: true
-        },
-        {
-          id: "3",
-          type: "default",
-          position: { x: 100, y: 0 },
-          data: {},
-          width: 50,
-          height: 50,
-          selected: true
-        }
-      ];
-      const { distributeHorizontally } = useNodeDistribution({ nodes: flow.nodes });
-      distributeHorizontally(void 0, 50);
-      const positions = flow.nodes.value.map((n) => n.position.x);
-      expect(positions[0]).toBe(0);
-      expect(positions[1]).toBe(100);
-      expect(positions[2]).toBe(200);
-    });
-  });
-  describe("distributeVertically", () => {
-    it("should not distribute when fewer than 3 nodes", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {} },
-        { id: "2", type: "default", position: { x: 0, y: 100 }, data: {} }
-      ];
-      const { distributeVertically } = useNodeDistribution({ nodes: flow.nodes });
-      distributeVertically(["1", "2"]);
-      expect(flow.nodes.value[0].position.y).toBe(0);
-      expect(flow.nodes.value[1].position.y).toBe(100);
-    });
-    it("should distribute 3 nodes vertically", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "2", type: "default", position: { x: 0, y: 50 }, data: {}, width: 50, height: 50 },
-        { id: "3", type: "default", position: { x: 0, y: 100 }, data: {}, width: 50, height: 50 }
-      ];
-      const { distributeVertically } = useNodeDistribution({ nodes: flow.nodes });
-      distributeVertically(["1", "2", "3"], 100);
-      const positions = flow.nodes.value.map((n) => n.position.y);
-      expect(positions[0]).toBe(0);
-      expect(positions[1]).toBe(150);
-      expect(positions[2]).toBe(300);
-    });
-    it("should distribute nodes that are too close vertically", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 50, height: 50 },
-        { id: "2", type: "default", position: { x: 0, y: 10 }, data: {}, width: 50, height: 50 },
-        { id: "3", type: "default", position: { x: 0, y: 20 }, data: {}, width: 50, height: 50 }
-      ];
-      const { distributeVertically } = useNodeDistribution({ nodes: flow.nodes });
-      distributeVertically(["1", "2", "3"], 50);
-      const positions = flow.nodes.value.map((n) => n.position.y);
-      expect(positions[0]).toBe(0);
-      expect(positions[1]).toBeGreaterThan(positions[0]);
-      expect(positions[2]).toBeGreaterThan(positions[1]);
-    });
-  });
-  describe("alignNodesHorizontal", () => {
-    it("should not align when fewer than 2 nodes", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesHorizontal } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesHorizontal(["1"]);
-      expect(flow.nodes.value[0].position.x).toBe(0);
-    });
-    it("should align to left edge", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 50, y: 50 }, data: {}, width: 100, height: 50 },
-        { id: "3", type: "default", position: { x: 100, y: 100 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesHorizontal } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesHorizontal(["1", "2", "3"], "left");
-      expect(flow.nodes.value[0].position.x).toBe(0);
-      expect(flow.nodes.value[1].position.x).toBe(0);
-      expect(flow.nodes.value[2].position.x).toBe(0);
-    });
-    it("should align to right edge", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 50, y: 50 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesHorizontal } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesHorizontal(["1", "2"], "right");
-      expect(flow.nodes.value[0].position.x).toBe(50);
-      expect(flow.nodes.value[1].position.x).toBe(50);
-    });
-    it("should align to center", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 50, y: 50 }, data: {}, width: 200, height: 50 }
-      ];
-      const { alignNodesHorizontal } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesHorizontal(["1", "2"], "center");
-      expect(flow.nodes.value[0].position.x).toBe(50);
-      expect(flow.nodes.value[1].position.x).toBe(0);
-    });
-    it("should use selected nodes when no nodeIds provided", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        {
-          id: "1",
-          type: "default",
-          position: { x: 0, y: 0 },
-          data: {},
-          width: 100,
-          height: 50,
-          selected: true
-        },
-        {
-          id: "2",
-          type: "default",
-          position: { x: 50, y: 0 },
-          data: {},
-          width: 100,
-          height: 50,
-          selected: true
-        }
-      ];
-      const { alignNodesHorizontal } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesHorizontal(void 0, "left");
-      expect(flow.nodes.value[0].position.x).toBe(0);
-      expect(flow.nodes.value[1].position.x).toBe(0);
-    });
-  });
-  describe("alignNodesVertical", () => {
-    it("should not align when fewer than 2 nodes", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesVertical } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesVertical(["1"]);
-      expect(flow.nodes.value[0].position.y).toBe(0);
-    });
-    it("should align to top edge", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 0, y: 50 }, data: {}, width: 100, height: 50 },
-        { id: "3", type: "default", position: { x: 0, y: 100 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesVertical } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesVertical(["1", "2", "3"], "top");
-      expect(flow.nodes.value[0].position.y).toBe(0);
-      expect(flow.nodes.value[1].position.y).toBe(0);
-      expect(flow.nodes.value[2].position.y).toBe(0);
-    });
-    it("should align to bottom edge", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 0, y: 50 }, data: {}, width: 100, height: 50 }
-      ];
-      const { alignNodesVertical } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesVertical(["1", "2"], "bottom");
-      expect(flow.nodes.value[0].position.y).toBe(50);
-      expect(flow.nodes.value[1].position.y).toBe(50);
-    });
-    it("should align to middle", () => {
-      const flow = createMockFlowInstance();
-      flow.nodes.value = [
-        { id: "1", type: "default", position: { x: 0, y: 0 }, data: {}, width: 100, height: 50 },
-        { id: "2", type: "default", position: { x: 0, y: 50 }, data: {}, width: 100, height: 100 }
-      ];
-      const { alignNodesVertical } = useNodeDistribution({ nodes: flow.nodes });
-      alignNodesVertical(["1", "2"], "middle");
-      expect(flow.nodes.value[0].position.y).toBe(37.5);
-      expect(flow.nodes.value[1].position.y).toBe(12.5);
-    });
-  });
-});

package/dist/__tests__/useNodes.test.cjs

@@ -1,150 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _vue = require("vue");
-var _useNodes = require("../core/useNodes.cjs");
-const defaultNode = (id, x = 0, y = 0) => ({
-  id,
-  type: "default",
-  position: {
-    x,
-    y
-  },
-  data: {
-    label: id
-  },
-  width: 160,
-  height: 50
-});
-(0, _vitest.describe)("flow/core/useNodes", () => {
-  (0, _vitest.it)("should add and remove node", () => {
-    const nodes = (0, _vue.ref)([]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.addNode(defaultNode("1"));
-    (0, _vitest.expect)(nodes.value).toHaveLength(1);
-    (0, _vitest.expect)(n.getNode("1")).toBeDefined();
-    n.removeNode("1");
-    (0, _vitest.expect)(nodes.value).toHaveLength(0);
-    (0, _vitest.expect)(n.getNode("1")).toBeUndefined();
-  });
-  (0, _vitest.it)("should update node and position", () => {
-    const nodes = (0, _vue.ref)([defaultNode("1", 10, 20)]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.updateNode("1", {
-      data: {
-        label: "updated"
-      }
-    });
-    (0, _vitest.expect)(nodes.value[0].data?.label).toBe("updated");
-    n.updateNodePosition("1", {
-      x: 100,
-      y: 200
-    });
-    (0, _vitest.expect)(nodes.value[0].position).toEqual({
-      x: 100,
-      y: 200
-    });
-  });
-  (0, _vitest.it)("should snap position to grid when snapToGrid true", () => {
-    const nodes = (0, _vue.ref)([defaultNode("1", 0, 0)]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes,
-      snapToGrid: true,
-      snapGrid: [20, 20]
-    });
-    n.updateNodePosition("1", {
-      x: 17,
-      y: 23
-    });
-    (0, _vitest.expect)(nodes.value[0].position.x).toBe(20);
-    (0, _vitest.expect)(nodes.value[0].position.y).toBe(20);
-  });
-  (0, _vitest.it)("should select single node (clear others when multi false)", () => {
-    const nodes = (0, _vue.ref)([{
-      ...defaultNode("1"),
-      selected: true
-    }, {
-      ...defaultNode("2"),
-      selected: false
-    }]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.selectNode("2", true, false);
-    (0, _vitest.expect)(nodes.value.find(x => x.id === "1")?.selected).toBe(false);
-    (0, _vitest.expect)(nodes.value.find(x => x.id === "2")?.selected).toBe(true);
-  });
-  (0, _vitest.it)("should multi-select when multi true", () => {
-    const nodes = (0, _vue.ref)([{
-      ...defaultNode("1"),
-      selected: true
-    }, {
-      ...defaultNode("2"),
-      selected: false
-    }]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.selectNode("2", true, true);
-    (0, _vitest.expect)(nodes.value.find(x => x.id === "1")?.selected).toBe(true);
-    (0, _vitest.expect)(nodes.value.find(x => x.id === "2")?.selected).toBe(true);
-  });
-  (0, _vitest.it)("should selectNodes and clearSelection", () => {
-    const nodes = (0, _vue.ref)([defaultNode("1"), defaultNode("2"), defaultNode("3")]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.selectNodes(["1", "3"], true);
-    (0, _vitest.expect)(n.getSelectedNodes()).toHaveLength(2);
-    n.clearSelection();
-    (0, _vitest.expect)(n.getSelectedNodes()).toHaveLength(0);
-  });
-  (0, _vitest.it)("should setNodes and findNode", () => {
-    const nodes = (0, _vue.ref)([]);
-    const viewport = (0, _vue.ref)({
-      x: 0,
-      y: 0,
-      zoom: 1
-    });
-    const n = (0, _useNodes.useNodes)(viewport, {
-      nodes
-    });
-    n.setNodes([defaultNode("a"), defaultNode("b")]);
-    (0, _vitest.expect)(nodes.value).toHaveLength(2);
-    (0, _vitest.expect)(n.findNode("b")?.id).toBe("b");
-  });
-});

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

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

package/dist/__tests__/useNodes.test.mjs

@@ -1,80 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ref } from "vue";
-import { useNodes } from "../core/useNodes.mjs";
-const defaultNode = (id, x = 0, y = 0) => ({
-  id,
-  type: "default",
-  position: { x, y },
-  data: { label: id },
-  width: 160,
-  height: 50
-});
-describe("flow/core/useNodes", () => {
-  it("should add and remove node", () => {
-    const nodes = ref([]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.addNode(defaultNode("1"));
-    expect(nodes.value).toHaveLength(1);
-    expect(n.getNode("1")).toBeDefined();
-    n.removeNode("1");
-    expect(nodes.value).toHaveLength(0);
-    expect(n.getNode("1")).toBeUndefined();
-  });
-  it("should update node and position", () => {
-    const nodes = ref([defaultNode("1", 10, 20)]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.updateNode("1", { data: { label: "updated" } });
-    expect(nodes.value[0].data?.label).toBe("updated");
-    n.updateNodePosition("1", { x: 100, y: 200 });
-    expect(nodes.value[0].position).toEqual({ x: 100, y: 200 });
-  });
-  it("should snap position to grid when snapToGrid true", () => {
-    const nodes = ref([defaultNode("1", 0, 0)]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes, snapToGrid: true, snapGrid: [20, 20] });
-    n.updateNodePosition("1", { x: 17, y: 23 });
-    expect(nodes.value[0].position.x).toBe(20);
-    expect(nodes.value[0].position.y).toBe(20);
-  });
-  it("should select single node (clear others when multi false)", () => {
-    const nodes = ref([
-      { ...defaultNode("1"), selected: true },
-      { ...defaultNode("2"), selected: false }
-    ]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.selectNode("2", true, false);
-    expect(nodes.value.find((x) => x.id === "1")?.selected).toBe(false);
-    expect(nodes.value.find((x) => x.id === "2")?.selected).toBe(true);
-  });
-  it("should multi-select when multi true", () => {
-    const nodes = ref([
-      { ...defaultNode("1"), selected: true },
-      { ...defaultNode("2"), selected: false }
-    ]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.selectNode("2", true, true);
-    expect(nodes.value.find((x) => x.id === "1")?.selected).toBe(true);
-    expect(nodes.value.find((x) => x.id === "2")?.selected).toBe(true);
-  });
-  it("should selectNodes and clearSelection", () => {
-    const nodes = ref([defaultNode("1"), defaultNode("2"), defaultNode("3")]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.selectNodes(["1", "3"], true);
-    expect(n.getSelectedNodes()).toHaveLength(2);
-    n.clearSelection();
-    expect(n.getSelectedNodes()).toHaveLength(0);
-  });
-  it("should setNodes and findNode", () => {
-    const nodes = ref([]);
-    const viewport = ref({ x: 0, y: 0, zoom: 1 });
-    const n = useNodes(viewport, { nodes });
-    n.setNodes([defaultNode("a"), defaultNode("b")]);
-    expect(nodes.value).toHaveLength(2);
-    expect(n.findNode("b")?.id).toBe("b");
-  });
-});

package/dist/__tests__/useSelection.test.cjs

@@ -1,112 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _vue = require("vue");
-var _useSelection = require("../core/useSelection.cjs");
-const node = (id, x, y, w = 100, h = 50) => ({
-  id,
-  type: "default",
-  position: {
-    x,
-    y
-  },
-  data: {},
-  width: w,
-  height: h,
-  selected: false
-});
-const edge = (id, source, target) => ({
-  id,
-  source,
-  target,
-  type: "bezier",
-  selected: false
-});
-(0, _vitest.describe)("flow/core/useSelection", () => {
-  (0, _vitest.it)("should start and update selection rect", () => {
-    const nodes = (0, _vue.ref)([node("1", 0, 0), node("2", 200, 100)]);
-    const edges = (0, _vue.ref)([]);
-    const s = (0, _useSelection.useSelection)({
-      nodes,
-      edges
-    });
-    s.startSelection(10, 20);
-    (0, _vitest.expect)(s.isSelecting.value).toBe(true);
-    (0, _vitest.expect)(s.selectionRect.value).toEqual({
-      x: 10,
-      y: 20,
-      width: 0,
-      height: 0
-    });
-    s.updateSelection(50, 60);
-    (0, _vitest.expect)(s.selectionRect.value).toEqual({
-      x: 10,
-      y: 20,
-      width: 40,
-      height: 40
-    });
-  });
-  (0, _vitest.it)("should select nodes inside rect on updateSelection", () => {
-    const nodes = (0, _vue.ref)([node("1", 20, 20, 50, 50), node("2", 100, 100, 50, 50)]);
-    const edges = (0, _vue.ref)([]);
-    const s = (0, _useSelection.useSelection)({
-      nodes,
-      edges
-    });
-    s.startSelection(0, 0);
-    s.updateSelection(80, 80);
-    (0, _vitest.expect)(nodes.value.find(n => n.id === "1")?.selected).toBe(true);
-    (0, _vitest.expect)(nodes.value.find(n => n.id === "2")?.selected).toBe(false);
-  });
-  (0, _vitest.it)("should end selection and clear rect", () => {
-    const nodes = (0, _vue.ref)([node("1", 0, 0)]);
-    const edges = (0, _vue.ref)([]);
-    const s = (0, _useSelection.useSelection)({
-      nodes,
-      edges
-    });
-    s.startSelection(0, 0);
-    s.updateSelection(10, 10);
-    s.endSelection();
-    (0, _vitest.expect)(s.isSelecting.value).toBe(false);
-    (0, _vitest.expect)(s.selectionRect.value).toBeNull();
-  });
-  (0, _vitest.it)("should clearSelection clear nodes and edges selected", () => {
-    const nodes = (0, _vue.ref)([{
-      ...node("1", 0, 0),
-      selected: true
-    }]);
-    const edges = (0, _vue.ref)([{
-      ...edge("e1", "1", "2"),
-      selected: true
-    }]);
-    const s = (0, _useSelection.useSelection)({
-      nodes,
-      edges
-    });
-    s.clearSelection();
-    (0, _vitest.expect)(nodes.value[0].selected).toBeFalsy();
-    (0, _vitest.expect)(edges.value[0].selected).toBeFalsy();
-  });
-  (0, _vitest.it)("should call onSelectionChange on endSelection", () => {
-    const nodes = (0, _vue.ref)([node("1", 20, 20, 50, 50)]);
-    const edges = (0, _vue.ref)([]);
-    let captured = null;
-    const s = (0, _useSelection.useSelection)({
-      nodes,
-      edges,
-      onSelectionChange: (selectedNodes, selectedEdges) => {
-        captured = {
-          nodes: selectedNodes,
-          edges: selectedEdges
-        };
-      }
-    });
-    s.startSelection(0, 0);
-    s.updateSelection(80, 80);
-    s.endSelection();
-    (0, _vitest.expect)(captured).not.toBeNull();
-    (0, _vitest.expect)(Array.isArray(captured.nodes)).toBe(true);
-    (0, _vitest.expect)(Array.isArray(captured.edges)).toBe(true);
-  });
-});

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

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