@yh-ui/flow 1.0.1 → 1.0.4

package/dist/__tests__/events-types.test.mjs

@@ -0,0 +1,184 @@
+import { describe, it, expect } from "vitest";
+describe("flow/types/events", () => {
+  describe("FlowEventCallback", () => {
+    it("should define callback type", () => {
+      const callback = (event) => {
+        expect(event).toBeDefined();
+      };
+      expect(typeof callback).toBe("function");
+    });
+    it("should accept void event type", () => {
+      const callback = () => {
+      };
+      expect(typeof callback).toBe("function");
+    });
+  });
+  describe("FlowEventKey", () => {
+    it("should define all event keys", () => {
+      const keys = [
+        "node:click",
+        "node:dblclick",
+        "node:dragstart",
+        "node:drag",
+        "node:dragend",
+        "node:selected",
+        "node:unselected",
+        "node:contextmenu",
+        "edge:click",
+        "edge:dblclick",
+        "edge:selected",
+        "edge:unselected",
+        "edge:contextmenu",
+        "edge:connect",
+        "edge:update",
+        "viewport:change",
+        "selection:change",
+        "selection:dragstart",
+        "selection:drag",
+        "selection:dragend",
+        "pane:click",
+        "pane:dblclick",
+        "pane:contextmenu",
+        "connect:start",
+        "connect:end",
+        "connect:cancel"
+      ];
+      expect(keys.length).toBeGreaterThan(20);
+    });
+  });
+  describe("FlowEvents", () => {
+    it("should define node click event", () => {
+      const event = {
+        node: { id: "n1", type: "default", position: { x: 0, y: 0 }, data: {} },
+        nativeEvent: new MouseEvent("click")
+      };
+      expect(event.node.id).toBe("n1");
+    });
+    it("should define node drag event", () => {
+      const event = {
+        node: { id: "n1", type: "default", position: { x: 0, y: 0 }, data: {} },
+        nativeEvent: new MouseEvent("mousedown"),
+        position: { x: 100, y: 200 }
+      };
+      expect(event.position.x).toBe(100);
+    });
+    it("should define edge connect event", () => {
+      const event = {
+        connection: {
+          source: "n1",
+          target: "n2",
+          sourceHandle: "right",
+          targetHandle: "left"
+        }
+      };
+      expect(event.connection.source).toBe("n1");
+      expect(event.connection.target).toBe("n2");
+    });
+    it("should define viewport change event", () => {
+      const event = {
+        transform: { x: 100, y: 50, zoom: 1.5 }
+      };
+      expect(event.transform.zoom).toBe(1.5);
+    });
+    it("should define selection change event", () => {
+      const event = {
+        selectedNodes: [
+          { id: "n1", type: "default", position: { x: 0, y: 0 }, data: {} }
+        ],
+        selectedEdges: []
+      };
+      expect(event.selectedNodes.length).toBe(1);
+    });
+    it("should define pane click event", () => {
+      const event = {
+        nativeEvent: new MouseEvent("click")
+      };
+      expect(event.nativeEvent).toBeDefined();
+    });
+    it("should define connect start event", () => {
+      const event = {
+        connection: { source: "n1", target: "n2" },
+        nativeEvent: new MouseEvent("mousedown")
+      };
+      expect(event.connection).toBeDefined();
+    });
+    it("should define connect cancel event", () => {
+      const event = void 0;
+      expect(event).toBeUndefined();
+    });
+  });
+  describe("FlowEventHandler", () => {
+    it("should define handler for node click", () => {
+      const handler = (event) => {
+        expect(event.node.id).toBeDefined();
+      };
+      expect(typeof handler).toBe("function");
+    });
+    it("should define handler for void event", () => {
+      const handler = () => {
+      };
+      expect(typeof handler).toBe("function");
+    });
+    it("should define handler for viewport change", () => {
+      const handler = (event) => {
+        expect(event.transform).toBeDefined();
+      };
+      expect(typeof handler).toBe("function");
+    });
+  });
+  describe("EventBus", () => {
+    it("should define EventBus interface", () => {
+      const bus = {
+        on: () => {
+        },
+        off: () => {
+        },
+        emit: () => {
+        },
+        once: () => {
+        },
+        clear: () => {
+        }
+      };
+      expect(typeof bus.on).toBe("function");
+      expect(typeof bus.off).toBe("function");
+      expect(typeof bus.emit).toBe("function");
+      expect(typeof bus.once).toBe("function");
+      expect(typeof bus.clear).toBe("function");
+    });
+  });
+  describe("SelectionRect", () => {
+    it("should define selection rectangle", () => {
+      const rect = {
+        x: 100,
+        y: 200,
+        width: 300,
+        height: 150
+      };
+      expect(rect.x).toBe(100);
+      expect(rect.y).toBe(200);
+      expect(rect.width).toBe(300);
+      expect(rect.height).toBe(150);
+    });
+    it("should allow negative coordinates", () => {
+      const rect = {
+        x: -50,
+        y: -100,
+        width: 200,
+        height: 100
+      };
+      expect(rect.x).toBe(-50);
+      expect(rect.y).toBe(-100);
+    });
+    it("should allow zero dimensions", () => {
+      const rect = {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0
+      };
+      expect(rect.width).toBe(0);
+      expect(rect.height).toBe(0);
+    });
+  });
+});

