@yh-ui/flow 1.0.25 → 1.0.30

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

@@ -1,300 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _customTypes = require("../utils/custom-types.cjs");
-var _vue = require("vue");
-(0, _vitest.describe)("flow/utils/custom-types", () => {
-  const MockComponent = (0, _vue.defineComponent)({
-    name: "MockComponent",
-    render() {
-      return (0, _vue.h)("div");
-    }
-  });
-  (0, _vitest.beforeEach)(() => {
-    (0, _customTypes.clearCustomTypes)();
-  });
-  (0, _vitest.describe)("Custom Node Templates", () => {
-    (0, _vitest.it)("should register and retrieve custom node template", () => {
-      const template = {
-        type: "custom-node",
-        component: MockComponent,
-        defaultData: {
-          label: "Test Node"
-        },
-        defaultWidth: 200,
-        defaultHeight: 100
-      };
-      (0, _customTypes.registerCustomNodeTemplate)(template);
-      (0, _vitest.expect)((0, _customTypes.hasCustomNodeTemplate)("custom-node")).toBe(true);
-      const retrieved = (0, _customTypes.getCustomNodeTemplate)("custom-node");
-      (0, _vitest.expect)(retrieved?.type).toBe("custom-node");
-      (0, _vitest.expect)(retrieved?.defaultWidth).toBe(200);
-    });
-    (0, _vitest.it)("should get all registered templates", () => {
-      (0, _customTypes.registerCustomNodeTemplate)({
-        type: "template-1",
-        component: MockComponent
-      });
-      (0, _customTypes.registerCustomNodeTemplate)({
-        type: "template-2",
-        component: MockComponent
-      });
-      const all = (0, _customTypes.getAllCustomNodeTemplates)();
-      (0, _vitest.expect)(all.length).toBe(2);
-    });
-    (0, _vitest.it)("should create node from template", () => {
-      (0, _customTypes.registerCustomNodeTemplate)({
-        type: "template-node",
-        component: MockComponent,
-        defaultData: {
-          label: "Default"
-        },
-        defaultWidth: 180,
-        defaultHeight: 60
-      });
-      const node = (0, _customTypes.createNodeFromTemplate)("template-node", "node-1", {
-        x: 100,
-        y: 200
-      });
-      (0, _vitest.expect)(node).not.toBeNull();
-      (0, _vitest.expect)(node?.id).toBe("node-1");
-      (0, _vitest.expect)(node?.type).toBe("template-node");
-      (0, _vitest.expect)(node?.position).toEqual({
-        x: 100,
-        y: 200
-      });
-      (0, _vitest.expect)(node?.width).toBe(180);
-      (0, _vitest.expect)(node?.height).toBe(60);
-      (0, _vitest.expect)(node?.data.label).toBe("Default");
-    });
-    (0, _vitest.it)("should create node with overrides", () => {
-      (0, _customTypes.registerCustomNodeTemplate)({
-        type: "template-node",
-        component: MockComponent,
-        defaultData: {
-          label: "Default"
-        },
-        defaultWidth: 180,
-        defaultHeight: 60
-      });
-      const node = (0, _customTypes.createNodeFromTemplate)("template-node", "node-1", {
-        x: 100,
-        y: 200
-      }, {
-        data: {
-          label: "Custom Label"
-        },
-        width: 250
-      });
-      (0, _vitest.expect)(node?.data.label).toBe("Custom Label");
-      (0, _vitest.expect)(node?.width).toBe(250);
-    });
-    (0, _vitest.it)("should return null for non-existent template", () => {
-      const node = (0, _customTypes.createNodeFromTemplate)("non-existent", "node-1", {
-        x: 0,
-        y: 0
-      });
-      (0, _vitest.expect)(node).toBeNull();
-    });
-  });
-  (0, _vitest.describe)("Custom Edges", () => {
-    (0, _vitest.it)("should register and retrieve custom edge", () => {
-      const edge = {
-        type: "custom-edge",
-        component: MockComponent,
-        label: "Custom Edge Label"
-      };
-      (0, _customTypes.registerCustomEdge)(edge);
-      (0, _vitest.expect)((0, _customTypes.hasCustomEdge)("custom-edge")).toBe(true);
-      const retrieved = (0, _customTypes.getCustomEdge)("custom-edge");
-      (0, _vitest.expect)(retrieved?.type).toBe("custom-edge");
-      (0, _vitest.expect)(retrieved?.label).toBe("Custom Edge Label");
-    });
-    (0, _vitest.it)("should get all registered edges", () => {
-      (0, _customTypes.registerCustomEdge)({
-        type: "edge-1",
-        component: MockComponent
-      });
-      (0, _customTypes.registerCustomEdge)({
-        type: "edge-2",
-        component: MockComponent
-      });
-      const all = (0, _customTypes.getAllCustomEdges)();
-      (0, _vitest.expect)(all.length).toBe(2);
-    });
-  });
-  (0, _vitest.describe)("Edge Templates", () => {
-    (0, _vitest.it)("should register and retrieve edge template", () => {
-      const template = {
-        type: "animated-edge",
-        animated: true,
-        style: {
-          stroke: "#3b82f6",
-          strokeWidth: 2
-        },
-        label: "Animated"
-      };
-      (0, _customTypes.registerEdgeTemplate)(template);
-      const retrieved = (0, _customTypes.getEdgeTemplate)("animated-edge");
-      (0, _vitest.expect)(retrieved?.type).toBe("animated-edge");
-      (0, _vitest.expect)(retrieved?.animated).toBe(true);
-    });
-    (0, _vitest.it)("should get all edge templates", () => {
-      (0, _customTypes.registerEdgeTemplate)({
-        type: "edge-1",
-        animated: false
-      });
-      (0, _customTypes.registerEdgeTemplate)({
-        type: "edge-2",
-        animated: true
-      });
-      const all = (0, _customTypes.getAllEdgeTemplates)();
-      (0, _vitest.expect)(all.length).toBe(2);
-    });
-  });
-  (0, _vitest.describe)("Nested Node Helpers", () => {
-    const nodes = [{
-      id: "parent-1",
-      type: "group",
-      position: {
-        x: 0,
-        y: 0
-      },
-      data: {},
-      width: 500,
-      height: 300
-    }, {
-      id: "child-1",
-      type: "default",
-      position: {
-        x: 50,
-        y: 50
-      },
-      data: {},
-      parentId: "parent-1"
-    }, {
-      id: "child-2",
-      type: "default",
-      position: {
-        x: 150,
-        y: 50
-      },
-      data: {},
-      parentId: "parent-1"
-    }, {
-      id: "standalone",
-      type: "default",
-      position: {
-        x: 300,
-        y: 300
-      },
-      data: {}
-    }];
-    (0, _vitest.it)("should detect nested node", () => {
-      const child = nodes.find(n => n.id === "child-1");
-      const standalone = nodes.find(n => n.id === "standalone");
-      (0, _vitest.expect)((0, _customTypes.isNestedNode)(child)).toBe(true);
-      (0, _vitest.expect)((0, _customTypes.isNestedNode)(standalone)).toBe(false);
-    });
-    (0, _vitest.it)("should get node children", () => {
-      const parent = nodes.find(n => n.id === "parent-1");
-      const children = (0, _customTypes.getNodeChildren)(parent, nodes);
-      (0, _vitest.expect)(children.length).toBe(2);
-      (0, _vitest.expect)(children.map(c => c.id).sort()).toEqual(["child-1", "child-2"]);
-    });
-    (0, _vitest.it)("should get node parent", () => {
-      const child = nodes.find(n => n.id === "child-1");
-      const standalone = nodes.find(n => n.id === "standalone");
-      const parent = (0, _customTypes.getNodeParent)(child, nodes);
-      (0, _vitest.expect)(parent?.id).toBe("parent-1");
-      const standaloneParent = (0, _customTypes.getNodeParent)(standalone, nodes);
-      (0, _vitest.expect)(standaloneParent).toBeUndefined();
-    });
-  });
-  (0, _vitest.describe)("Export/Import", () => {
-    const testNodes = [{
-      id: "1",
-      type: "input",
-      position: {
-        x: 0,
-        y: 0
-      },
-      data: {
-        label: "Start"
-      }
-    }, {
-      id: "2",
-      type: "default",
-      position: {
-        x: 100,
-        y: 100
-      },
-      data: {
-        label: "Process"
-      }
-    }];
-    const testEdges = [{
-      id: "e1",
-      source: "1",
-      target: "2",
-      type: "bezier"
-    }];
-    (0, _vitest.it)("should export flow data as JSON", () => {
-      const json = (0, _customTypes.exportFlowData)(testNodes, testEdges, {
-        x: 0,
-        y: 0,
-        zoom: 1
-      });
-      (0, _vitest.expect)(json).toContain('"nodes"');
-      (0, _vitest.expect)(json).toContain('"edges"');
-      (0, _vitest.expect)(json).toContain('"viewport"');
-      (0, _vitest.expect)(json).toContain('"version"');
-    });
-    (0, _vitest.it)("should import flow data from JSON", () => {
-      const json = JSON.stringify({
-        nodes: testNodes,
-        edges: testEdges,
-        viewport: {
-          x: 0,
-          y: 0,
-          zoom: 1
-        }
-      });
-      const data = (0, _customTypes.importFlowData)(json);
-      (0, _vitest.expect)(data).not.toBeNull();
-      (0, _vitest.expect)(data?.nodes.length).toBe(2);
-      (0, _vitest.expect)(data?.edges.length).toBe(1);
-    });
-    (0, _vitest.it)("should return null for invalid JSON", () => {
-      const data = (0, _customTypes.importFlowData)("invalid json");
-      (0, _vitest.expect)(data).toBeNull();
-    });
-    (0, _vitest.it)("should return null for empty nodes array", () => {
-      const json = JSON.stringify({
-        edges: []
-      });
-      const data = (0, _customTypes.importFlowData)(json);
-      (0, _vitest.expect)(data).toBeNull();
-    });
-  });
-  (0, _vitest.describe)("clearCustomTypes", () => {
-    (0, _vitest.it)("should clear all registered types", () => {
-      (0, _customTypes.registerCustomNodeTemplate)({
-        type: "test-node",
-        component: MockComponent
-      });
-      (0, _customTypes.registerCustomEdge)({
-        type: "test-edge",
-        component: MockComponent
-      });
-      (0, _customTypes.registerEdgeTemplate)({
-        type: "test-edge-template",
-        animated: true
-      });
-      (0, _customTypes.clearCustomTypes)();
-      (0, _vitest.expect)((0, _customTypes.hasCustomNodeTemplate)("test-node")).toBe(false);
-      (0, _vitest.expect)((0, _customTypes.hasCustomEdge)("test-edge")).toBe(false);
-      (0, _vitest.expect)((0, _customTypes.getEdgeTemplate)("test-edge-template")).toBeUndefined();
-    });
-  });
-});

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

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

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

