@yh-ui/flow 0.1.56 → 1.0.4

package/dist/__tests__/export.test.mjs

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ref } from "vue";
+import { createExportPlugin } from "../plugins/plugins/export.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/plugins/plugins/export", () => {
+  let consoleLogSpy;
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {
+    });
+    vi.useFakeTimers({ shouldAdvanceTime: false });
+  });
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    vi.useRealTimers();
+  });
+  describe("createExportPlugin", () => {
+    it("should create plugin with correct id and name", () => {
+      const plugin = createExportPlugin();
+      expect(plugin.id).toBe("export");
+      expect(plugin.name).toBe("Export");
+    });
+    it("should install exportJson method", () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [
+        { id: "n1", type: "default", position: { x: 0, y: 0 }, data: { label: "Node 1" } }
+      ];
+      flow.edges.value = [{ id: "e1", source: "n1", target: "n2", type: "default" }];
+      const plugin = createExportPlugin();
+      plugin.install(flow);
+      expect(typeof flow.exportJson).toBe("function");
+    });
+    it("should exportJson return correct JSON structure", () => {
+      const flow = createMockFlowInstance();
+      const testNode = { id: "n1", type: "default", position: { x: 100, y: 200 }, data: {} };
+      flow.nodes.value = [testNode];
+      flow.edges.value = [{ id: "e1", source: "n1", target: "n2", type: "default" }];
+      const plugin = createExportPlugin();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      const parsed = JSON.parse(json);
+      expect(parsed.nodes).toHaveLength(1);
+      expect(parsed.edges).toHaveLength(1);
+      expect(parsed.nodes[0].id).toBe("n1");
+    });
+    it("should exportJson with formatted output", () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [];
+      flow.edges.value = [];
+      const plugin = createExportPlugin();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      expect(json).toContain("\n");
+    });
+    it("should include viewport in exportJson", () => {
+      const flow = createMockFlowInstance();
+      flow.viewport.value = { x: 50, y: 100, zoom: 1.5 };
+      const plugin = createExportPlugin();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      const parsed = JSON.parse(json);
+      expect(parsed.viewport).toEqual({ x: 50, y: 100, zoom: 1.5 });
+    });
+    it("should support custom fileName option", () => {
+      const plugin = createExportPlugin({ fileName: "custom-flow-name" });
+      expect(plugin.id).toBe("export");
+    });
+    it("should support different image types", () => {
+      const pluginPng = createExportPlugin({ imageType: "png" });
+      const pluginJpeg = createExportPlugin({ imageType: "jpeg" });
+      const pluginWebp = createExportPlugin({ imageType: "webp" });
+      expect(pluginPng.id).toBe("export");
+      expect(pluginJpeg.id).toBe("export");
+      expect(pluginWebp.id).toBe("export");
+    });
+    it("should support custom imageQuality", () => {
+      const plugin = createExportPlugin({ imageQuality: 0.8 });
+      expect(plugin.id).toBe("export");
+    });
+    it("should support custom pixelRatio", () => {
+      const plugin = createExportPlugin({ pixelRatio: 3 });
+      expect(plugin.id).toBe("export");
+    });
+    it("should support custom backgroundColor", () => {
+      const plugin = createExportPlugin({ backgroundColor: "#f0f0f0" });
+      expect(plugin.id).toBe("export");
+    });
+    it("should support exportImage disabled", () => {
+      const plugin = createExportPlugin({ exportImage: false });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      expect(flow.exportImage).toBeUndefined();
+    });
+    it("should support exportJson disabled", () => {
+      const plugin = createExportPlugin({ exportJson: false });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      expect(flow.exportJson).toBeUndefined();
+    });
+    it("should not install when enabled is false", () => {
+      const plugin = createExportPlugin({ enabled: false });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      expect(flow.exportJson).toBeUndefined();
+      expect(flow.exportImage).toBeUndefined();
+    });
+    it("should merge default options with provided options", () => {
+      const plugin = createExportPlugin({ fileName: "test", imageType: "jpeg" });
+      expect(plugin.id).toBe("export");
+      expect(plugin.name).toBe("Export");
+    });
+  });
+  describe("ExportPluginOptions interface", () => {
+    it("should accept all option fields", () => {
+      const options = {
+        enabled: true,
+        fileName: "my-flow",
+        exportImage: true,
+        exportJson: true,
+        imageType: "png",
+        imageQuality: 0.9,
+        pixelRatio: 2,
+        backgroundColor: "#ffffff"
+      };
+      const plugin = createExportPlugin(options);
+      expect(plugin.id).toBe("export");
+    });
+    it("should accept partial options", () => {
+      const plugin = createExportPlugin({ fileName: "partial" });
+      expect(plugin.id).toBe("export");
+    });
+  });
+});

