@yh-ui/flow 0.1.56 → 1.0.4

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

@@ -0,0 +1,292 @@
+import { describe, it, expect } from "vitest";
+import {
+  isNode
+} from "../types/node.mjs";
+describe("flow/types/node", () => {
+  describe("NodeHandle", () => {
+    it("should define handle with type and position", () => {
+      const handle = {
+        type: "source",
+        position: "right"
+      };
+      expect(handle.type).toBe("source");
+      expect(handle.position).toBe("right");
+    });
+    it("should support optional properties", () => {
+      const handle = {
+        type: "target",
+        position: "left",
+        id: "handle-1",
+        style: { background: "#fff" },
+        class: "custom-handle",
+        isConnectable: true
+      };
+      expect(handle.id).toBe("handle-1");
+      expect(handle.class).toBe("custom-handle");
+      expect(handle.isConnectable).toBe(true);
+    });
+  });
+  describe("NodeStyle", () => {
+    it("should allow CSS-like properties", () => {
+      const style = {
+        background: "#f0f0f0",
+        border: "1px solid #ccc",
+        width: 200
+      };
+      expect(style.background).toBe("#f0f0f0");
+      expect(style.width).toBe(200);
+    });
+    it("should support undefined values", () => {
+      const style = {
+        background: "#fff",
+        border: void 0
+      };
+      expect(style.border).toBeUndefined();
+    });
+  });
+  describe("NodeData", () => {
+    it("should define basic node data", () => {
+      const data = {
+        label: "Test Node"
+      };
+      expect(data.label).toBe("Test Node");
+    });
+    it("should support extended data fields", () => {
+      const data = {
+        label: "AI Node",
+        style: { background: "#e0f7fa" },
+        class: "ai-node",
+        icon: "robot",
+        description: "An AI processing node"
+      };
+      expect(data.icon).toBe("robot");
+      expect(data.description).toBe("An AI processing node");
+    });
+    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"
+      };
+      expect(data.model).toBe("gpt-4");
+      expect(data.temperature).toBe(0.7);
+      expect(data.status).toBe("running");
+    });
+  });
+  describe("NodePosition", () => {
+    it("should define position with x and y", () => {
+      const pos = { x: 100, y: 200 };
+      expect(pos.x).toBe(100);
+      expect(pos.y).toBe(200);
+    });
+    it("should support negative coordinates", () => {
+      const pos = { x: -50, y: -100 };
+      expect(pos.x).toBe(-50);
+      expect(pos.y).toBe(-100);
+    });
+  });
+  describe("NodeDimension", () => {
+    it("should define width and height", () => {
+      const dim = { width: 150, height: 80 };
+      expect(dim.width).toBe(150);
+      expect(dim.height).toBe(80);
+    });
+  });
+  describe("NodeHandleBounds", () => {
+    it("should define handle bounds", () => {
+      const bounds = {
+        top: [{ type: "source", position: "top" }],
+        right: [{ type: "target", position: "right" }]
+      };
+      expect(bounds.top).toHaveLength(1);
+      expect(bounds.right).toHaveLength(1);
+    });
+  });
+  describe("Node", () => {
+    it("should create basic node", () => {
+      const node = {
+        id: "node-1",
+        type: "default",
+        position: { x: 0, y: 0 },
+        data: { label: "Basic Node" }
+      };
+      expect(node.id).toBe("node-1");
+      expect(node.type).toBe("default");
+    });
+    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" }]
+        }
+      };
+      expect(node.draggable).toBe(true);
+      expect(node.width).toBe(200);
+      expect(node.parentId).toBe("parent-1");
+    });
+    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
+      };
+      expect(node.children).toEqual(["child-1", "child-2"]);
+      expect(node.computed).toBe(true);
+    });
+  });
+  describe("NodeChangeType", () => {
+    it("should define all change types", () => {
+      const types = [
+        "select",
+        "position",
+        "remove",
+        "dimensions",
+        "style",
+        "data",
+        "selectMulti",
+        "unselect"
+      ];
+      expect(types).toContain("select");
+      expect(types).toContain("position");
+      expect(types).toContain("remove");
+    });
+  });
+  describe("NodeChange", () => {
+    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
+      };
+      expect(change.type).toBe("select");
+      expect(change.selected).toBe(true);
+    });
+    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 }
+      };
+      expect(change.position?.x).toBe(100);
+      expect(change.position?.y).toBe(200);
+    });
+    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 }
+      };
+      expect(change.dimensions?.width).toBe(200);
+    });
+    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
+      };
+      expect(change.drag).toBe(true);
+    });
+  });
+  describe("isNode", () => {
+    it("should return true for valid node objects", () => {
+      const node = {
+        id: "node-1",
+        type: "default",
+        position: { x: 0, y: 0 },
+        data: {}
+      };
+      expect(isNode(node)).toBe(true);
+    });
+    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
+      };
+      expect(isNode(node)).toBe(true);
+    });
+    it("should return false for null", () => {
+      expect(isNode(null)).toBe(false);
+    });
+    it("should return false for undefined", () => {
+      expect(isNode(void 0)).toBe(false);
+    });
+    it("should return false for object missing id", () => {
+      expect(isNode({ type: "default", position: { x: 0, y: 0 }, data: {} })).toBe(false);
+    });
+    it("should return false for object missing type", () => {
+      expect(isNode({ id: "node-1", position: { x: 0, y: 0 }, data: {} })).toBe(false);
+    });
+    it("should return false for primitive values", () => {
+      expect(isNode("node")).toBe(false);
+      expect(isNode(123)).toBe(false);
+      expect(isNode(true)).toBe(false);
+    });
+    it("should return false for arrays", () => {
+      expect(isNode([])).toBe(false);
+    });
+  });
+});

