@yh-ui/flow 1.0.1 → 1.0.4

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

@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ref } from "vue";
+import { PluginManager, createPlugin, withHooks } 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(),
+    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/plugin - withHooks", () => {
+  let consoleLogSpy;
+  let consoleWarnSpy;
+  let consoleErrorSpy;
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {
+    });
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {
+    });
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {
+    });
+  });
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+  describe("PluginManager - edge cases", () => {
+    it("should warn when unregistering non-existent plugin", () => {
+      const pm = new PluginManager();
+      pm.unregister("non-existent");
+      expect(consoleWarnSpy).toHaveBeenCalledWith("[YhFlow] Plugin non-existent not found");
+    });
+    it("should warn when registering without init and no options", () => {
+      const pm = new PluginManager();
+      const install = vi.fn();
+      pm.register({ id: "n", name: "N", install });
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        "[YhFlow] PluginManager not initialized, call init() first or provide flow instance"
+      );
+      expect(install).not.toHaveBeenCalled();
+    });
+    it("should register with options as flow instance fallback", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      const install = vi.fn();
+      pm.register({ id: "fallback", name: "Fallback", install }, flow);
+      expect(install).toHaveBeenCalledWith(flow, flow);
+    });
+    it("should log when plugin is registered", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      pm.init(flow);
+      pm.register({ id: "log-test", name: "LogTest", install: vi.fn() });
+      expect(consoleLogSpy).toHaveBeenCalledWith("[YhFlow] Plugin LogTest (log-test) registered");
+    });
+    it("should log when plugin is unregistered", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      pm.init(flow);
+      pm.register({ id: "ul", name: "UL", install: vi.fn() });
+      pm.unregister("ul");
+      expect(consoleLogSpy).toHaveBeenCalledWith("[YhFlow] Plugin UL (ul) unregistered");
+    });
+    it("should not call destroy if plugin has no destroy method", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      pm.init(flow);
+      pm.register({ id: "no-destroy", name: "NoDestroy", install: vi.fn() });
+      expect(() => pm.unregister("no-destroy")).not.toThrow();
+    });
+  });
+  describe("withHooks", () => {
+    it("should wrap plugin with onInit hook", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      pm.init(flow);
+      const onInit = vi.fn();
+      const install = vi.fn();
+      const hooks = { onInit };
+      const basePlugin = createPlugin({ id: "hooks-test", name: "HooksTest" }, install);
+      const hookedPlugin = withHooks(basePlugin, hooks);
+      hookedPlugin.install(flow);
+      expect(onInit).toHaveBeenCalled();
+    });
+    it("should register onViewportChange hook", () => {
+      const flow = createMockFlowInstance();
+      const onViewportChange = vi.fn();
+      const basePlugin = createPlugin({ id: "vp-hook", name: "VpHook" }, vi.fn());
+      const hookedPlugin = withHooks(basePlugin, { onViewportChange });
+      hookedPlugin.install(flow);
+      const onHandler = flow.on.mock.calls.find(
+        (call) => call[0] === "viewport:change"
+      );
+      expect(onHandler).toBeDefined();
+      const handler = onHandler[1];
+      handler({ transform: { x: 100, y: 200, zoom: 2 } });
+      expect(onViewportChange).toHaveBeenCalledWith({ x: 100, y: 200, zoom: 2 });
+    });
+    it("should register onNodesChange hook", () => {
+      const flow = createMockFlowInstance();
+      const onNodesChange = vi.fn();
+      const basePlugin = createPlugin({ id: "nodes-hook", name: "NodesHook" }, vi.fn());
+      const hookedPlugin = withHooks(basePlugin, { onNodesChange });
+      hookedPlugin.install(flow);
+      const onHandler = flow.on.mock.calls.find(
+        (call) => call[0] === "node:selected"
+      );
+      expect(onHandler).toBeDefined();
+    });
+    it("should register onEdgesChange hook", () => {
+      const flow = createMockFlowInstance();
+      const onEdgesChange = vi.fn();
+      const basePlugin = createPlugin({ id: "edges-hook", name: "EdgesHook" }, vi.fn());
+      const hookedPlugin = withHooks(basePlugin, { onEdgesChange });
+      hookedPlugin.install(flow);
+      const onHandler = flow.on.mock.calls.find(
+        (call) => call[0] === "edge:selected"
+      );
+      expect(onHandler).toBeDefined();
+    });
+    it("should call onDestroy when hooked plugin is destroyed", () => {
+      const flow = createMockFlowInstance();
+      const onDestroy = vi.fn();
+      const baseDestroy = vi.fn();
+      const basePlugin = createPlugin({ id: "destroy-hook", name: "DestroyHook" }, vi.fn());
+      basePlugin.destroy = baseDestroy;
+      const hookedPlugin = withHooks(basePlugin, { onDestroy });
+      hookedPlugin.destroy();
+      expect(onDestroy).toHaveBeenCalled();
+      expect(baseDestroy).toHaveBeenCalled();
+    });
+    it("should only register hooks that are provided", () => {
+      const flow = createMockFlowInstance();
+      const onInit = vi.fn();
+      const hooks = { onInit };
+      const basePlugin = createPlugin({ id: "partial-hooks", name: "PartialHooks" }, vi.fn());
+      const hookedPlugin = withHooks(basePlugin, hooks);
+      hookedPlugin.install(flow);
+      expect(onInit).toHaveBeenCalled();
+    });
+    it("should keep plugin metadata from base plugin", () => {
+      const basePlugin = createPlugin(
+        { id: "meta", name: "Meta", version: "1.0.0", description: "Test plugin" },
+        vi.fn()
+      );
+      const hookedPlugin = withHooks(basePlugin, {});
+      expect(hookedPlugin.id).toBe("meta");
+      expect(hookedPlugin.name).toBe("Meta");
+      expect(hookedPlugin.version).toBe("1.0.0");
+      expect(hookedPlugin.description).toBe("Test plugin");
+    });
+  });
+  describe("createPlugin", () => {
+    it("should create plugin with default enabled true", () => {
+      const installFn = vi.fn();
+      const plugin = createPlugin({ id: "default-enabled", name: "DefaultEnabled" }, installFn);
+      expect(plugin.enabled).toBe(true);
+    });
+    it("should create plugin with explicit enabled false", () => {
+      const installFn = vi.fn();
+      const plugin = createPlugin(
+        { id: "explicit-disabled", name: "ExplicitDisabled", enabled: false },
+        installFn
+      );
+      expect(plugin.enabled).toBe(false);
+      plugin.install(createMockFlowInstance());
+      expect(installFn).not.toHaveBeenCalled();
+    });
+    it("should pass options to install function", () => {
+      const installFn = vi.fn();
+      const plugin = createPlugin(
+        { id: "opts-pass", name: "OptsPass", version: "2.0.0" },
+        installFn
+      );
+      const flow = createMockFlowInstance();
+      plugin.install(flow, { customOption: true });
+      expect(installFn).toHaveBeenCalledWith(flow, { id: "opts-pass", name: "OptsPass", version: "2.0.0" });
+    });
+  });
+  describe("getPlugins", () => {
+    it("should return all registered plugins", () => {
+      const pm = new PluginManager();
+      const flow = createMockFlowInstance();
+      pm.init(flow);
+      pm.register({ id: "p1", name: "P1", install: vi.fn() });
+      pm.register({ id: "p2", name: "P2", install: vi.fn() });
+      const plugins = pm.getPlugins();
+      expect(plugins).toHaveLength(2);
+    });
+  });
+});