package/dist/__tests__/flow-context.test.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _FlowContext = require("../core/FlowContext.cjs");
+(0, _vitest.describe)("flow/core/FlowContext", () => {
+  (0, _vitest.describe)("provideFlowContext", () => {
+    (0, _vitest.it)("should accept null without error", () => {
+      (0, _vitest.expect)(() => (0, _FlowContext.provideFlowContext)(null)).not.toThrow();
+    });
+  });
+  (0, _vitest.describe)("useFlowContext", () => {
+    (0, _vitest.it)("should throw when used outside provider", () => {
+      (0, _vitest.expect)(() => (0, _FlowContext.useFlowContext)()).toThrow("[YhFlow] FlowContext is not provided");
+    });
+  });
+});

package/dist/__tests__/flow-context.test.d.ts

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

package/dist/__tests__/flow-context.test.mjs

@@ -0,0 +1,16 @@
+import { describe, it, expect } from "vitest";
+import { useFlowContext, provideFlowContext } from "../core/FlowContext.mjs";
+describe("flow/core/FlowContext", () => {
+  describe("provideFlowContext", () => {
+    it("should accept null without error", () => {
+      expect(() => provideFlowContext(null)).not.toThrow();
+    });
+  });
+  describe("useFlowContext", () => {
+    it("should throw when used outside provider", () => {
+      expect(() => useFlowContext()).toThrow(
+        "[YhFlow] FlowContext is not provided"
+      );
+    });
+  });
+});

package/dist/__tests__/flow-props.test.cjs

