@yh-ui/flow 0.1.21

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

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

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

@@ -0,0 +1,109 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _customTypes = require("../utils/custom-types.cjs");
+var _aiWorkflow = require("../components/nodes/ai-workflow/index.cjs");
+(0, _vitest.describe)("flow/components/nodes/ai-workflow", () => {
+  (0, _vitest.beforeEach)(() => {
+    (0, _customTypes.clearCustomTypes)();
+  });
+  (0, _vitest.describe)("AI Workflow Node Types", () => {
+    (0, _vitest.it)("should have correct AI workflow node type constants", () => {
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.LLM).toBe("ai-llm");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Prompt).toBe("ai-prompt");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Agent).toBe("ai-agent");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Tool).toBe("ai-tool");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Condition).toBe("ai-condition");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Start).toBe("ai-start");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.End).toBe("ai-end");
+      (0, _vitest.expect)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Memory).toBe("ai-memory");
+    });
+    (0, _vitest.it)("should have 8 AI workflow node types", () => {
+      const types = Object.values(_aiWorkflow.AI_WORKFLOW_NODE_TYPES);
+      (0, _vitest.expect)(types).toHaveLength(8);
+    });
+  });
+  (0, _vitest.describe)("AI Workflow Node Registration", () => {
+    (0, _vitest.it)("should register all AI workflow node types", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const allNodes = (0, _customTypes.getAllCustomNodes)();
+      (0, _vitest.expect)(allNodes).toHaveLength(8);
+    });
+    (0, _vitest.it)("should register LLM node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.LLM);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.LLM);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Prompt node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Prompt);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Prompt);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Agent node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Agent);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Agent);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Tool node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Tool);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Tool);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Condition node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Condition);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Condition);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Start node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Start);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Start);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register End node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.End);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.End);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should register Memory node", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const node = (0, _customTypes.getCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Memory);
+      (0, _vitest.expect)(node).toBeDefined();
+      (0, _vitest.expect)(node?.type).toBe(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Memory);
+      (0, _vitest.expect)(node?.component).toBeDefined();
+    });
+    (0, _vitest.it)("should check if AI workflow nodes are registered", () => {
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.LLM)).toBe(false);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Prompt)).toBe(false);
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.LLM)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Prompt)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Agent)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Tool)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Condition)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Start)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.End)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNode)(_aiWorkflow.AI_WORKFLOW_NODE_TYPES.Memory)).toBe(true);
+    });
+    (0, _vitest.it)("should not duplicate nodes on re-registration", () => {
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const firstCount = (0, _customTypes.getAllCustomNodes)().length;
+      (0, _aiWorkflow.registerAiWorkflowNodes)();
+      const secondCount = (0, _customTypes.getAllCustomNodes)().length;
+      (0, _vitest.expect)(firstCount).toBe(secondCount);
+    });
+  });
+});

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

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

package/dist/__tests__/ai-workflow.test.mjs

@@ -0,0 +1,112 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  clearCustomTypes,
+  getCustomNode,
+  getAllCustomNodes,
+  hasCustomNode
+} from "../utils/custom-types.mjs";
+import { registerAiWorkflowNodes, AI_WORKFLOW_NODE_TYPES } from "../components/nodes/ai-workflow/index.mjs";
+describe("flow/components/nodes/ai-workflow", () => {
+  beforeEach(() => {
+    clearCustomTypes();
+  });
+  describe("AI Workflow Node Types", () => {
+    it("should have correct AI workflow node type constants", () => {
+      expect(AI_WORKFLOW_NODE_TYPES.LLM).toBe("ai-llm");
+      expect(AI_WORKFLOW_NODE_TYPES.Prompt).toBe("ai-prompt");
+      expect(AI_WORKFLOW_NODE_TYPES.Agent).toBe("ai-agent");
+      expect(AI_WORKFLOW_NODE_TYPES.Tool).toBe("ai-tool");
+      expect(AI_WORKFLOW_NODE_TYPES.Condition).toBe("ai-condition");
+      expect(AI_WORKFLOW_NODE_TYPES.Start).toBe("ai-start");
+      expect(AI_WORKFLOW_NODE_TYPES.End).toBe("ai-end");
+      expect(AI_WORKFLOW_NODE_TYPES.Memory).toBe("ai-memory");
+    });
+    it("should have 8 AI workflow node types", () => {
+      const types = Object.values(AI_WORKFLOW_NODE_TYPES);
+      expect(types).toHaveLength(8);
+    });
+  });
+  describe("AI Workflow Node Registration", () => {
+    it("should register all AI workflow node types", () => {
+      registerAiWorkflowNodes();
+      const allNodes = getAllCustomNodes();
+      expect(allNodes).toHaveLength(8);
+    });
+    it("should register LLM node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.LLM);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.LLM);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Prompt node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Prompt);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Prompt);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Agent node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Agent);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Agent);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Tool node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Tool);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Tool);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Condition node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Condition);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Condition);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Start node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Start);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Start);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register End node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.End);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.End);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register Memory node", () => {
+      registerAiWorkflowNodes();
+      const node = getCustomNode(AI_WORKFLOW_NODE_TYPES.Memory);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(AI_WORKFLOW_NODE_TYPES.Memory);
+      expect(node?.component).toBeDefined();
+    });
+    it("should check if AI workflow nodes are registered", () => {
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.LLM)).toBe(false);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Prompt)).toBe(false);
+      registerAiWorkflowNodes();
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.LLM)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Prompt)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Agent)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Tool)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Condition)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Start)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.End)).toBe(true);
+      expect(hasCustomNode(AI_WORKFLOW_NODE_TYPES.Memory)).toBe(true);
+    });
+    it("should not duplicate nodes on re-registration", () => {
+      registerAiWorkflowNodes();
+      const firstCount = getAllCustomNodes().length;
+      registerAiWorkflowNodes();
+      const secondCount = getAllCustomNodes().length;
+      expect(firstCount).toBe(secondCount);
+    });
+  });
+});