@yh-ui/flow 0.1.21

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

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { createHistoryPlugin } from "../plugins/plugins/history.mjs";
+function createMockFlow() {
+  const nodes = ref([
+    { id: "1", type: "default", position: { x: 0, y: 0 }, data: { label: "A" } }
+  ]);
+  const edges = ref([]);
+  const eventHandlers = {};
+  const flow = {
+    nodes,
+    edges,
+    viewport: ref({ x: 0, y: 0, zoom: 1 }),
+    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: () => nodes.value,
+    getEdges: () => edges.value,
+    getViewport: () => ({ x: 0, y: 0, zoom: 1 }),
+    screenToCanvas: vi.fn().mockReturnValue({ x: 0, y: 0 }),
+    canvasToScreen: vi.fn().mockReturnValue({ x: 0, y: 0 }),
+    on: vi.fn((event, handler) => {
+      if (!eventHandlers[event]) eventHandlers[event] = [];
+      eventHandlers[event].push(handler);
+    }),
+    off: vi.fn(),
+    emit: vi.fn(),
+    isValidConnection: vi.fn().mockReturnValue(true),
+    $el: void 0,
+    draggingNodeId: ref(null),
+    draggingPosition: ref(null),
+    usePlugin: vi.fn(),
+    removePlugin: vi.fn()
+  };
+  return flow;
+}
+describe("createHistoryPlugin", () => {
+  it("should be created with correct metadata", () => {
+    const plugin = createHistoryPlugin();
+    expect(plugin.id).toBe("history");
+    expect(plugin.name).toBe("History");
+    expect(plugin.version).toBe("1.0.0");
+  });
+  it("should install and expose undo/redo on flow instance", () => {
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin();
+    plugin.install(flow);
+    expect(typeof flow.undo).toBe("function");
+    expect(typeof flow.redo).toBe("function");
+    expect(typeof flow.saveSnapshot).toBe("function");
+    expect(typeof flow.clearHistory).toBe("function");
+    expect(typeof flow.jumpToStep).toBe("function");
+    expect(typeof flow.getHistory).toBe("function");
+  });
+  it("should save initial snapshot on install", () => {
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin();
+    plugin.install(flow);
+    const history = plugin.getHistory();
+    expect(history.length).toBe(1);
+    expect(history[0].description).toBe("initial");
+  });
+  it("should correctly undo and redo node position changes", () => {
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("move node");
+    expect(plugin.canUndo.value).toBe(true);
+    expect(plugin.canRedo.value).toBe(false);
+    plugin.undo();
+    expect(flow.nodes.value[0].position.x).toBe(0);
+    expect(plugin.canRedo.value).toBe(true);
+    plugin.redo();
+    expect(flow.nodes.value[0].position.x).toBe(100);
+  });
+  it("should clear redo stack when new snapshot is pushed after undo", () => {
+    const flow = createMockFlow();
+    const plugin = 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();
+    expect(flow.nodes.value[0].position.x).toBe(50);
+    expect(plugin.canRedo.value).toBe(true);
+    flow.nodes.value[0].position.x = 200;
+    plugin.saveSnapshot("step3");
+    expect(plugin.canRedo.value).toBe(false);
+  });
+  it("should respect maxHistory limit", () => {
+    const flow = createMockFlow();
+    const plugin = 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}`);
+    }
+    expect(plugin.getHistory().length).toBe(3);
+  });
+  it("should clear history", () => {
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin();
+    plugin.install(flow);
+    flow.nodes.value[0].position.x = 100;
+    plugin.saveSnapshot("move");
+    plugin.clearHistory();
+    expect(plugin.getHistory().length).toBe(0);
+    expect(plugin.canUndo.value).toBe(false);
+    expect(plugin.canRedo.value).toBe(false);
+  });
+  it("should call onHistoryChange callback", () => {
+    const onHistoryChange = vi.fn();
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin({ onHistoryChange });
+    plugin.install(flow);
+    expect(onHistoryChange).toHaveBeenCalled();
+  });
+  it("should jump to a specific step", () => {
+    const flow = createMockFlow();
+    const plugin = 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);
+    expect(flow.nodes.value[0].position.x).toBe(0);
+  });
+  it("should not undo below 0 or redo beyond end", () => {
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin();
+    plugin.install(flow);
+    expect(plugin.canUndo.value).toBe(false);
+    plugin.undo();
+    expect(plugin.canRedo.value).toBe(false);
+    plugin.redo();
+  });
+  it("should destroy and cleanup", () => {
+    const removeEventListener = vi.spyOn(window, "removeEventListener");
+    const flow = createMockFlow();
+    const plugin = createHistoryPlugin({ enableKeyboard: true });
+    plugin.install(flow);
+    plugin.destroy?.();
+    expect(removeEventListener).toHaveBeenCalledWith("keydown", expect.any(Function));
+  });
+});

package/dist/__tests__/history.test.cjs

@@ -0,0 +1,81 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _useHistory = require("../core/useHistory.cjs");
+(0, _vitest.describe)("flow/core/useHistory", () => {
+  (0, _vitest.it)("should push, undo, redo", () => {
+    const nodes = (0, _vue.ref)([{
+      id: "1",
+      type: "default",
+      position: {
+        x: 0,
+        y: 0
+      },
+      data: {}
+    }]);
+    const edges = (0, _vue.ref)([]);
+    const historyEvents = [];
+    const h = (0, _useHistory.useHistory)(nodes, edges, {
+      maxHistory: 10,
+      onHistoryChange: (canUndo, canRedo) => historyEvents.push({
+        canUndo,
+        canRedo
+      })
+    });
+    h.push({
+      nodes: nodes.value,
+      edges: edges.value
+    });
+    (0, _vitest.expect)(h.canUndo.value).toBe(false);
+    (0, _vitest.expect)(h.canRedo.value).toBe(false);
+    nodes.value[0].position.x = 100;
+    h.push({
+      nodes: nodes.value,
+      edges: edges.value
+    });
+    (0, _vitest.expect)(h.canUndo.value).toBe(true);
+    (0, _vitest.expect)(h.canRedo.value).toBe(false);
+    h.undo();
+    (0, _vitest.expect)(nodes.value[0].position.x).toBe(0);
+    (0, _vitest.expect)(h.canRedo.value).toBe(true);
+    h.redo();
+    (0, _vitest.expect)(nodes.value[0].position.x).toBe(100);
+    h.clear();
+    (0, _vitest.expect)(h.canUndo.value).toBe(false);
+    (0, _vitest.expect)(h.canRedo.value).toBe(false);
+    (0, _vitest.expect)(historyEvents.length).toBeGreaterThan(0);
+  });
+  (0, _vitest.it)("should respect maxHistory", () => {
+    const nodes = (0, _vue.ref)([{
+      id: "1",
+      type: "default",
+      position: {
+        x: 0,
+        y: 0
+      },
+      data: {}
+    }]);
+    const edges = (0, _vue.ref)([]);
+    const h = (0, _useHistory.useHistory)(nodes, edges, {
+      maxHistory: 2
+    });
+    h.push({
+      nodes: nodes.value,
+      edges: edges.value
+    });
+    nodes.value[0].position.x = 1;
+    h.push({
+      nodes: nodes.value,
+      edges: edges.value
+    });
+    nodes.value[0].position.x = 2;
+    h.push({
+      nodes: nodes.value,
+      edges: edges.value
+    });
+    h.undo();
+    (0, _vitest.expect)(nodes.value[0].position.x).toBe(1);
+    (0, _vitest.expect)(h.canUndo.value).toBe(false);
+  });
+});

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

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

package/dist/__tests__/history.test.mjs

@@ -0,0 +1,43 @@
+import { describe, it, expect } from "vitest";
+import { ref } from "vue";
+import { useHistory } from "../core/useHistory.mjs";
+describe("flow/core/useHistory", () => {
+  it("should push, undo, redo", () => {
+    const nodes = ref([{ id: "1", type: "default", position: { x: 0, y: 0 }, data: {} }]);
+    const edges = ref([]);
+    const historyEvents = [];
+    const h = useHistory(nodes, edges, {
+      maxHistory: 10,
+      onHistoryChange: (canUndo, canRedo) => historyEvents.push({ canUndo, canRedo })
+    });
+    h.push({ nodes: nodes.value, edges: edges.value });
+    expect(h.canUndo.value).toBe(false);
+    expect(h.canRedo.value).toBe(false);
+    nodes.value[0].position.x = 100;
+    h.push({ nodes: nodes.value, edges: edges.value });
+    expect(h.canUndo.value).toBe(true);
+    expect(h.canRedo.value).toBe(false);
+    h.undo();
+    expect(nodes.value[0].position.x).toBe(0);
+    expect(h.canRedo.value).toBe(true);
+    h.redo();
+    expect(nodes.value[0].position.x).toBe(100);
+    h.clear();
+    expect(h.canUndo.value).toBe(false);
+    expect(h.canRedo.value).toBe(false);
+    expect(historyEvents.length).toBeGreaterThan(0);
+  });
+  it("should respect maxHistory", () => {
+    const nodes = ref([{ id: "1", type: "default", position: { x: 0, y: 0 }, data: {} }]);
+    const edges = ref([]);
+    const h = useHistory(nodes, edges, { maxHistory: 2 });
+    h.push({ nodes: nodes.value, edges: edges.value });
+    nodes.value[0].position.x = 1;
+    h.push({ nodes: nodes.value, edges: edges.value });
+    nodes.value[0].position.x = 2;
+    h.push({ nodes: nodes.value, edges: edges.value });
+    h.undo();
+    expect(nodes.value[0].position.x).toBe(1);
+    expect(h.canUndo.value).toBe(false);
+  });
+});

package/dist/__tests__/layout.test.cjs

@@ -0,0 +1,213 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _layout = require("../plugins/plugins/layout.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(),
+    removeNode: _vitest.vi.fn(),
+    updateNode: _vitest.vi.fn((id, data) => {
+      const node = nodes.value.find(n => n.id === id);
+      if (node) Object.assign(node, data);
+    }),
+    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/plugins/layout", () => {
+  (0, _vitest.describe)("LayoutOptions", () => {
+    (0, _vitest.it)("should have correct default options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)();
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.applyLayout).toBeDefined();
+    });
+    (0, _vitest.it)("should support dagre layout type", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "dagre"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+      (0, _vitest.expect)(plugin.name).toBe("Layout");
+    });
+    (0, _vitest.it)("should support elk layout type", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "elk"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+      (0, _vitest.expect)(plugin.name).toBe("Layout");
+    });
+    (0, _vitest.it)("should support force layout type", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "force"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+      (0, _vitest.expect)(plugin.name).toBe("Layout");
+    });
+    (0, _vitest.it)("should support grid layout type", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+      (0, _vitest.expect)(plugin.name).toBe("Layout");
+    });
+    (0, _vitest.it)("should accept direction option TB", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        direction: "TB"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept direction option LR", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        direction: "LR"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept node spacing option", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        nodeSpacing: 100
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept rank spacing option", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        rankSpacing: 150
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept elk options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "elk",
+        elkOptions: {
+          algorithm: "layered",
+          direction: "DOWN",
+          spacing: 50,
+          edgeRouting: "POLYLINE"
+        }
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept force options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "force",
+        forceOptions: {
+          strength: -500,
+          distance: 200,
+          iterations: 500
+        }
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should accept grid options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid",
+        gridOptions: {
+          columns: 3,
+          startX: 100,
+          startY: 100
+        }
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+  });
+  (0, _vitest.describe)("Layout execution", () => {
+    (0, _vitest.it)("should add applyLayout method to flow instance", () => {
+      const plugin = (0, _layout.createLayoutPlugin)();
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      (0, _vitest.expect)(typeof flow.applyLayout).toBe("function");
+    });
+    (0, _vitest.it)("should return function when calling applyLayout", async () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "dagre"
+      });
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [{
+        id: "1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Node 1"
+        },
+        width: 150,
+        height: 50
+      }];
+      flow.edges.value = [];
+      plugin.install(flow);
+      const result = flow.applyLayout({
+        type: "dagre"
+      });
+      (0, _vitest.expect)(result === void 0 || result instanceof Promise).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("LayoutOptions interface", () => {
+    (0, _vitest.it)("should validate LayoutOptions type field accepts dagre", () => {
+      const options = {
+        type: "dagre"
+      };
+      (0, _vitest.expect)(options.type).toBe("dagre");
+    });
+    (0, _vitest.it)("should validate LayoutOptions type field accepts elk", () => {
+      const options = {
+        type: "elk"
+      };
+      (0, _vitest.expect)(options.type).toBe("elk");
+    });
+    (0, _vitest.it)("should validate LayoutOptions type field accepts force", () => {
+      const options = {
+        type: "force"
+      };
+      (0, _vitest.expect)(options.type).toBe("force");
+    });
+    (0, _vitest.it)("should validate LayoutOptions type field accepts grid", () => {
+      const options = {
+        type: "grid"
+      };
+      (0, _vitest.expect)(options.type).toBe("grid");
+    });
+  });
+});

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

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

package/dist/__tests__/layout.test.mjs

@@ -0,0 +1,170 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { createLayoutPlugin } from "../plugins/plugins/layout.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((id, data) => {
+      const node = nodes.value.find((n) => n.id === id);
+      if (node) Object.assign(node, data);
+    }),
+    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/plugins/layout", () => {
+  describe("LayoutOptions", () => {
+    it("should have correct default options", () => {
+      const plugin = createLayoutPlugin();
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      expect(flow.applyLayout).toBeDefined();
+    });
+    it("should support dagre layout type", () => {
+      const plugin = createLayoutPlugin({ type: "dagre" });
+      expect(plugin.id).toBe("layout");
+      expect(plugin.name).toBe("Layout");
+    });
+    it("should support elk layout type", () => {
+      const plugin = createLayoutPlugin({ type: "elk" });
+      expect(plugin.id).toBe("layout");
+      expect(plugin.name).toBe("Layout");
+    });
+    it("should support force layout type", () => {
+      const plugin = createLayoutPlugin({ type: "force" });
+      expect(plugin.id).toBe("layout");
+      expect(plugin.name).toBe("Layout");
+    });
+    it("should support grid layout type", () => {
+      const plugin = createLayoutPlugin({ type: "grid" });
+      expect(plugin.id).toBe("layout");
+      expect(plugin.name).toBe("Layout");
+    });
+    it("should accept direction option TB", () => {
+      const plugin = createLayoutPlugin({ direction: "TB" });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept direction option LR", () => {
+      const plugin = createLayoutPlugin({ direction: "LR" });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept node spacing option", () => {
+      const plugin = createLayoutPlugin({ nodeSpacing: 100 });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept rank spacing option", () => {
+      const plugin = createLayoutPlugin({ rankSpacing: 150 });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept elk options", () => {
+      const plugin = createLayoutPlugin({
+        type: "elk",
+        elkOptions: {
+          algorithm: "layered",
+          direction: "DOWN",
+          spacing: 50,
+          edgeRouting: "POLYLINE"
+        }
+      });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept force options", () => {
+      const plugin = createLayoutPlugin({
+        type: "force",
+        forceOptions: {
+          strength: -500,
+          distance: 200,
+          iterations: 500
+        }
+      });
+      expect(plugin.id).toBe("layout");
+    });
+    it("should accept grid options", () => {
+      const plugin = createLayoutPlugin({
+        type: "grid",
+        gridOptions: {
+          columns: 3,
+          startX: 100,
+          startY: 100
+        }
+      });
+      expect(plugin.id).toBe("layout");
+    });
+  });
+  describe("Layout execution", () => {
+    it("should add applyLayout method to flow instance", () => {
+      const plugin = createLayoutPlugin();
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      expect(typeof flow.applyLayout).toBe("function");
+    });
+    it("should return function when calling applyLayout", async () => {
+      const plugin = createLayoutPlugin({ type: "dagre" });
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [
+        {
+          id: "1",
+          type: "default",
+          position: { x: 0, y: 0 },
+          data: { label: "Node 1" },
+          width: 150,
+          height: 50
+        }
+      ];
+      flow.edges.value = [];
+      plugin.install(flow);
+      const result = flow.applyLayout({ type: "dagre" });
+      expect(result === void 0 || result instanceof Promise).toBe(true);
+    });
+  });
+  describe("LayoutOptions interface", () => {
+    it("should validate LayoutOptions type field accepts dagre", () => {
+      const options = { type: "dagre" };
+      expect(options.type).toBe("dagre");
+    });
+    it("should validate LayoutOptions type field accepts elk", () => {
+      const options = { type: "elk" };
+      expect(options.type).toBe("elk");
+    });
+    it("should validate LayoutOptions type field accepts force", () => {
+      const options = { type: "force" };
+      expect(options.type).toBe("force");
+    });
+    it("should validate LayoutOptions type field accepts grid", () => {
+      const options = { type: "grid" };
+      expect(options.type).toBe("grid");
+    });
+  });
+});