@@ -0,0 +1,94 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _flow = require("../flow.cjs");
+(0, _vitest.describe)("flow/flow", () => {
+  (0, _vitest.describe)("flowProps", () => {
+    (0, _vitest.it)("should have all required prop definitions", () => {
+      (0, _vitest.expect)(_flow.flowProps.nodes).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.edges).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.modelValue).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.minZoom).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.maxZoom).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.zoomStep).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.nodesDraggable).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.edgesConnectable).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.selectable).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.background).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.gridSize).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.snapToGrid).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.readonly).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.keyboardShortcuts).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.showControls).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.showMinimap).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.history).toBeDefined();
+      (0, _vitest.expect)(_flow.flowProps.maxHistory).toBeDefined();
+    });
+    (0, _vitest.it)("should have correct default values for numbers", () => {
+      (0, _vitest.expect)(_flow.flowProps.minZoom.default).toBe(0.1);
+      (0, _vitest.expect)(_flow.flowProps.maxZoom.default).toBe(5);
+      (0, _vitest.expect)(_flow.flowProps.zoomStep.default).toBe(0.1);
+      (0, _vitest.expect)(_flow.flowProps.panZoomSpeed.default).toBe(1);
+      (0, _vitest.expect)(_flow.flowProps.gridSize.default).toBe(20);
+      (0, _vitest.expect)(_flow.flowProps.maxHistory.default).toBe(50);
+      (0, _vitest.expect)(_flow.flowProps.virtualizationThreshold.default).toBe(100);
+    });
+    (0, _vitest.it)("should have correct default values for booleans", () => {
+      (0, _vitest.expect)(_flow.flowProps.nodesDraggable.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.edgesConnectable.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.selectable.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.snapToGrid.default).toBe(false);
+      (0, _vitest.expect)(_flow.flowProps.readonly.default).toBe(false);
+      (0, _vitest.expect)(_flow.flowProps.keyboardShortcuts.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.showControls.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.showMinimap.default).toBe(false);
+      (0, _vitest.expect)(_flow.flowProps.history.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.showAlignmentGuides.default).toBe(true);
+      (0, _vitest.expect)(_flow.flowProps.virtualized.default).toBe(false);
+    });
+    (0, _vitest.it)("should have correct default values for strings", () => {
+      (0, _vitest.expect)(_flow.flowProps.background.default).toBe("dots");
+      (0, _vitest.expect)(_flow.flowProps.backgroundColor.default).toBe("#f8f9fa");
+      (0, _vitest.expect)(_flow.flowProps.defaultNodeType.default).toBe("default");
+      (0, _vitest.expect)(_flow.flowProps.defaultEdgeType.default).toBe("bezier");
+      (0, _vitest.expect)(_flow.flowProps.multiSelectKey.default).toBe("Shift");
+      (0, _vitest.expect)(_flow.flowProps.minimapNodeColor.default).toBe("#b1b1b7");
+    });
+    (0, _vitest.it)("should have isValidConnection defaulting to null", () => {
+      (0, _vitest.expect)(_flow.flowProps.isValidConnection.default).toBe(null);
+    });
+    (0, _vitest.it)("should have themeOverrides defaulting to undefined", () => {
+      (0, _vitest.expect)(_flow.flowProps.themeOverrides.default).toBeUndefined();
+    });
+  });
+  (0, _vitest.describe)("flowEmits", () => {
+    (0, _vitest.it)("should have update:modelValue emit", () => {
+      (0, _vitest.expect)(_flow.flowEmits["update:modelValue"]).toBeDefined();
+    });
+    (0, _vitest.it)("should have update:nodes emit", () => {
+      (0, _vitest.expect)(_flow.flowEmits["update:nodes"]).toBeDefined();
+    });
+    (0, _vitest.it)("should have update:edges emit", () => {
+      (0, _vitest.expect)(_flow.flowEmits["update:edges"]).toBeDefined();
+    });
+    (0, _vitest.it)("should have node event emits", () => {
+      (0, _vitest.expect)(_flow.flowEmits.nodeClick).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.nodeDblClick).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.nodeDragStart).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.nodeDrag).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.nodeDragEnd).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.nodeContextMenu).toBeDefined();
+    });
+    (0, _vitest.it)("should have edge event emits", () => {
+      (0, _vitest.expect)(_flow.flowEmits.edgeClick).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.edgeDblClick).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.edgeContextMenu).toBeDefined();
+    });
+    (0, _vitest.it)("should have connection emits", () => {
+      (0, _vitest.expect)(_flow.flowEmits.edgeConnect).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.selectionChange).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.historyChange).toBeDefined();
+      (0, _vitest.expect)(_flow.flowEmits.viewportChange).toBeDefined();
+    });
+  });
+});

package/dist/__tests__/flow-props.test.d.ts

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

package/dist/__tests__/flow-props.test.mjs

