@yh-ui/flow 1.0.25 → 1.0.30

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

@@ -1,292 +0,0 @@
-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

@@ -1,313 +0,0 @@
-"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

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