@yh-ui/flow 1.0.25 → 1.0.30

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

@@ -1,230 +0,0 @@
-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);
-    });
-  });
-});

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

@@ -1,368 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _node = require("../types/node.cjs");
-(0, _vitest.describe)("flow/types/node", () => {
-  (0, _vitest.describe)("NodeHandle", () => {
-    (0, _vitest.it)("should define handle with type and position", () => {
-      const handle = {
-        type: "source",
-        position: "right"
-      };
-      (0, _vitest.expect)(handle.type).toBe("source");
-      (0, _vitest.expect)(handle.position).toBe("right");
-    });
-    (0, _vitest.it)("should support optional properties", () => {
-      const handle = {
-        type: "target",
-        position: "left",
-        id: "handle-1",
-        style: {
-          background: "#fff"
-        },
-        class: "custom-handle",
-        isConnectable: true
-      };
-      (0, _vitest.expect)(handle.id).toBe("handle-1");
-      (0, _vitest.expect)(handle.class).toBe("custom-handle");
-      (0, _vitest.expect)(handle.isConnectable).toBe(true);
-    });
-  });
-  (0, _vitest.describe)("NodeStyle", () => {
-    (0, _vitest.it)("should allow CSS-like properties", () => {
-      const style = {
-        background: "#f0f0f0",
-        border: "1px solid #ccc",
-        width: 200
-      };
-      (0, _vitest.expect)(style.background).toBe("#f0f0f0");
-      (0, _vitest.expect)(style.width).toBe(200);
-    });
-    (0, _vitest.it)("should support undefined values", () => {
-      const style = {
-        background: "#fff",
-        border: void 0
-      };
-      (0, _vitest.expect)(style.border).toBeUndefined();
-    });
-  });
-  (0, _vitest.describe)("NodeData", () => {
-    (0, _vitest.it)("should define basic node data", () => {
-      const data = {
-        label: "Test Node"
-      };
-      (0, _vitest.expect)(data.label).toBe("Test Node");
-    });
-    (0, _vitest.it)("should support extended data fields", () => {
-      const data = {
-        label: "AI Node",
-        style: {
-          background: "#e0f7fa"
-        },
-        class: "ai-node",
-        icon: "robot",
-        description: "An AI processing node"
-      };
-      (0, _vitest.expect)(data.icon).toBe("robot");
-      (0, _vitest.expect)(data.description).toBe("An AI processing node");
-    });
-    (0, _vitest.it)("should support AI workflow specific fields", () => {
-      const data = {
-        label: "LLM Node",
-        model: "gpt-4",
-        prompt: "You are a helpful assistant",
-        temperature: 0.7,
-        maxTokens: 2e3,
-        tools: ["search", "calculator"],
-        toolName: "web_search",
-        condition: 'status == "success"',
-        memoryType: "vector",
-        status: "running",
-        streamOutput: "partial"
-      };
-      (0, _vitest.expect)(data.model).toBe("gpt-4");
-      (0, _vitest.expect)(data.temperature).toBe(0.7);
-      (0, _vitest.expect)(data.status).toBe("running");
-    });
-  });
-  (0, _vitest.describe)("NodePosition", () => {
-    (0, _vitest.it)("should define position with x and y", () => {
-      const pos = {
-        x: 100,
-        y: 200
-      };
-      (0, _vitest.expect)(pos.x).toBe(100);
-      (0, _vitest.expect)(pos.y).toBe(200);
-    });
-    (0, _vitest.it)("should support negative coordinates", () => {
-      const pos = {
-        x: -50,
-        y: -100
-      };
-      (0, _vitest.expect)(pos.x).toBe(-50);
-      (0, _vitest.expect)(pos.y).toBe(-100);
-    });
-  });
-  (0, _vitest.describe)("NodeDimension", () => {
-    (0, _vitest.it)("should define width and height", () => {
-      const dim = {
-        width: 150,
-        height: 80
-      };
-      (0, _vitest.expect)(dim.width).toBe(150);
-      (0, _vitest.expect)(dim.height).toBe(80);
-    });
-  });
-  (0, _vitest.describe)("NodeHandleBounds", () => {
-    (0, _vitest.it)("should define handle bounds", () => {
-      const bounds = {
-        top: [{
-          type: "source",
-          position: "top"
-        }],
-        right: [{
-          type: "target",
-          position: "right"
-        }]
-      };
-      (0, _vitest.expect)(bounds.top).toHaveLength(1);
-      (0, _vitest.expect)(bounds.right).toHaveLength(1);
-    });
-  });
-  (0, _vitest.describe)("Node", () => {
-    (0, _vitest.it)("should create basic node", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {
-          label: "Basic Node"
-        }
-      };
-      (0, _vitest.expect)(node.id).toBe("node-1");
-      (0, _vitest.expect)(node.type).toBe("default");
-    });
-    (0, _vitest.it)("should support all optional properties", () => {
-      const node = {
-        id: "node-1",
-        type: "custom",
-        position: {
-          x: 100,
-          y: 200
-        },
-        data: {
-          label: "Test"
-        },
-        style: {
-          background: "#fff"
-        },
-        class: "custom-node",
-        draggable: true,
-        selectable: true,
-        connectable: true,
-        resizable: true,
-        deletable: true,
-        hidden: false,
-        selected: false,
-        dragging: false,
-        width: 200,
-        height: 100,
-        parentId: "parent-1",
-        zIndex: 1,
-        extent: "parent",
-        expandParent: true,
-        positionAbsolute: {
-          x: 150,
-          y: 250
-        },
-        handleBounds: {
-          top: [{
-            type: "source",
-            position: "top"
-          }],
-          right: [{
-            type: "target",
-            position: "right"
-          }]
-        }
-      };
-      (0, _vitest.expect)(node.draggable).toBe(true);
-      (0, _vitest.expect)(node.width).toBe(200);
-      (0, _vitest.expect)(node.parentId).toBe("parent-1");
-    });
-    (0, _vitest.it)("should support nested children", () => {
-      const node = {
-        id: "parent",
-        type: "group",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {
-          label: "Parent"
-        },
-        children: ["child-1", "child-2"],
-        computed: true
-      };
-      (0, _vitest.expect)(node.children).toEqual(["child-1", "child-2"]);
-      (0, _vitest.expect)(node.computed).toBe(true);
-    });
-  });
-  (0, _vitest.describe)("NodeChangeType", () => {
-    (0, _vitest.it)("should define all change types", () => {
-      const types = ["select", "position", "remove", "dimensions", "style", "data", "selectMulti", "unselect"];
-      (0, _vitest.expect)(types).toContain("select");
-      (0, _vitest.expect)(types).toContain("position");
-      (0, _vitest.expect)(types).toContain("remove");
-    });
-  });
-  (0, _vitest.describe)("NodeChange", () => {
-    (0, _vitest.it)("should create select change", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      };
-      const change = {
-        type: "select",
-        id: "node-1",
-        item: node,
-        selected: true
-      };
-      (0, _vitest.expect)(change.type).toBe("select");
-      (0, _vitest.expect)(change.selected).toBe(true);
-    });
-    (0, _vitest.it)("should create position change", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      };
-      const change = {
-        type: "position",
-        id: "node-1",
-        item: node,
-        position: {
-          x: 100,
-          y: 200
-        }
-      };
-      (0, _vitest.expect)(change.position?.x).toBe(100);
-      (0, _vitest.expect)(change.position?.y).toBe(200);
-    });
-    (0, _vitest.it)("should create dimensions change", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      };
-      const change = {
-        type: "dimensions",
-        id: "node-1",
-        item: node,
-        dimensions: {
-          width: 200,
-          height: 100
-        }
-      };
-      (0, _vitest.expect)(change.dimensions?.width).toBe(200);
-    });
-    (0, _vitest.it)("should create drag change", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      };
-      const change = {
-        type: "position",
-        id: "node-1",
-        item: node,
-        drag: true
-      };
-      (0, _vitest.expect)(change.drag).toBe(true);
-    });
-  });
-  (0, _vitest.describe)("isNode", () => {
-    (0, _vitest.it)("should return true for valid node objects", () => {
-      const node = {
-        id: "node-1",
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      };
-      (0, _vitest.expect)((0, _node.isNode)(node)).toBe(true);
-    });
-    (0, _vitest.it)("should return true for node with extended properties", () => {
-      const node = {
-        id: "node-1",
-        type: "custom",
-        position: {
-          x: 100,
-          y: 200
-        },
-        data: {
-          label: "Test"
-        },
-        width: 200,
-        height: 100
-      };
-      (0, _vitest.expect)((0, _node.isNode)(node)).toBe(true);
-    });
-    (0, _vitest.it)("should return false for null", () => {
-      (0, _vitest.expect)((0, _node.isNode)(null)).toBe(false);
-    });
-    (0, _vitest.it)("should return false for undefined", () => {
-      (0, _vitest.expect)((0, _node.isNode)(void 0)).toBe(false);
-    });
-    (0, _vitest.it)("should return false for object missing id", () => {
-      (0, _vitest.expect)((0, _node.isNode)({
-        type: "default",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      })).toBe(false);
-    });
-    (0, _vitest.it)("should return false for object missing type", () => {
-      (0, _vitest.expect)((0, _node.isNode)({
-        id: "node-1",
-        position: {
-          x: 0,
-          y: 0
-        },
-        data: {}
-      })).toBe(false);
-    });
-    (0, _vitest.it)("should return false for primitive values", () => {
-      (0, _vitest.expect)((0, _node.isNode)("node")).toBe(false);
-      (0, _vitest.expect)((0, _node.isNode)(123)).toBe(false);
-      (0, _vitest.expect)((0, _node.isNode)(true)).toBe(false);
-    });
-    (0, _vitest.it)("should return false for arrays", () => {
-      (0, _vitest.expect)((0, _node.isNode)([])).toBe(false);
-    });
-  });
-});

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

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