@yh-ui/flow 0.1.21

package/dist/Flow.vue.d.ts

@@ -0,0 +1,306 @@
+declare global {
+    interface Window {
+        __YH_FLOW_VERSION__?: string;
+    }
+}
+import type { Node, Edge, ViewportTransform, Connection, FitViewOptions, FlowEventKey, FlowEventHandler, FlowEvents, NodeTypes, EdgeTypes } from './types';
+import type { FlowPlugin } from './plugins/plugin';
+type __VLS_Props = {
+    nodes?: Node[];
+    edges?: Edge[];
+    modelValue?: ViewportTransform;
+    minZoom?: number;
+    maxZoom?: number;
+    zoomStep?: number;
+    nodesDraggable?: boolean;
+    edgesConnectable?: boolean;
+    selectable?: boolean;
+    background?: 'none' | 'dots' | 'grid';
+    backgroundColor?: string;
+    gridSize?: number;
+    snapToGrid?: boolean;
+    snapGrid?: [number, number];
+    readonly?: boolean;
+    showControls?: boolean;
+    showMinimap?: boolean;
+    minimapNodeColor?: string;
+    history?: boolean;
+    maxHistory?: number;
+    keyboardShortcuts?: boolean;
+    connectionValidator?: (connection: {
+        source: string;
+        target: string;
+        sourceHandle?: string | null;
+        targetHandle?: string | null;
+    }) => boolean;
+    noCycleValidation?: boolean;
+    showAlignmentLines?: boolean;
+    snapThreshold?: number;
+    /** Custom node templates for quick node creation */
+    customNodeTemplates?: Record<string, {
+        type: string;
+        defaultData?: Record<string, unknown>;
+        defaultWidth?: number;
+        defaultHeight?: number;
+    }>;
+    /** Node types map for rendering */
+    nodeTypes?: NodeTypes;
+    /** Edge types map for rendering */
+    edgeTypes?: EdgeTypes;
+    /** Enable interactive minimap (click to navigate) */
+    interactiveMinimap?: boolean;
+    /** Show layout controls in minimap */
+    showLayoutControls?: boolean;
+    /** Current layout type */
+    layoutType?: 'dagre' | 'elk' | 'force' | 'grid' | 'none';
+    /** Layout direction for auto-layout */
+    layoutDirection?: 'TB' | 'BT' | 'LR' | 'RL';
+    /** Enable export functionality */
+    enableExport?: boolean;
+    /** Export file name prefix */
+    exportFileName?: string;
+};
+declare var __VLS_15: any, __VLS_38: any;
+type __VLS_Slots = {} & {
+    edge?: (props: typeof __VLS_15) => any;
+} & {
+    node?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    nodes: import("vue").Ref<Node[]>;
+    edges: import("vue").Ref<Edge[]>;
+    viewport: import("vue").Ref<ViewportTransform>;
+    addNode: (node: Node) => void;
+    removeNode: (nodeId: string) => void;
+    updateNode: (nodeId: string, data: Partial<Node>) => void;
+    getNode: (nodeId: string) => Node | undefined;
+    addEdge: (edge: Edge) => void;
+    removeEdge: (edgeId: string) => void;
+    updateEdge: (edgeId: string, data: Partial<Edge>) => void;
+    getEdge: (edgeId: string) => Edge | undefined;
+    setViewport: (transform: ViewportTransform) => void;
+    fitView: (options?: FitViewOptions) => void;
+    zoomIn: (factor?: number) => void;
+    zoomOut: (factor?: number) => void;
+    centerView: () => void;
+    selectNode: (nodeId: string, selected?: boolean, multi?: boolean) => void;
+    selectEdge: (edgeId: string, selected?: boolean, multi?: boolean) => void;
+    clearSelection: () => void;
+    getNodes: () => Node[];
+    getEdges: () => Edge[];
+    getViewport: () => ViewportTransform;
+    screenToCanvas: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    canvasToScreen: (x: number, y: number) => {
+        x: number;
+        y: number;
+    };
+    on: <K extends FlowEventKey>(event: K, handler: FlowEventHandler<K>) => void;
+    off: <K extends FlowEventKey>(event: K, handler: FlowEventHandler<K>) => void;
+    emit: <K extends FlowEventKey>(event: K, payload?: FlowEvents[K]) => void;
+    isValidConnection: (connection: Connection) => boolean;
+    $el: HTMLElement | undefined;
+    draggingNodeId: import("vue").Ref<string | null>;
+    draggingPosition: import("vue").Ref<{
+        x: number;
+        y: number;
+    } | null>;
+    isLocked: import("vue").Ref<boolean>;
+    setInteractive: (interactive: boolean) => void;
+    usePlugin: (plugin: FlowPlugin) => void;
+    removePlugin: (pluginId: string) => void;
+    createNodeFromTemplate?: (type: string, id: string, position: {
+        x: number;
+        y: number;
+    }, overrides?: Record<string, unknown>) => Node | null;
+    exportFlowData?: (viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    }) => string;
+    importFlowData?: (json: string) => {
+        nodes: Node[];
+        edges: Edge[];
+        viewport?: {
+            x: number;
+            y: number;
+            zoom: number;
+        };
+    } | null;
+    isNestedNode?: (node: Node) => boolean;
+    getNodeChildren?: (node: Node) => Node[];
+    getNodeParent?: (node: Node) => Node | undefined;
+    exportJson?: () => string;
+    exportImage?: (options?: import("./types").ScreenshotOptions | HTMLElement) => Promise<import("./types").ScreenshotResult>;
+    applyLayout?: (options?: unknown) => void | Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: ViewportTransform) => any;
+    "update:nodes": (nodes: Node<import("./types").NodeData>[]) => any;
+    "update:edges": (edges: Edge<import("./types").EdgeData>[]) => any;
+    nodeClick: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any;
+    nodeDblClick: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any;
+    nodeDragStart: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any;
+    nodeDrag: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+        position: {
+            x: number;
+            y: number;
+        };
+    }) => any;
+    nodeDragEnd: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any;
+    nodeContextMenu: (event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any;
+    edgeClick: (event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any;
+    edgeDblClick: (event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any;
+    edgeContextMenu: (event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any;
+    edgeConnect: (connection: Connection) => any;
+    selectionChange: (event: {
+        selectedNodes: Node[];
+        selectedEdges: Edge[];
+    }) => any;
+    historyChange: (event: {
+        canUndo: boolean;
+        canRedo: boolean;
+    }) => any;
+    viewportChange: (transform: ViewportTransform) => any;
+    edgeUpdate: (event: {
+        edge: Edge;
+        connection: Connection;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ViewportTransform) => any) | undefined;
+    "onUpdate:nodes"?: ((nodes: Node<import("./types").NodeData>[]) => any) | undefined;
+    "onUpdate:edges"?: ((edges: Edge<import("./types").EdgeData>[]) => any) | undefined;
+    onNodeClick?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onNodeDblClick?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onNodeDragStart?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onNodeDrag?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+        position: {
+            x: number;
+            y: number;
+        };
+    }) => any) | undefined;
+    onNodeDragEnd?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onNodeContextMenu?: ((event: {
+        node: Node;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onEdgeClick?: ((event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onEdgeDblClick?: ((event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onEdgeContextMenu?: ((event: {
+        edge: Edge;
+        nativeEvent: MouseEvent;
+    }) => any) | undefined;
+    onEdgeConnect?: ((connection: Connection) => any) | undefined;
+    onSelectionChange?: ((event: {
+        selectedNodes: Node[];
+        selectedEdges: Edge[];
+    }) => any) | undefined;
+    onHistoryChange?: ((event: {
+        canUndo: boolean;
+        canRedo: boolean;
+    }) => any) | undefined;
+    onViewportChange?: ((transform: ViewportTransform) => any) | undefined;
+    onEdgeUpdate?: ((event: {
+        edge: Edge;
+        connection: Connection;
+    }) => any) | undefined;
+}>, {
+    selectable: boolean;
+    edges: Edge[];
+    nodes: Node[];
+    edgeTypes: EdgeTypes;
+    backgroundColor: string;
+    nodeTypes: NodeTypes;
+    readonly: boolean;
+    showLayoutControls: boolean;
+    layoutType: "dagre" | "elk" | "force" | "grid" | "none";
+    layoutDirection: "TB" | "BT" | "LR" | "RL";
+    snapThreshold: number;
+    snapToGrid: boolean;
+    gridSize: number;
+    showAlignmentLines: boolean;
+    maxHistory: number;
+    history: boolean;
+    minZoom: number;
+    maxZoom: number;
+    zoomStep: number;
+    snapGrid: [number, number];
+    modelValue: ViewportTransform;
+    nodesDraggable: boolean;
+    edgesConnectable: boolean;
+    background: "none" | "dots" | "grid";
+    showControls: boolean;
+    showMinimap: boolean;
+    minimapNodeColor: string;
+    keyboardShortcuts: boolean;
+    connectionValidator: (connection: {
+        source: string;
+        target: string;
+        sourceHandle?: string | null;
+        targetHandle?: string | null;
+    }) => boolean;
+    noCycleValidation: boolean;
+    customNodeTemplates: Record<string, {
+        type: string;
+        defaultData?: Record<string, unknown>;
+        defaultWidth?: number;
+        defaultHeight?: number;
+    }>;
+    interactiveMinimap: boolean;
+    enableExport: boolean;
+    exportFileName: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/__tests__/ai-workflow.ssr.test.cjs

@@ -0,0 +1,352 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _AiLlmNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiLlmNode.vue"));
+var _AiPromptNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiPromptNode.vue"));
+var _AiAgentNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiAgentNode.vue"));
+var _AiToolNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiToolNode.vue"));
+var _AiConditionNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiConditionNode.vue"));
+var _AiStartNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiStartNode.vue"));
+var _AiEndNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiEndNode.vue"));
+var _AiMemoryNode = _interopRequireDefault(require("../components/nodes/ai-workflow/AiMemoryNode.vue"));
+var _ssr = require("./utils/ssr.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _vitest.describe)("AI Workflow Nodes SSR", () => {
+  (0, _vitest.describe)("AiLlmNode", () => {
+    (0, _vitest.it)("should render LLM node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiLlmNode.default, {
+        id: "llm-1",
+        type: "ai-llm",
+        data: {
+          label: "GPT-4",
+          model: "gpt-4"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "gpt-4");
+    });
+    (0, _vitest.it)("should render with model info in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiLlmNode.default, {
+        id: "llm-1",
+        type: "ai-llm",
+        data: {
+          label: "LLM",
+          model: "gpt-4",
+          temperature: 0.7
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "gpt-4");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiLlmNode.default, {
+        id: "llm-1",
+        type: "ai-llm",
+        data: {
+          label: "GPT-4",
+          model: "gpt-4"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiPromptNode", () => {
+    (0, _vitest.it)("should render prompt node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiPromptNode.default, {
+        id: "prompt-1",
+        type: "ai-prompt",
+        data: {
+          label: "Prompt",
+          prompt: "Hello world"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u63D0\u793A\u8BCD");
+    });
+    (0, _vitest.it)("should render with prompt content in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiPromptNode.default, {
+        id: "prompt-1",
+        type: "ai-prompt",
+        data: {
+          label: "Prompt",
+          prompt: "Summarize this text"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "Summarize");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiPromptNode.default, {
+        id: "prompt-1",
+        type: "ai-prompt",
+        data: {
+          label: "Prompt",
+          prompt: "Test prompt"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiAgentNode", () => {
+    (0, _vitest.it)("should render agent node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiAgentNode.default, {
+        id: "agent-1",
+        type: "ai-agent",
+        data: {
+          label: "Agent",
+          tools: ["tool1", "tool2"]
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "Agent");
+    });
+    (0, _vitest.it)("should render tools count in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiAgentNode.default, {
+        id: "agent-1",
+        type: "ai-agent",
+        data: {
+          label: "Agent",
+          tools: ["search", "calculator"]
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "2");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiAgentNode.default, {
+        id: "agent-1",
+        type: "ai-agent",
+        data: {
+          label: "Agent",
+          tools: ["tool1"]
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiToolNode", () => {
+    (0, _vitest.it)("should render tool node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiToolNode.default, {
+        id: "tool-1",
+        type: "ai-tool",
+        data: {
+          label: "Search Tool",
+          toolName: "search"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u5DE5\u5177");
+      (0, _ssr.expectSSRContains)(html, "search");
+    });
+    (0, _vitest.it)("should render with tool name in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiToolNode.default, {
+        id: "tool-1",
+        type: "ai-tool",
+        data: {
+          label: "Tool",
+          toolName: "calculator"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "calculator");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiToolNode.default, {
+        id: "tool-1",
+        type: "ai-tool",
+        data: {
+          label: "Search",
+          toolName: "search"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiConditionNode", () => {
+    (0, _vitest.it)("should render condition node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiConditionNode.default, {
+        id: "cond-1",
+        type: "ai-condition",
+        data: {
+          label: "Condition",
+          condition: "if"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u6761\u4EF6\u5206\u652F");
+    });
+    (0, _vitest.it)("should render with condition text in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiConditionNode.default, {
+        id: "cond-1",
+        type: "ai-condition",
+        data: {
+          label: "Check",
+          condition: "score > 60"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "score");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiConditionNode.default, {
+        id: "cond-1",
+        type: "ai-condition",
+        data: {
+          label: "Condition",
+          condition: "if"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiStartNode", () => {
+    (0, _vitest.it)("should render start node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiStartNode.default, {
+        id: "start-1",
+        type: "ai-start",
+        data: {
+          label: "Start"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u25B6");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiStartNode.default, {
+        id: "start-1",
+        type: "ai-start",
+        data: {
+          label: "Start"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiEndNode", () => {
+    (0, _vitest.it)("should render end node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiEndNode.default, {
+        id: "end-1",
+        type: "ai-end",
+        data: {
+          label: "End"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u25A0");
+    });
+    (0, _vitest.it)("should render with status in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiEndNode.default, {
+        id: "end-1",
+        type: "ai-end",
+        data: {
+          label: "End",
+          status: "success"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u25A0");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiEndNode.default, {
+        id: "end-1",
+        type: "ai-end",
+        data: {
+          label: "End"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+  (0, _vitest.describe)("AiMemoryNode", () => {
+    (0, _vitest.it)("should render memory node in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiMemoryNode.default, {
+        id: "mem-1",
+        type: "ai-memory",
+        data: {
+          label: "Memory",
+          memoryType: "buffer"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "\u8BB0\u5FC6");
+      (0, _ssr.expectSSRContains)(html, "buffer");
+    });
+    (0, _vitest.it)("should render with memory type in SSR", async () => {
+      const html = await (0, _ssr.renderSSR)(_AiMemoryNode.default, {
+        id: "mem-1",
+        type: "ai-memory",
+        data: {
+          label: "Memory",
+          memoryType: "vector"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _ssr.expectSSRContains)(html, "vector");
+    });
+    (0, _vitest.it)("should hydrate without mismatch", async () => {
+      const result = await (0, _ssr.testHydration)(_AiMemoryNode.default, {
+        id: "mem-1",
+        type: "ai-memory",
+        data: {
+          label: "Memory",
+          memoryType: "buffer"
+        },
+        selected: false,
+        dragging: false,
+        connectable: true
+      });
+      (0, _vitest.expect)(result.isMatch).toBe(true);
+    });
+  });
+});

package/dist/__tests__/ai-workflow.ssr.test.d.ts

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