@yh-ui/flow 0.1.21

package/dist/__tests__/node-handles.test.cjs

@@ -0,0 +1,340 @@
+"use strict";
+
+var _vitest = require("vitest");
+const getHandles = (node, type) => {
+  if (node.handleBounds) {
+    const handles = [];
+    if (node.handleBounds.top) handles.push(...node.handleBounds.top);
+    if (node.handleBounds.right) handles.push(...node.handleBounds.right);
+    if (node.handleBounds.bottom) handles.push(...node.handleBounds.bottom);
+    if (node.handleBounds.left) handles.push(...node.handleBounds.left);
+    return handles.filter(h => h.type === type);
+  }
+  if (node.type === "group") {
+    return [];
+  }
+  if (node.type === "input") {
+    return type === "source" ? [{
+      type: "source",
+      position: "right"
+    }] : [];
+  }
+  if (node.type === "output") {
+    return type === "target" ? [{
+      type: "target",
+      position: "left"
+    }] : [];
+  }
+  if (node.type === "bpmn-start") {
+    return type === "source" ? [{
+      type: "source",
+      position: "right"
+    }] : [];
+  }
+  if (node.type === "bpmn-end") {
+    return type === "target" ? [{
+      type: "target",
+      position: "left"
+    }] : [];
+  }
+  if (node.type === "bpmn-task" || node.type === "bpmn-service-task" || node.type === "bpmn-user-task") {
+    return [{
+      type: "target",
+      position: "left"
+    }, {
+      type: "source",
+      position: "right"
+    }].filter(h => h.type === type);
+  }
+  if (node.type === "bpmn-exclusive-gateway" || node.type === "bpmn-parallel-gateway" || node.type === "bpmn-inclusive-gateway") {
+    return [{
+      type: "target",
+      position: "left"
+    }, {
+      type: "source",
+      position: "right"
+    }, {
+      type: "target",
+      position: "top"
+    }, {
+      type: "source",
+      position: "bottom"
+    }].filter(h => h.type === type);
+  }
+  if (node.type === "ai-start") {
+    return type === "source" ? [{
+      type: "source",
+      position: "right"
+    }] : [];
+  }
+  if (node.type === "ai-end") {
+    return type === "target" ? [{
+      type: "target",
+      position: "left"
+    }] : [];
+  }
+  if (node.type === "ai-condition") {
+    return [{
+      type: "target",
+      position: "left"
+    }, {
+      type: "source",
+      position: "right"
+    },
+    // true
+    {
+      type: "source",
+      position: "bottom"
+    }
+    // false
+    ].filter(h => h.type === type);
+  }
+  if (node.type === "ai-llm" || node.type === "ai-prompt" || node.type === "ai-agent" || node.type === "ai-tool" || node.type === "ai-memory") {
+    return [{
+      type: "target",
+      position: "left"
+    }, {
+      type: "source",
+      position: "right"
+    }].filter(h => h.type === type);
+  }
+  return [{
+    type: "target",
+    position: "left"
+  }, {
+    type: "source",
+    position: "right"
+  }].filter(h => h.type === type);
+};
+(0, _vitest.describe)("flow/utils/node-handles", () => {
+  (0, _vitest.describe)("Default node handles", () => {
+    (0, _vitest.it)("should return handles for default node type", () => {
+      const node = {
+        id: "1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Test"
+        }
+      };
+      const handles = getHandles(node, "source");
+      (0, _vitest.expect)(handles).toBeDefined();
+      (0, _vitest.expect)(handles.length).toBeGreaterThan(0);
+    });
+    (0, _vitest.it)("should return source and target handles for default node", () => {
+      const node = {
+        id: "1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Test"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(1);
+      (0, _vitest.expect)(sourceHandles[0]?.position).toBe("right");
+      (0, _vitest.expect)(targetHandles.length).toBe(1);
+      (0, _vitest.expect)(targetHandles[0]?.position).toBe("left");
+    });
+  });
+  (0, _vitest.describe)("BPMN node handles", () => {
+    (0, _vitest.it)("should return source handle for bpmn-start", () => {
+      const node = {
+        id: "start1",
+        type: "bpmn-start",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Start"
+        }
+      };
+      const handles = getHandles(node, "source");
+      (0, _vitest.expect)(handles.length).toBe(1);
+      (0, _vitest.expect)(handles[0]?.position).toBe("right");
+    });
+    (0, _vitest.it)("should return target handle for bpmn-end", () => {
+      const node = {
+        id: "end1",
+        type: "bpmn-end",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "End"
+        }
+      };
+      const handles = getHandles(node, "target");
+      (0, _vitest.expect)(handles.length).toBe(1);
+      (0, _vitest.expect)(handles[0]?.position).toBe("left");
+    });
+    (0, _vitest.it)("should return both handles for bpmn-task", () => {
+      const node = {
+        id: "task1",
+        type: "bpmn-task",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Task"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(1);
+      (0, _vitest.expect)(targetHandles.length).toBe(1);
+    });
+    (0, _vitest.it)("should return 4 handles for bpmn-exclusive-gateway", () => {
+      const node = {
+        id: "gw1",
+        type: "bpmn-exclusive-gateway",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Gateway"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(2);
+      (0, _vitest.expect)(targetHandles.length).toBe(2);
+    });
+  });
+  (0, _vitest.describe)("AI Workflow node handles", () => {
+    (0, _vitest.it)("should return handles for ai-llm", () => {
+      const node = {
+        id: "llm1",
+        type: "ai-llm",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "LLM",
+          model: "gpt-4"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(1);
+      (0, _vitest.expect)(targetHandles.length).toBe(1);
+    });
+    (0, _vitest.it)("should return source handle for ai-start", () => {
+      const node = {
+        id: "start1",
+        type: "ai-start",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Start"
+        }
+      };
+      const handles = getHandles(node, "source");
+      (0, _vitest.expect)(handles.length).toBe(1);
+      (0, _vitest.expect)(handles[0]?.position).toBe("right");
+    });
+    (0, _vitest.it)("should return target handle for ai-end", () => {
+      const node = {
+        id: "end1",
+        type: "ai-end",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "End"
+        }
+      };
+      const handles = getHandles(node, "target");
+      (0, _vitest.expect)(handles.length).toBe(1);
+      (0, _vitest.expect)(handles[0]?.position).toBe("left");
+    });
+    (0, _vitest.it)("should return 3 handles for ai-condition (left target, right source, bottom source)", () => {
+      const node = {
+        id: "cond1",
+        type: "ai-condition",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Condition",
+          condition: "if"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(2);
+      (0, _vitest.expect)(targetHandles.length).toBe(1);
+    });
+  });
+  (0, _vitest.describe)("Input/Output node handles", () => {
+    (0, _vitest.it)("should return only source handle for input node", () => {
+      const node = {
+        id: "input1",
+        type: "input",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Input"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(1);
+      (0, _vitest.expect)(targetHandles.length).toBe(0);
+    });
+    (0, _vitest.it)("should return only target handle for output node", () => {
+      const node = {
+        id: "output1",
+        type: "output",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Output"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(0);
+      (0, _vitest.expect)(targetHandles.length).toBe(1);
+    });
+  });
+  (0, _vitest.describe)("Group node handles", () => {
+    (0, _vitest.it)("should return empty array for group node", () => {
+      const node = {
+        id: "group1",
+        type: "group",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {
+          label: "Group"
+        }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      (0, _vitest.expect)(sourceHandles.length).toBe(0);
+      (0, _vitest.expect)(targetHandles.length).toBe(0);
+    });
+  });
+});

package/dist/__tests__/node-handles.test.d.ts

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

package/dist/__tests__/node-handles.test.mjs

@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+const getHandles = (node, type) => {
+  if (node.handleBounds) {
+    const handles = [];
+    if (node.handleBounds.top) handles.push(...node.handleBounds.top);
+    if (node.handleBounds.right) handles.push(...node.handleBounds.right);
+    if (node.handleBounds.bottom) handles.push(...node.handleBounds.bottom);
+    if (node.handleBounds.left) handles.push(...node.handleBounds.left);
+    return handles.filter((h) => h.type === type);
+  }
+  if (node.type === "group") {
+    return [];
+  }
+  if (node.type === "input") {
+    return type === "source" ? [{ type: "source", position: "right" }] : [];
+  }
+  if (node.type === "output") {
+    return type === "target" ? [{ type: "target", position: "left" }] : [];
+  }
+  if (node.type === "bpmn-start") {
+    return type === "source" ? [{ type: "source", position: "right" }] : [];
+  }
+  if (node.type === "bpmn-end") {
+    return type === "target" ? [{ type: "target", position: "left" }] : [];
+  }
+  if (node.type === "bpmn-task" || node.type === "bpmn-service-task" || node.type === "bpmn-user-task") {
+    return [
+      { type: "target", position: "left" },
+      { type: "source", position: "right" }
+    ].filter((h) => h.type === type);
+  }
+  if (node.type === "bpmn-exclusive-gateway" || node.type === "bpmn-parallel-gateway" || node.type === "bpmn-inclusive-gateway") {
+    return [
+      { type: "target", position: "left" },
+      { type: "source", position: "right" },
+      { type: "target", position: "top" },
+      { type: "source", position: "bottom" }
+    ].filter((h) => h.type === type);
+  }
+  if (node.type === "ai-start") {
+    return type === "source" ? [{ type: "source", position: "right" }] : [];
+  }
+  if (node.type === "ai-end") {
+    return type === "target" ? [{ type: "target", position: "left" }] : [];
+  }
+  if (node.type === "ai-condition") {
+    return [
+      { type: "target", position: "left" },
+      { type: "source", position: "right" },
+      // true
+      { type: "source", position: "bottom" }
+      // false
+    ].filter((h) => h.type === type);
+  }
+  if (node.type === "ai-llm" || node.type === "ai-prompt" || node.type === "ai-agent" || node.type === "ai-tool" || node.type === "ai-memory") {
+    return [
+      { type: "target", position: "left" },
+      { type: "source", position: "right" }
+    ].filter((h) => h.type === type);
+  }
+  return [
+    { type: "target", position: "left" },
+    { type: "source", position: "right" }
+  ].filter((h) => h.type === type);
+};
+describe("flow/utils/node-handles", () => {
+  describe("Default node handles", () => {
+    it("should return handles for default node type", () => {
+      const node = {
+        id: "1",
+        type: "default",
+        position: { x: 0, y: 0 },
+        data: { label: "Test" }
+      };
+      const handles = getHandles(node, "source");
+      expect(handles).toBeDefined();
+      expect(handles.length).toBeGreaterThan(0);
+    });
+    it("should return source and target handles for default node", () => {
+      const node = {
+        id: "1",
+        type: "default",
+        position: { x: 0, y: 0 },
+        data: { label: "Test" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(1);
+      expect(sourceHandles[0]?.position).toBe("right");
+      expect(targetHandles.length).toBe(1);
+      expect(targetHandles[0]?.position).toBe("left");
+    });
+  });
+  describe("BPMN node handles", () => {
+    it("should return source handle for bpmn-start", () => {
+      const node = {
+        id: "start1",
+        type: "bpmn-start",
+        position: { x: 0, y: 0 },
+        data: { label: "Start" }
+      };
+      const handles = getHandles(node, "source");
+      expect(handles.length).toBe(1);
+      expect(handles[0]?.position).toBe("right");
+    });
+    it("should return target handle for bpmn-end", () => {
+      const node = {
+        id: "end1",
+        type: "bpmn-end",
+        position: { x: 0, y: 0 },
+        data: { label: "End" }
+      };
+      const handles = getHandles(node, "target");
+      expect(handles.length).toBe(1);
+      expect(handles[0]?.position).toBe("left");
+    });
+    it("should return both handles for bpmn-task", () => {
+      const node = {
+        id: "task1",
+        type: "bpmn-task",
+        position: { x: 0, y: 0 },
+        data: { label: "Task" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(1);
+      expect(targetHandles.length).toBe(1);
+    });
+    it("should return 4 handles for bpmn-exclusive-gateway", () => {
+      const node = {
+        id: "gw1",
+        type: "bpmn-exclusive-gateway",
+        position: { x: 0, y: 0 },
+        data: { label: "Gateway" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(2);
+      expect(targetHandles.length).toBe(2);
+    });
+  });
+  describe("AI Workflow node handles", () => {
+    it("should return handles for ai-llm", () => {
+      const node = {
+        id: "llm1",
+        type: "ai-llm",
+        position: { x: 0, y: 0 },
+        data: { label: "LLM", model: "gpt-4" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(1);
+      expect(targetHandles.length).toBe(1);
+    });
+    it("should return source handle for ai-start", () => {
+      const node = {
+        id: "start1",
+        type: "ai-start",
+        position: { x: 0, y: 0 },
+        data: { label: "Start" }
+      };
+      const handles = getHandles(node, "source");
+      expect(handles.length).toBe(1);
+      expect(handles[0]?.position).toBe("right");
+    });
+    it("should return target handle for ai-end", () => {
+      const node = {
+        id: "end1",
+        type: "ai-end",
+        position: { x: 0, y: 0 },
+        data: { label: "End" }
+      };
+      const handles = getHandles(node, "target");
+      expect(handles.length).toBe(1);
+      expect(handles[0]?.position).toBe("left");
+    });
+    it("should return 3 handles for ai-condition (left target, right source, bottom source)", () => {
+      const node = {
+        id: "cond1",
+        type: "ai-condition",
+        position: { x: 0, y: 0 },
+        data: { label: "Condition", condition: "if" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(2);
+      expect(targetHandles.length).toBe(1);
+    });
+  });
+  describe("Input/Output node handles", () => {
+    it("should return only source handle for input node", () => {
+      const node = {
+        id: "input1",
+        type: "input",
+        position: { x: 0, y: 0 },
+        data: { label: "Input" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(1);
+      expect(targetHandles.length).toBe(0);
+    });
+    it("should return only target handle for output node", () => {
+      const node = {
+        id: "output1",
+        type: "output",
+        position: { x: 0, y: 0 },
+        data: { label: "Output" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(0);
+      expect(targetHandles.length).toBe(1);
+    });
+  });
+  describe("Group node handles", () => {
+    it("should return empty array for group node", () => {
+      const node = {
+        id: "group1",
+        type: "group",
+        position: { x: 0, y: 0 },
+        data: { label: "Group" }
+      };
+      const sourceHandles = getHandles(node, "source");
+      const targetHandles = getHandles(node, "target");
+      expect(sourceHandles.length).toBe(0);
+      expect(targetHandles.length).toBe(0);
+    });
+  });
+});