package/dist/__tests__/export-image-plugin.test.cjs

@@ -0,0 +1,142 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _export = require("../plugins/plugins/export.cjs");
+var screenshot = _interopRequireWildcard(require("../utils/screenshot.cjs"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+_vitest.vi.mock("../utils/screenshot", () => ({
+  captureElement: _vitest.vi.fn().mockResolvedValue({
+    dataUrl: "data:image/png;base64,xx",
+    blob: new Blob(),
+    extension: "png"
+  }),
+  triggerDownload: _vitest.vi.fn(),
+  copyBlobToClipboard: _vitest.vi.fn().mockResolvedValue(void 0)
+}));
+function createMockFlow(overrides = {}) {
+  const nodes = (0, _vue.ref)([]);
+  const edges = (0, _vue.ref)([]);
+  const viewport = (0, _vue.ref)({
+    x: 0,
+    y: 0,
+    zoom: 1
+  });
+  const el = document.createElement("div");
+  return {
+    nodes,
+    edges,
+    viewport,
+    draggingNodeId: (0, _vue.ref)(null),
+    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: el,
+    usePlugin: _vitest.vi.fn(),
+    removePlugin: _vitest.vi.fn(),
+    ...overrides
+  };
+}
+(0, _vitest.describe)("flow export plugin exportImage", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.mocked(screenshot.captureElement).mockClear();
+    _vitest.vi.mocked(screenshot.triggerDownload).mockClear();
+    _vitest.vi.mocked(screenshot.copyBlobToClipboard).mockClear();
+  });
+  (0, _vitest.afterEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _vitest.it)("captures viewport and triggers download by default", async () => {
+    const flow = createMockFlow();
+    const plugin = (0, _export.createExportPlugin)({
+      fileName: "chart"
+    });
+    plugin.install(flow);
+    await flow.exportImage();
+    (0, _vitest.expect)(screenshot.captureElement).toHaveBeenCalled();
+    (0, _vitest.expect)(screenshot.triggerDownload).toHaveBeenCalled();
+  });
+  (0, _vitest.it)("throws when no container is available", async () => {
+    const flow = createMockFlow({
+      $el: void 0
+    });
+    const plugin = (0, _export.createExportPlugin)();
+    plugin.install(flow);
+    await (0, _vitest.expect)(flow.exportImage()).rejects.toThrow(/No element found/);
+  });
+  (0, _vitest.it)("uses explicit HTMLElement as capture target", async () => {
+    const flow = createMockFlow({
+      $el: void 0
+    });
+    const plugin = (0, _export.createExportPlugin)();
+    plugin.install(flow);
+    const box = document.createElement("div");
+    await flow.exportImage(box);
+    (0, _vitest.expect)(screenshot.captureElement).toHaveBeenCalledWith(box, _vitest.expect.objectContaining({
+      imageType: "png",
+      pixelRatio: 2
+    }));
+  });
+  (0, _vitest.it)("skips download when download: false", async () => {
+    const flow = createMockFlow();
+    const plugin = (0, _export.createExportPlugin)();
+    plugin.install(flow);
+    await flow.exportImage({
+      download: false
+    });
+    (0, _vitest.expect)(screenshot.triggerDownload).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("copies to clipboard when copyToClipboard is true", async () => {
+    const flow = createMockFlow();
+    const plugin = (0, _export.createExportPlugin)();
+    plugin.install(flow);
+    await flow.exportImage({
+      copyToClipboard: true
+    });
+    (0, _vitest.expect)(screenshot.copyBlobToClipboard).toHaveBeenCalled();
+  });
+  (0, _vitest.it)("uses full mode with fitView and restores viewport", async () => {
+    const vp = {
+      x: 1,
+      y: 2,
+      zoom: 1.5
+    };
+    const flow = createMockFlow({
+      getViewport: _vitest.vi.fn(() => vp),
+      fitView: _vitest.vi.fn()
+    });
+    const plugin = (0, _export.createExportPlugin)();
+    plugin.install(flow);
+    await flow.exportImage({
+      mode: "full",
+      fullModePadding: 12
+    });
+    (0, _vitest.expect)(flow.fitView).toHaveBeenCalledWith({
+      padding: 12
+    });
+    (0, _vitest.expect)(flow.setViewport).toHaveBeenCalledWith(vp);
+  });
+});

package/dist/__tests__/export-image-plugin.test.d.ts

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

package/dist/__tests__/export-image-plugin.test.mjs

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { ref } from "vue";
+import { createExportPlugin } from "../plugins/plugins/export.mjs";
+import * as screenshot from "../utils/screenshot.mjs";
+vi.mock("../utils/screenshot", () => ({
+  captureElement: vi.fn().mockResolvedValue({
+    dataUrl: "data:image/png;base64,xx",
+    blob: new Blob(),
+    extension: "png"
+  }),
+  triggerDownload: vi.fn(),
+  copyBlobToClipboard: vi.fn().mockResolvedValue(void 0)
+}));
+function createMockFlow(overrides = {}) {
+  const nodes = ref([]);
+  const edges = ref([]);
+  const viewport = ref({ x: 0, y: 0, zoom: 1 });
+  const el = document.createElement("div");
+  return {
+    nodes,
+    edges,
+    viewport,
+    draggingNodeId: ref(null),
+    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: el,
+    usePlugin: vi.fn(),
+    removePlugin: vi.fn(),
+    ...overrides
+  };
+}
+describe("flow export plugin exportImage", () => {
+  beforeEach(() => {
+    vi.mocked(screenshot.captureElement).mockClear();
+    vi.mocked(screenshot.triggerDownload).mockClear();
+    vi.mocked(screenshot.copyBlobToClipboard).mockClear();
+  });
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+  it("captures viewport and triggers download by default", async () => {
+    const flow = createMockFlow();
+    const plugin = createExportPlugin({ fileName: "chart" });
+    plugin.install(flow);
+    await flow.exportImage();
+    expect(screenshot.captureElement).toHaveBeenCalled();
+    expect(screenshot.triggerDownload).toHaveBeenCalled();
+  });
+  it("throws when no container is available", async () => {
+    const flow = createMockFlow({ $el: void 0 });
+    const plugin = createExportPlugin();
+    plugin.install(flow);
+    await expect(flow.exportImage()).rejects.toThrow(/No element found/);
+  });
+  it("uses explicit HTMLElement as capture target", async () => {
+    const flow = createMockFlow({ $el: void 0 });
+    const plugin = createExportPlugin();
+    plugin.install(flow);
+    const box = document.createElement("div");
+    await flow.exportImage(box);
+    expect(screenshot.captureElement).toHaveBeenCalledWith(
+      box,
+      expect.objectContaining({
+        imageType: "png",
+        pixelRatio: 2
+      })
+    );
+  });
+  it("skips download when download: false", async () => {
+    const flow = createMockFlow();
+    const plugin = createExportPlugin();
+    plugin.install(flow);
+    await flow.exportImage({ download: false });
+    expect(screenshot.triggerDownload).not.toHaveBeenCalled();
+  });
+  it("copies to clipboard when copyToClipboard is true", async () => {
+    const flow = createMockFlow();
+    const plugin = createExportPlugin();
+    plugin.install(flow);
+    await flow.exportImage({ copyToClipboard: true });
+    expect(screenshot.copyBlobToClipboard).toHaveBeenCalled();
+  });
+  it("uses full mode with fitView and restores viewport", async () => {
+    const vp = { x: 1, y: 2, zoom: 1.5 };
+    const flow = createMockFlow({
+      getViewport: vi.fn(() => vp),
+      fitView: vi.fn()
+    });
+    const plugin = createExportPlugin();
+    plugin.install(flow);
+    await flow.exportImage({ mode: "full", fullModePadding: 12 });
+    expect(flow.fitView).toHaveBeenCalledWith({ padding: 12 });
+    expect(flow.setViewport).toHaveBeenCalledWith(vp);
+  });
+});

package/dist/__tests__/export.test.cjs

@@ -0,0 +1,237 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _vue = require("vue");
+var _export = require("../plugins/plugins/export.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/export", () => {
+  let consoleLogSpy;
+  (0, _vitest.beforeEach)(() => {
+    consoleLogSpy = _vitest.vi.spyOn(console, "log").mockImplementation(() => {});
+    _vitest.vi.useFakeTimers({
+      shouldAdvanceTime: false
+    });
+  });
+  (0, _vitest.afterEach)(() => {
+    consoleLogSpy.mockRestore();
+    _vitest.vi.useRealTimers();
+  });
+  (0, _vitest.describe)("createExportPlugin", () => {
+    (0, _vitest.it)("should create plugin with correct id and name", () => {
+      const plugin = (0, _export.createExportPlugin)();
+      (0, _vitest.expect)(plugin.id).toBe("export");
+      (0, _vitest.expect)(plugin.name).toBe("Export");
+    });
+    (0, _vitest.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 = (0, _export.createExportPlugin)();
+      plugin.install(flow);
+      (0, _vitest.expect)(typeof flow.exportJson).toBe("function");
+    });
+    (0, _vitest.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 = (0, _export.createExportPlugin)();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      const parsed = JSON.parse(json);
+      (0, _vitest.expect)(parsed.nodes).toHaveLength(1);
+      (0, _vitest.expect)(parsed.edges).toHaveLength(1);
+      (0, _vitest.expect)(parsed.nodes[0].id).toBe("n1");
+    });
+    (0, _vitest.it)("should exportJson with formatted output", () => {
+      const flow = createMockFlowInstance();
+      flow.nodes.value = [];
+      flow.edges.value = [];
+      const plugin = (0, _export.createExportPlugin)();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      (0, _vitest.expect)(json).toContain("\n");
+    });
+    (0, _vitest.it)("should include viewport in exportJson", () => {
+      const flow = createMockFlowInstance();
+      flow.viewport.value = {
+        x: 50,
+        y: 100,
+        zoom: 1.5
+      };
+      const plugin = (0, _export.createExportPlugin)();
+      plugin.install(flow);
+      const json = flow.exportJson();
+      const parsed = JSON.parse(json);
+      (0, _vitest.expect)(parsed.viewport).toEqual({
+        x: 50,
+        y: 100,
+        zoom: 1.5
+      });
+    });
+    (0, _vitest.it)("should support custom fileName option", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        fileName: "custom-flow-name"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+    (0, _vitest.it)("should support different image types", () => {
+      const pluginPng = (0, _export.createExportPlugin)({
+        imageType: "png"
+      });
+      const pluginJpeg = (0, _export.createExportPlugin)({
+        imageType: "jpeg"
+      });
+      const pluginWebp = (0, _export.createExportPlugin)({
+        imageType: "webp"
+      });
+      (0, _vitest.expect)(pluginPng.id).toBe("export");
+      (0, _vitest.expect)(pluginJpeg.id).toBe("export");
+      (0, _vitest.expect)(pluginWebp.id).toBe("export");
+    });
+    (0, _vitest.it)("should support custom imageQuality", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        imageQuality: 0.8
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+    (0, _vitest.it)("should support custom pixelRatio", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        pixelRatio: 3
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+    (0, _vitest.it)("should support custom backgroundColor", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        backgroundColor: "#f0f0f0"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+    (0, _vitest.it)("should support exportImage disabled", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        exportImage: false
+      });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.exportImage).toBeUndefined();
+    });
+    (0, _vitest.it)("should support exportJson disabled", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        exportJson: false
+      });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.exportJson).toBeUndefined();
+    });
+    (0, _vitest.it)("should not install when enabled is false", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        enabled: false
+      });
+      const flow = createMockFlowInstance();
+      plugin.install(flow);
+      (0, _vitest.expect)(flow.exportJson).toBeUndefined();
+      (0, _vitest.expect)(flow.exportImage).toBeUndefined();
+    });
+    (0, _vitest.it)("should merge default options with provided options", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        fileName: "test",
+        imageType: "jpeg"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+      (0, _vitest.expect)(plugin.name).toBe("Export");
+    });
+  });
+  (0, _vitest.describe)("ExportPluginOptions interface", () => {
+    (0, _vitest.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 = (0, _export.createExportPlugin)(options);
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+    (0, _vitest.it)("should accept partial options", () => {
+      const plugin = (0, _export.createExportPlugin)({
+        fileName: "partial"
+      });
+      (0, _vitest.expect)(plugin.id).toBe("export");
+    });
+  });
+});

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

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