@@ -0,0 +1,92 @@
+import { describe, it, expect } from "vitest";
+import { flowProps, flowEmits } from "../flow.mjs";
+describe("flow/flow", () => {
+  describe("flowProps", () => {
+    it("should have all required prop definitions", () => {
+      expect(flowProps.nodes).toBeDefined();
+      expect(flowProps.edges).toBeDefined();
+      expect(flowProps.modelValue).toBeDefined();
+      expect(flowProps.minZoom).toBeDefined();
+      expect(flowProps.maxZoom).toBeDefined();
+      expect(flowProps.zoomStep).toBeDefined();
+      expect(flowProps.nodesDraggable).toBeDefined();
+      expect(flowProps.edgesConnectable).toBeDefined();
+      expect(flowProps.selectable).toBeDefined();
+      expect(flowProps.background).toBeDefined();
+      expect(flowProps.gridSize).toBeDefined();
+      expect(flowProps.snapToGrid).toBeDefined();
+      expect(flowProps.readonly).toBeDefined();
+      expect(flowProps.keyboardShortcuts).toBeDefined();
+      expect(flowProps.showControls).toBeDefined();
+      expect(flowProps.showMinimap).toBeDefined();
+      expect(flowProps.history).toBeDefined();
+      expect(flowProps.maxHistory).toBeDefined();
+    });
+    it("should have correct default values for numbers", () => {
+      expect(flowProps.minZoom.default).toBe(0.1);
+      expect(flowProps.maxZoom.default).toBe(5);
+      expect(flowProps.zoomStep.default).toBe(0.1);
+      expect(flowProps.panZoomSpeed.default).toBe(1);
+      expect(flowProps.gridSize.default).toBe(20);
+      expect(flowProps.maxHistory.default).toBe(50);
+      expect(flowProps.virtualizationThreshold.default).toBe(100);
+    });
+    it("should have correct default values for booleans", () => {
+      expect(flowProps.nodesDraggable.default).toBe(true);
+      expect(flowProps.edgesConnectable.default).toBe(true);
+      expect(flowProps.selectable.default).toBe(true);
+      expect(flowProps.snapToGrid.default).toBe(false);
+      expect(flowProps.readonly.default).toBe(false);
+      expect(flowProps.keyboardShortcuts.default).toBe(true);
+      expect(flowProps.showControls.default).toBe(true);
+      expect(flowProps.showMinimap.default).toBe(false);
+      expect(flowProps.history.default).toBe(true);
+      expect(flowProps.showAlignmentGuides.default).toBe(true);
+      expect(flowProps.virtualized.default).toBe(false);
+    });
+    it("should have correct default values for strings", () => {
+      expect(flowProps.background.default).toBe("dots");
+      expect(flowProps.backgroundColor.default).toBe("#f8f9fa");
+      expect(flowProps.defaultNodeType.default).toBe("default");
+      expect(flowProps.defaultEdgeType.default).toBe("bezier");
+      expect(flowProps.multiSelectKey.default).toBe("Shift");
+      expect(flowProps.minimapNodeColor.default).toBe("#b1b1b7");
+    });
+    it("should have isValidConnection defaulting to null", () => {
+      expect(flowProps.isValidConnection.default).toBe(null);
+    });
+    it("should have themeOverrides defaulting to undefined", () => {
+      expect(flowProps.themeOverrides.default).toBeUndefined();
+    });
+  });
+  describe("flowEmits", () => {
+    it("should have update:modelValue emit", () => {
+      expect(flowEmits["update:modelValue"]).toBeDefined();
+    });
+    it("should have update:nodes emit", () => {
+      expect(flowEmits["update:nodes"]).toBeDefined();
+    });
+    it("should have update:edges emit", () => {
+      expect(flowEmits["update:edges"]).toBeDefined();
+    });
+    it("should have node event emits", () => {
+      expect(flowEmits.nodeClick).toBeDefined();
+      expect(flowEmits.nodeDblClick).toBeDefined();
+      expect(flowEmits.nodeDragStart).toBeDefined();
+      expect(flowEmits.nodeDrag).toBeDefined();
+      expect(flowEmits.nodeDragEnd).toBeDefined();
+      expect(flowEmits.nodeContextMenu).toBeDefined();
+    });
+    it("should have edge event emits", () => {
+      expect(flowEmits.edgeClick).toBeDefined();
+      expect(flowEmits.edgeDblClick).toBeDefined();
+      expect(flowEmits.edgeContextMenu).toBeDefined();
+    });
+    it("should have connection emits", () => {
+      expect(flowEmits.edgeConnect).toBeDefined();
+      expect(flowEmits.selectionChange).toBeDefined();
+      expect(flowEmits.historyChange).toBeDefined();
+      expect(flowEmits.viewportChange).toBeDefined();
+    });
+  });
+});

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