@@ -1,248 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  registerCustomNodeTemplate,
-  getCustomNodeTemplate,
-  getAllCustomNodeTemplates,
-  hasCustomNodeTemplate,
-  createNodeFromTemplate,
-  isNestedNode,
-  getNodeChildren,
-  getNodeParent,
-  registerCustomEdge,
-  getCustomEdge,
-  getAllCustomEdges,
-  hasCustomEdge,
-  registerEdgeTemplate,
-  getEdgeTemplate,
-  getAllEdgeTemplates,
-  exportFlowData,
-  importFlowData,
-  clearCustomTypes
-} from "../utils/custom-types.mjs";
-import { defineComponent, h } from "vue";
-describe("flow/utils/custom-types", () => {
-  const MockComponent = defineComponent({
-    name: "MockComponent",
-    render() {
-      return h("div");
-    }
-  });
-  beforeEach(() => {
-    clearCustomTypes();
-  });
-  describe("Custom Node Templates", () => {
-    it("should register and retrieve custom node template", () => {
-      const template = {
-        type: "custom-node",
-        component: MockComponent,
-        defaultData: { label: "Test Node" },
-        defaultWidth: 200,
-        defaultHeight: 100
-      };
-      registerCustomNodeTemplate(template);
-      expect(hasCustomNodeTemplate("custom-node")).toBe(true);
-      const retrieved = getCustomNodeTemplate("custom-node");
-      expect(retrieved?.type).toBe("custom-node");
-      expect(retrieved?.defaultWidth).toBe(200);
-    });
-    it("should get all registered templates", () => {
-      registerCustomNodeTemplate({
-        type: "template-1",
-        component: MockComponent
-      });
-      registerCustomNodeTemplate({
-        type: "template-2",
-        component: MockComponent
-      });
-      const all = getAllCustomNodeTemplates();
-      expect(all.length).toBe(2);
-    });
-    it("should create node from template", () => {
-      registerCustomNodeTemplate({
-        type: "template-node",
-        component: MockComponent,
-        defaultData: { label: "Default" },
-        defaultWidth: 180,
-        defaultHeight: 60
-      });
-      const node = createNodeFromTemplate("template-node", "node-1", { x: 100, y: 200 });
-      expect(node).not.toBeNull();
-      expect(node?.id).toBe("node-1");
-      expect(node?.type).toBe("template-node");
-      expect(node?.position).toEqual({ x: 100, y: 200 });
-      expect(node?.width).toBe(180);
-      expect(node?.height).toBe(60);
-      expect(node?.data.label).toBe("Default");
-    });
-    it("should create node with overrides", () => {
-      registerCustomNodeTemplate({
-        type: "template-node",
-        component: MockComponent,
-        defaultData: { label: "Default" },
-        defaultWidth: 180,
-        defaultHeight: 60
-      });
-      const node = createNodeFromTemplate(
-        "template-node",
-        "node-1",
-        { x: 100, y: 200 },
-        {
-          data: { label: "Custom Label" },
-          width: 250
-        }
-      );
-      expect(node?.data.label).toBe("Custom Label");
-      expect(node?.width).toBe(250);
-    });
-    it("should return null for non-existent template", () => {
-      const node = createNodeFromTemplate("non-existent", "node-1", { x: 0, y: 0 });
-      expect(node).toBeNull();
-    });
-  });
-  describe("Custom Edges", () => {
-    it("should register and retrieve custom edge", () => {
-      const edge = {
-        type: "custom-edge",
-        component: MockComponent,
-        label: "Custom Edge Label"
-      };
-      registerCustomEdge(edge);
-      expect(hasCustomEdge("custom-edge")).toBe(true);
-      const retrieved = getCustomEdge("custom-edge");
-      expect(retrieved?.type).toBe("custom-edge");
-      expect(retrieved?.label).toBe("Custom Edge Label");
-    });
-    it("should get all registered edges", () => {
-      registerCustomEdge({ type: "edge-1", component: MockComponent });
-      registerCustomEdge({ type: "edge-2", component: MockComponent });
-      const all = getAllCustomEdges();
-      expect(all.length).toBe(2);
-    });
-  });
-  describe("Edge Templates", () => {
-    it("should register and retrieve edge template", () => {
-      const template = {
-        type: "animated-edge",
-        animated: true,
-        style: { stroke: "#3b82f6", strokeWidth: 2 },
-        label: "Animated"
-      };
-      registerEdgeTemplate(template);
-      const retrieved = getEdgeTemplate("animated-edge");
-      expect(retrieved?.type).toBe("animated-edge");
-      expect(retrieved?.animated).toBe(true);
-    });
-    it("should get all edge templates", () => {
-      registerEdgeTemplate({ type: "edge-1", animated: false });
-      registerEdgeTemplate({ type: "edge-2", animated: true });
-      const all = getAllEdgeTemplates();
-      expect(all.length).toBe(2);
-    });
-  });
-  describe("Nested Node Helpers", () => {
-    const nodes = [
-      {
-        id: "parent-1",
-        type: "group",
-        position: { x: 0, y: 0 },
-        data: {},
-        width: 500,
-        height: 300
-      },
-      {
-        id: "child-1",
-        type: "default",
-        position: { x: 50, y: 50 },
-        data: {},
-        parentId: "parent-1"
-      },
-      {
-        id: "child-2",
-        type: "default",
-        position: { x: 150, y: 50 },
-        data: {},
-        parentId: "parent-1"
-      },
-      {
-        id: "standalone",
-        type: "default",
-        position: { x: 300, y: 300 },
-        data: {}
-      }
-    ];
-    it("should detect nested node", () => {
-      const child = nodes.find((n) => n.id === "child-1");
-      const standalone = nodes.find((n) => n.id === "standalone");
-      expect(isNestedNode(child)).toBe(true);
-      expect(isNestedNode(standalone)).toBe(false);
-    });
-    it("should get node children", () => {
-      const parent = nodes.find((n) => n.id === "parent-1");
-      const children = getNodeChildren(parent, nodes);
-      expect(children.length).toBe(2);
-      expect(children.map((c) => c.id).sort()).toEqual(["child-1", "child-2"]);
-    });
-    it("should get node parent", () => {
-      const child = nodes.find((n) => n.id === "child-1");
-      const standalone = nodes.find((n) => n.id === "standalone");
-      const parent = getNodeParent(child, nodes);
-      expect(parent?.id).toBe("parent-1");
-      const standaloneParent = getNodeParent(standalone, nodes);
-      expect(standaloneParent).toBeUndefined();
-    });
-  });
-  describe("Export/Import", () => {
-    const testNodes = [
-      { id: "1", type: "input", position: { x: 0, y: 0 }, data: { label: "Start" } },
-      { id: "2", type: "default", position: { x: 100, y: 100 }, data: { label: "Process" } }
-    ];
-    const testEdges = [{ id: "e1", source: "1", target: "2", type: "bezier" }];
-    it("should export flow data as JSON", () => {
-      const json = exportFlowData(testNodes, testEdges, { x: 0, y: 0, zoom: 1 });
-      expect(json).toContain('"nodes"');
-      expect(json).toContain('"edges"');
-      expect(json).toContain('"viewport"');
-      expect(json).toContain('"version"');
-    });
-    it("should import flow data from JSON", () => {
-      const json = JSON.stringify({
-        nodes: testNodes,
-        edges: testEdges,
-        viewport: { x: 0, y: 0, zoom: 1 }
-      });
-      const data = importFlowData(json);
-      expect(data).not.toBeNull();
-      expect(data?.nodes.length).toBe(2);
-      expect(data?.edges.length).toBe(1);
-    });
-    it("should return null for invalid JSON", () => {
-      const data = importFlowData("invalid json");
-      expect(data).toBeNull();
-    });
-    it("should return null for empty nodes array", () => {
-      const json = JSON.stringify({ edges: [] });
-      const data = importFlowData(json);
-      expect(data).toBeNull();
-    });
-  });
-  describe("clearCustomTypes", () => {
-    it("should clear all registered types", () => {
-      registerCustomNodeTemplate({
-        type: "test-node",
-        component: MockComponent
-      });
-      registerCustomEdge({
-        type: "test-edge",
-        component: MockComponent
-      });
-      registerEdgeTemplate({
-        type: "test-edge-template",
-        animated: true
-      });
-      clearCustomTypes();
-      expect(hasCustomNodeTemplate("test-node")).toBe(false);
-      expect(hasCustomEdge("test-edge")).toBe(false);
-      expect(getEdgeTemplate("test-edge-template")).toBeUndefined();
-    });
-  });
-});