package/dist/__tests__/plugins.test.cjs

@@ -0,0 +1,412 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _controls = require("../plugins/plugins/controls.cjs");
+var _grid = require("../plugins/plugins/grid.cjs");
+var _keyboard = require("../plugins/plugins/keyboard.cjs");
+var _minimap = require("../plugins/plugins/minimap.cjs");
+var _snap = require("../plugins/plugins/snap.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()
+  };
+}
+(0, _vitest.describe)("flow/plugins/plugins/controls", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+  });
+  (0, _vitest.describe)("createControlsPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _controls.createControlsPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("controls");
+      (0, _vitest.expect)(plugin.name).toBe("Controls");
+      (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+      (0, _vitest.expect)(plugin.description).toBe("Displays a set of controls for zooming and fitting the view");
+    });
+    (0, _vitest.it)("should have a component", () => {
+      const plugin = (0, _controls.createControlsPlugin)();
+      (0, _vitest.expect)(plugin.component).toBeDefined();
+    });
+    (0, _vitest.it)("should install with default options", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _controls.createControlsPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("[Controls Plugin] Installed");
+    });
+    (0, _vitest.it)("should merge custom options", () => {
+      const plugin = (0, _controls.createControlsPlugin)({
+        enabled: true,
+        position: "top-right",
+        showZoom: true,
+        showFitView: false,
+        showInteractive: false
+      });
+      (0, _vitest.expect)(plugin.componentProps).toEqual({
+        position: "top-right",
+        showZoom: true,
+        showFitView: false,
+        showInteractive: false
+      });
+    });
+    (0, _vitest.it)("should use default position when not provided", () => {
+      const plugin = (0, _controls.createControlsPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.position).toBe("bottom-left");
+    });
+    (0, _vitest.it)("should use default show options", () => {
+      const plugin = (0, _controls.createControlsPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.showZoom).toBe(true);
+      (0, _vitest.expect)(plugin.componentProps?.showFitView).toBe(true);
+      (0, _vitest.expect)(plugin.componentProps?.showInteractive).toBe(true);
+    });
+    (0, _vitest.it)("should support all position options", () => {
+      const positions = ["top-left", "top-right", "bottom-left", "bottom-right"];
+      for (const pos of positions) {
+        const plugin = (0, _controls.createControlsPlugin)({
+          position: pos
+        });
+        (0, _vitest.expect)(plugin.componentProps?.position).toBe(pos);
+      }
+    });
+  });
+});
+(0, _vitest.describe)("flow/plugins/plugins/grid", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+  });
+  (0, _vitest.describe)("createGridPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _grid.createGridPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("grid");
+      (0, _vitest.expect)(plugin.name).toBe("Grid");
+      (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+      (0, _vitest.expect)(plugin.description).toBe("Displays a grid or dots background");
+    });
+    (0, _vitest.it)("should have a component", () => {
+      const plugin = (0, _grid.createGridPlugin)();
+      (0, _vitest.expect)(plugin.component).toBeDefined();
+    });
+    (0, _vitest.it)("should install with default options", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _grid.createGridPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("[Grid Plugin] Installed");
+    });
+    (0, _vitest.it)("should merge custom options", () => {
+      const plugin = (0, _grid.createGridPlugin)({
+        enabled: true,
+        type: "grid",
+        color: "#ff0000",
+        gap: 30
+      });
+      (0, _vitest.expect)(plugin.componentProps).toEqual({
+        type: "grid",
+        color: "#ff0000",
+        gap: 30
+      });
+    });
+    (0, _vitest.it)("should use default type dots", () => {
+      const plugin = (0, _grid.createGridPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.type).toBe("dots");
+    });
+    (0, _vitest.it)("should use default gap", () => {
+      const plugin = (0, _grid.createGridPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.gap).toBe(20);
+    });
+    (0, _vitest.it)("should use default color", () => {
+      const plugin = (0, _grid.createGridPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.color).toBe("#e5e5e5");
+    });
+    (0, _vitest.it)("should support grid type", () => {
+      const plugin = (0, _grid.createGridPlugin)({
+        type: "grid"
+      });
+      (0, _vitest.expect)(plugin.componentProps?.type).toBe("grid");
+    });
+  });
+});
+(0, _vitest.describe)("flow/plugins/plugins/keyboard", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+  });
+  (0, _vitest.describe)("createKeyboardPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _keyboard.createKeyboardPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("keyboard");
+      (0, _vitest.expect)(plugin.name).toBe("Keyboard");
+    });
+    (0, _vitest.it)("should install with default options", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _keyboard.createKeyboardPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("Keyboard plugin installed", {
+        enabled: true,
+        delete: true,
+        backspace: true,
+        ctrlZ: true,
+        ctrlY: true,
+        escape: true
+      });
+    });
+    (0, _vitest.it)("should merge custom options", () => {
+      const plugin = (0, _keyboard.createKeyboardPlugin)({
+        enabled: false,
+        delete: false,
+        backspace: false,
+        ctrlZ: false,
+        ctrlY: false,
+        escape: false
+      });
+      plugin.install(createMockFlowInstance());
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("Keyboard plugin installed", {
+        enabled: false,
+        delete: false,
+        backspace: false,
+        ctrlZ: false,
+        ctrlY: false,
+        escape: false
+      });
+    });
+    (0, _vitest.it)("should accept partial options", () => {
+      const plugin = (0, _keyboard.createKeyboardPlugin)({
+        delete: false
+      });
+      (0, _vitest.expect)(plugin.id).toBe("keyboard");
+    });
+    (0, _vitest.it)("should override individual options", () => {
+      const plugin = (0, _keyboard.createKeyboardPlugin)({
+        ctrlZ: false,
+        ctrlY: false
+      });
+      plugin.install(createMockFlowInstance());
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalledWith("Keyboard plugin installed", {
+        enabled: true,
+        delete: true,
+        backspace: true,
+        ctrlZ: false,
+        ctrlY: false,
+        escape: true
+      });
+    });
+  });
+});
+(0, _vitest.describe)("flow/plugins/plugins/minimap", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+  });
+  (0, _vitest.describe)("createMiniMapPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("minimap");
+      (0, _vitest.expect)(plugin.name).toBe("Minimap");
+      (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+      (0, _vitest.expect)(plugin.description).toBe("Displays a minimap for navigation");
+    });
+    (0, _vitest.it)("should have a component", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.component).toBeDefined();
+    });
+    (0, _vitest.it)("should install with default options", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should use default position bottom-right", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.position).toBe("bottom-right");
+    });
+    (0, _vitest.it)("should use default dimensions", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.width).toBe(200);
+      (0, _vitest.expect)(plugin.componentProps?.height).toBe(150);
+    });
+    (0, _vitest.it)("should use default mask colors", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.maskColor).toBe("rgba(240, 240, 240, 0.6)");
+      (0, _vitest.expect)(plugin.componentProps?.maskStrokeColor).toBe("#ddd");
+      (0, _vitest.expect)(plugin.componentProps?.maskStrokeWidth).toBe(1);
+    });
+    (0, _vitest.it)("should use default pannable and zoomable", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.pannable).toBe(true);
+      (0, _vitest.expect)(plugin.componentProps?.zoomable).toBe(true);
+    });
+    (0, _vitest.it)("should support custom position", () => {
+      const positions = ["top-left", "top-right", "bottom-left", "bottom-right"];
+      for (const pos of positions) {
+        const plugin = (0, _minimap.createMiniMapPlugin)({
+          position: pos
+        });
+        (0, _vitest.expect)(plugin.componentProps?.position).toBe(pos);
+      }
+    });
+    (0, _vitest.it)("should support custom dimensions", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)({
+        width: 300,
+        height: 200
+      });
+      (0, _vitest.expect)(plugin.componentProps?.width).toBe(300);
+      (0, _vitest.expect)(plugin.componentProps?.height).toBe(200);
+    });
+    (0, _vitest.it)("should support custom node color functions", () => {
+      const customNodeColor = node => "#ff0000";
+      const customNodeStrokeColor = node => "#00ff00";
+      const plugin = (0, _minimap.createMiniMapPlugin)({
+        nodeColor: customNodeColor,
+        nodeStrokeColor: customNodeStrokeColor
+      });
+      (0, _vitest.expect)(plugin.componentProps?.nodeColor).toBe(customNodeColor);
+      (0, _vitest.expect)(plugin.componentProps?.nodeStrokeColor).toBe(customNodeStrokeColor);
+    });
+    (0, _vitest.it)("should support interactive option", () => {
+      const pluginEnabled = (0, _minimap.createMiniMapPlugin)({
+        interactive: true
+      });
+      const pluginDisabled = (0, _minimap.createMiniMapPlugin)({
+        interactive: false
+      });
+      (0, _vitest.expect)(pluginEnabled.componentProps?.interactive).toBe(true);
+      (0, _vitest.expect)(pluginDisabled.componentProps?.interactive).toBe(false);
+    });
+    (0, _vitest.it)("should support layout controls options", () => {
+      const plugin = (0, _minimap.createMiniMapPlugin)({
+        showLayoutControls: true,
+        layoutType: "dagre",
+        layoutDirection: "LR"
+      });
+      (0, _vitest.expect)(plugin.componentProps?.showLayoutControls).toBe(true);
+      (0, _vitest.expect)(plugin.componentProps?.layoutType).toBe("dagre");
+      (0, _vitest.expect)(plugin.componentProps?.layoutDirection).toBe("LR");
+    });
+    (0, _vitest.it)("should support all layout directions", () => {
+      const directions = ["TB", "BT", "LR", "RL"];
+      for (const dir of directions) {
+        const plugin = (0, _minimap.createMiniMapPlugin)({
+          layoutDirection: dir
+        });
+        (0, _vitest.expect)(plugin.componentProps?.layoutDirection).toBe(dir);
+      }
+    });
+    (0, _vitest.it)("should support all layout types", () => {
+      const types = ["dagre", "elk", "force", "grid", "none"];
+      for (const type of types) {
+        const plugin = (0, _minimap.createMiniMapPlugin)({
+          layoutType: type
+        });
+        (0, _vitest.expect)(plugin.componentProps?.layoutType).toBe(type);
+      }
+    });
+  });
+});
+(0, _vitest.describe)("flow/plugins/plugins/snap", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+  });
+  (0, _vitest.describe)("createSnapPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _snap.createSnapPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("snap");
+      (0, _vitest.expect)(plugin.name).toBe("Snap");
+      (0, _vitest.expect)(plugin.version).toBe("1.0.0");
+      (0, _vitest.expect)(plugin.description).toBe("Enables grid snapping and alignment lines");
+    });
+    (0, _vitest.it)("should have a component when showAlignmentLines is true", () => {
+      const plugin = (0, _snap.createSnapPlugin)({
+        showAlignmentLines: true
+      });
+      (0, _vitest.expect)(plugin.component).toBeDefined();
+    });
+    (0, _vitest.it)("should not have a component when showAlignmentLines is false", () => {
+      const plugin = (0, _snap.createSnapPlugin)({
+        showAlignmentLines: false
+      });
+      (0, _vitest.expect)(plugin.component).toBeUndefined();
+    });
+    (0, _vitest.it)("should install with default options", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _snap.createSnapPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should not install when enabled is false", () => {
+      const flow = createMockFlowInstance();
+      const plugin = (0, _snap.createSnapPlugin)({
+        enabled: false
+      });
+      plugin.install(flow);
+      (0, _vitest.expect)(consoleLogSpy).not.toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should use default snap options", () => {
+      const plugin = (0, _snap.createSnapPlugin)();
+      (0, _vitest.expect)(plugin.componentProps?.snapThreshold).toBe(10);
+    });
+    (0, _vitest.it)("should support custom snap options", () => {
+      const plugin = (0, _snap.createSnapPlugin)({
+        snapToGrid: true,
+        gridSize: 20,
+        snapThreshold: 15
+      });
+      (0, _vitest.expect)(plugin.componentProps?.snapThreshold).toBe(15);
+    });
+  });
+});

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

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