@@ -0,0 +1,233 @@
+"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(),
+    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: _vitest.vi.fn(() => nodes.value),
+    getEdges: _vitest.vi.fn(() => edges.value),
+    getViewport: _vitest.vi.fn(() => viewport.value),
+    screenToCanvas: _vitest.vi.fn(),
+    canvasToScreen: _vitest.vi.fn(),
+    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()
+  };
+}
+function createMockNode(id, type = "default") {
+  return {
+    id,
+    type,
+    position: {
+      x: 0,
+      y: 0
+    },
+    width: 100,
+    height: 50,
+    data: {},
+    selected: false,
+    dragging: false
+  };
+}
+function createMockEdge(id, source, target) {
+  return {
+    id,
+    source,
+    target,
+    type: "smoothstep",
+    selected: false,
+    animated: false
+  };
+}
+(0, _vitest.describe)("flow/plugins/plugins/layout", () => {
+  let consoleLogSpy;
+  let consoleWarnSpy;
+  let consoleErrorSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleWarnSpy = _vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    consoleErrorSpy = _vitest.vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    _vitest.vi.restoreAllMocks();
+  });
+  (0, _vitest.describe)("createLayoutPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _layout.createLayoutPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+      (0, _vitest.expect)(plugin.name).toBe("Layout");
+      (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+    });
+    (0, _vitest.it)("should install without crashing", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _layout.createLayoutPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.applyLayout).toBeDefined();
+    });
+    (0, _vitest.it)("should not install applyLayout when enabled is false", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _layout.createLayoutPlugin)({
+        enabled: false
+      });
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.applyLayout).toBeUndefined();
+    });
+    (0, _vitest.it)("should use default layout options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should merge custom options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid",
+        direction: "LR",
+        nodeSpacing: 100,
+        rankSpacing: 200,
+        animate: false
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should support all layout types", () => {
+      const types = ["dagre", "elk", "force", "grid"];
+      for (const type of types) {
+        const plugin = (0, _layout.createLayoutPlugin)({
+          type
+        });
+        (0, _vitest.expect)(plugin.id).toBe("layout");
+      }
+    });
+    (0, _vitest.it)("should support all directions", () => {
+      const directions = ["TB", "BT", "LR", "RL"];
+      for (const direction of directions) {
+        const plugin = (0, _layout.createLayoutPlugin)({
+          direction
+        });
+        (0, _vitest.expect)(plugin.id).toBe("layout");
+      }
+    });
+    (0, _vitest.it)("should support 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 support force options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "force",
+        forceOptions: {
+          strength: -500,
+          distance: 150,
+          theta: 0.5,
+          iterations: 500
+        }
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+    (0, _vitest.it)("should support grid options", () => {
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid",
+        gridOptions: {
+          columns: 6,
+          startX: 100,
+          startY: 100
+        }
+      });
+      (0, _vitest.expect)(plugin.id).toBe("layout");
+    });
+  });
+  (0, _vitest.describe)("applyLayout with grid", () => {
+    (0, _vitest.it)("should apply grid layout", async () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [createMockNode("n1"), createMockNode("n2"), createMockNode("n3"), createMockNode("n4")];
+      flow.edges.value = [createMockEdge("e1", "n1", "n2"), createMockEdge("e2", "n2", "n3")];
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid",
+        animate: false
+      });
+      plugin.install(flow);
+      await flow.applyLayout({
+        type: "grid",
+        gridOptions: {
+          columns: 2
+        }
+      });
+      (0, _vitest.expect)(flow.updateNode).toHaveBeenCalled();
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("[Layout Plugin] Grid layout applied successfully");
+    });
+    (0, _vitest.it)("should warn for unknown layout type", async () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [createMockNode("n1")];
+      const plugin = (0, _layout.createLayoutPlugin)();
+      plugin.install(flow);
+      await flow.applyLayout({
+        type: "unknown"
+      });
+      (0, _vitest.expect)(consoleWarnSpy).toHaveBeenCalledWith(_vitest.expect.stringContaining("Unknown layout type"));
+    });
+    (0, _vitest.it)("should handle layout with empty nodes", async () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [];
+      flow.edges.value = [];
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid"
+      });
+      plugin.install(flow);
+      await flow.applyLayout();
+      (0, _vitest.expect)(flow.updateNode).not.toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should use override options from applyLayout call", async () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [createMockNode("n1")];
+      flow.edges.value = [];
+      const plugin = (0, _layout.createLayoutPlugin)({
+        type: "grid"
+      });
+      plugin.install(flow);
+      await flow.applyLayout({
+        direction: "LR"
+      });
+      (0, _vitest.expect)(flow.updateNode).toHaveBeenCalled();
+    });
+  });
+});

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

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