package/dist/__tests__/performance.test.cjs

@@ -0,0 +1,313 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _performance = require("../utils/performance.cjs");
+(0, _vitest.describe)("flow/utils/performance", () => {
+  (0, _vitest.describe)("ReactiveGraph", () => {
+    (0, _vitest.it)("should initialize with empty nodes and edges", () => {
+      const graph = new _performance.ReactiveGraph();
+      (0, _vitest.expect)(graph.nodes).toEqual([]);
+      (0, _vitest.expect)(graph.edges).toEqual([]);
+    });
+    (0, _vitest.it)("should set and get nodes", () => {
+      const graph = new _performance.ReactiveGraph();
+      const nodes = [{
+        id: "n1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {}
+      }];
+      graph.nodes = nodes;
+      (0, _vitest.expect)(graph.nodes).toBe(nodes);
+    });
+    (0, _vitest.it)("should set and get edges", () => {
+      const graph = new _performance.ReactiveGraph();
+      const edges = [{
+        id: "e1",
+        source: "n1",
+        target: "n2",
+        type: "default"
+      }];
+      graph.edges = edges;
+      (0, _vitest.expect)(graph.edges).toBe(edges);
+    });
+    (0, _vitest.it)("should get connected edges for a node", () => {
+      const graph = new _performance.ReactiveGraph();
+      graph.nodes = [{
+        id: "n1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {}
+      }, {
+        id: "n2",
+        type: "default",
+        position: {
+          x: 100,
+          y: 0
+        },
+        data: {}
+      }, {
+        id: "n3",
+        type: "default",
+        position: {
+          x: 200,
+          y: 0
+        },
+        data: {}
+      }];
+      graph.edges = [{
+        id: "e1",
+        source: "n1",
+        target: "n2",
+        type: "default"
+      }, {
+        id: "e2",
+        source: "n2",
+        target: "n3",
+        type: "default"
+      }];
+      const connectedEdges = graph.getConnectedEdges("n2");
+      (0, _vitest.expect)(connectedEdges).toHaveLength(2);
+    });
+    (0, _vitest.it)("should get connected nodes for a node", () => {
+      const graph = new _performance.ReactiveGraph();
+      graph.nodes = [{
+        id: "n1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {}
+      }, {
+        id: "n2",
+        type: "default",
+        position: {
+          x: 100,
+          y: 0
+        },
+        data: {}
+      }, {
+        id: "n3",
+        type: "default",
+        position: {
+          x: 200,
+          y: 0
+        },
+        data: {}
+      }];
+      graph.edges = [{
+        id: "e1",
+        source: "n1",
+        target: "n2",
+        type: "default"
+      }, {
+        id: "e2",
+        source: "n2",
+        target: "n3",
+        type: "default"
+      }];
+      const connectedNodes = graph.getConnectedNodes("n1");
+      (0, _vitest.expect)(connectedNodes).toHaveLength(1);
+      (0, _vitest.expect)(connectedNodes[0].id).toBe("n2");
+    });
+    (0, _vitest.it)("should return empty array for node with no connections", () => {
+      const graph = new _performance.ReactiveGraph();
+      graph.nodes = [{
+        id: "n1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {}
+      }, {
+        id: "n2",
+        type: "default",
+        position: {
+          x: 100,
+          y: 0
+        },
+        data: {}
+      }];
+      graph.edges = [];
+      const connected = graph.getConnectedNodes("n1");
+      (0, _vitest.expect)(connected).toHaveLength(0);
+    });
+    (0, _vitest.it)("should batch update nodes", () => {
+      const graph = new _performance.ReactiveGraph();
+      graph.nodes = [{
+        id: "n1",
+        type: "default",
+        position: {
+          x: 0,
+          y: 0
+        },
+        data: {}
+      }];
+      graph.batchUpdateNodes(nodes => [...nodes, {
+        id: "n2",
+        type: "default",
+        position: {
+          x: 100,
+          y: 0
+        },
+        data: {}
+      }]);
+      (0, _vitest.expect)(graph.nodes).toHaveLength(2);
+    });
+    (0, _vitest.it)("should batch update edges", () => {
+      const graph = new _performance.ReactiveGraph();
+      graph.edges = [{
+        id: "e1",
+        source: "n1",
+        target: "n2",
+        type: "default"
+      }];
+      graph.batchUpdateEdges(edges => [...edges, {
+        id: "e2",
+        source: "n2",
+        target: "n3",
+        type: "default"
+      }]);
+      (0, _vitest.expect)(graph.edges).toHaveLength(2);
+    });
+  });
+  (0, _vitest.describe)("generateId", () => {
+    (0, _vitest.it)("should generate id with default prefix", () => {
+      const id = (0, _performance.generateId)();
+      (0, _vitest.expect)(id).toMatch(/^id-\d+-\d+$/);
+    });
+    (0, _vitest.it)("should generate id with custom prefix", () => {
+      const id = (0, _performance.generateId)("node");
+      (0, _vitest.expect)(id).toMatch(/^node-\d+-\d+$/);
+    });
+    (0, _vitest.it)("should generate unique ids", () => {
+      const id1 = (0, _performance.generateId)("test");
+      const id2 = (0, _performance.generateId)("test");
+      (0, _vitest.expect)(id1).not.toBe(id2);
+    });
+  });
+  (0, _vitest.describe)("debounce", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.useFakeTimers();
+    });
+    (0, _vitest.afterEach)(() => {
+      _vitest.vi.useRealTimers();
+    });
+    (0, _vitest.it)("should debounce function calls", () => {
+      const fn = _vitest.vi.fn();
+      const debounced = (0, _performance.debounce)(fn, 100);
+      debounced("a");
+      debounced("b");
+      debounced("c");
+      (0, _vitest.expect)(fn).not.toHaveBeenCalled();
+      _vitest.vi.advanceTimersByTime(100);
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+      (0, _vitest.expect)(fn).toHaveBeenCalledWith("c");
+    });
+    (0, _vitest.it)("should pass arguments correctly", () => {
+      const fn = _vitest.vi.fn();
+      const debounced = (0, _performance.debounce)(fn, 50);
+      debounced("hello", 123);
+      _vitest.vi.advanceTimersByTime(50);
+      (0, _vitest.expect)(fn).toHaveBeenCalledWith("hello", 123);
+    });
+    (0, _vitest.it)("should only call once for multiple rapid calls", () => {
+      const fn = _vitest.vi.fn();
+      const debounced = (0, _performance.debounce)(fn, 200);
+      for (let i = 0; i < 10; i++) {
+        debounced(i);
+      }
+      _vitest.vi.advanceTimersByTime(200);
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+  (0, _vitest.describe)("throttle", () => {
+    (0, _vitest.beforeEach)(() => {
+      _vitest.vi.useFakeTimers();
+    });
+    (0, _vitest.afterEach)(() => {
+      _vitest.vi.useRealTimers();
+    });
+    (0, _vitest.it)("should throttle function calls", () => {
+      const fn = _vitest.vi.fn();
+      const throttled = (0, _performance.throttle)(fn, 100);
+      throttled("a");
+      throttled("b");
+      throttled("c");
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+      (0, _vitest.expect)(fn).toHaveBeenCalledWith("a");
+      _vitest.vi.advanceTimersByTime(50);
+      throttled("d");
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(1);
+      _vitest.vi.advanceTimersByTime(60);
+      throttled("e");
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(2);
+      (0, _vitest.expect)(fn).toHaveBeenCalledWith("e");
+    });
+    (0, _vitest.it)("should pass arguments correctly", () => {
+      const fn = _vitest.vi.fn();
+      const throttled = (0, _performance.throttle)(fn, 100);
+      throttled("test", true, 42);
+      (0, _vitest.expect)(fn).toHaveBeenCalledWith("test", true, 42);
+    });
+  });
+  (0, _vitest.describe)("memo", () => {
+    (0, _vitest.beforeEach)(() => {
+      (0, _performance.clearMemoCache)();
+    });
+    (0, _vitest.it)("should memoize function results", () => {
+      let callCount = 0;
+      const memoized = (0, _performance.memo)("key1", () => {
+        callCount++;
+        return "result";
+      });
+      const result1 = memoized;
+      const result2 = memoized;
+      (0, _vitest.expect)(callCount).toBe(1);
+      (0, _vitest.expect)(result1).toBe("result");
+      (0, _vitest.expect)(result2).toBe("result");
+    });
+    (0, _vitest.it)("should cache different keys separately", () => {
+      const fn = _vitest.vi.fn().mockImplementation(key => `result-${key}`);
+      const result1 = (0, _performance.memo)("key-a", () => fn("a"));
+      const result2 = (0, _performance.memo)("key-b", () => fn("b"));
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(2);
+      (0, _vitest.expect)(result1).toBe("result-a");
+      (0, _vitest.expect)(result2).toBe("result-b");
+    });
+    (0, _vitest.it)("should return cached result without calling function", () => {
+      let callCount = 0;
+      const cached = (0, _performance.memo)("cache-key", () => {
+        callCount++;
+        return "cached";
+      });
+      const result1 = cached;
+      const result2 = cached;
+      const result3 = cached;
+      (0, _vitest.expect)(callCount).toBe(1);
+      (0, _vitest.expect)(result1).toBe("cached");
+      (0, _vitest.expect)(result2).toBe("cached");
+      (0, _vitest.expect)(result3).toBe("cached");
+    });
+  });
+  (0, _vitest.describe)("clearMemoCache", () => {
+    (0, _vitest.it)("should clear memo cache", () => {
+      const fn = _vitest.vi.fn().mockReturnValue("value");
+      (0, _performance.memo)("key-x", fn);
+      (0, _performance.memo)("key-y", fn);
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(2);
+      (0, _performance.clearMemoCache)();
+      (0, _performance.memo)("key-x", fn);
+      (0, _performance.memo)("key-y", fn);
+      (0, _vitest.expect)(fn).toHaveBeenCalledTimes(4);
+    });
+  });
+});

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

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