@yh-ui/flow 1.0.25 → 1.0.30

package/dist/__tests__/bpmn-utils.test.mjs

@@ -1,227 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { flowToBpmnXml, validateBpmnXml, generateSampleBpmnXml } from "../utils/bpmn.mjs";
-function createMockNode(id, type, position = { x: 100, y: 100 }) {
-  return {
-    id,
-    type,
-    position,
-    width: 100,
-    height: 80,
-    data: {},
-    selected: false,
-    dragging: false
-  };
-}
-function createMockEdge(id, source, target) {
-  return {
-    id,
-    source,
-    target,
-    type: "smoothstep",
-    selected: false,
-    animated: false
-  };
-}
-describe("flow/utils/bpmn", () => {
-  describe("flowToBpmnXml", () => {
-    it("should generate BPMN XML with start event", () => {
-      const nodes = [createMockNode("start", "bpmn-start", { x: 50, y: 50 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges, { processId: "test", processName: "Test" });
-      expect(result.xml).toContain("startEvent");
-      expect(result.xml).toContain('id="start"');
-      expect(result.processId).toBe("test");
-    });
-    it("should generate BPMN XML with end event", () => {
-      const nodes = [createMockNode("end", "bpmn-end", { x: 300, y: 100 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("endEvent");
-    });
-    it("should generate BPMN XML with task", () => {
-      const nodes = [createMockNode("task1", "bpmn-task", { x: 150, y: 100 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("<bpmn:task");
-    });
-    it("should generate BPMN XML with service task", () => {
-      const nodes = [
-        {
-          ...createMockNode("service", "bpmn-service-task"),
-          data: { implementation: "${myService}" }
-        }
-      ];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("serviceTask");
-      expect(result.xml).toContain('implementation="delegateExpression"');
-    });
-    it("should generate BPMN XML with user task and assignee", () => {
-      const nodes = [
-        {
-          ...createMockNode("user", "bpmn-user-task"),
-          data: { assignee: "admin", candidateUsers: "user1,user2" }
-        }
-      ];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("userTask");
-      expect(result.xml).toContain('assignee="admin"');
-      expect(result.xml).toContain('candidateUsers="user1,user2"');
-    });
-    it("should generate BPMN XML with exclusive gateway", () => {
-      const nodes = [createMockNode("gw", "bpmn-exclusive-gateway", { x: 250, y: 100 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("exclusiveGateway");
-      expect(result.xml).toContain('gatewayDirection="diverging"');
-    });
-    it("should generate BPMN XML with parallel gateway", () => {
-      const nodes = [createMockNode("pgw", "bpmn-parallel-gateway", { x: 250, y: 100 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("parallelGateway");
-    });
-    it("should generate BPMN XML with inclusive gateway", () => {
-      const nodes = [createMockNode("igw", "bpmn-inclusive-gateway", { x: 250, y: 100 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("inclusiveGateway");
-    });
-    it("should include node name in XML", () => {
-      const nodes = [
-        {
-          ...createMockNode("task1", "bpmn-task"),
-          data: { name: "My Task", label: "My Task" }
-        }
-      ];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain('name="My Task"');
-    });
-    it("should generate sequence flow with condition expression", () => {
-      const nodes = [createMockNode("start", "bpmn-start"), createMockNode("end", "bpmn-end")];
-      const edges = [
-        {
-          ...createMockEdge("flow1", "start", "end"),
-          data: { conditionExpression: "${approved == true}" }
-        }
-      ];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("sequenceFlow");
-      expect(result.xml).toContain("conditionExpression");
-      expect(result.xml).toContain("${approved == true}");
-    });
-    it("should include DI information when includeDi is true", () => {
-      const nodes = [createMockNode("n1", "bpmn-start", { x: 10, y: 20 })];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges, { includeDi: true });
-      expect(result.xml).toContain("BPMNDiagram");
-      expect(result.xml).toContain("BPMNShape");
-    });
-    it("should not include DI information when includeDi is false", () => {
-      const nodes = [createMockNode("n1", "bpmn-start")];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges, { includeDi: false });
-      expect(result.xml).not.toContain("BPMNDiagram");
-    });
-    it("should use default dimensions when node has no width/height", () => {
-      const nodes = [
-        {
-          id: "n1",
-          type: "bpmn-start",
-          position: { x: 0, y: 0 },
-          selected: false,
-          dragging: false
-        }
-      ];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges, { includeDi: true });
-      expect(result.xml).toContain('width="100"');
-      expect(result.xml).toContain('height="80"');
-    });
-    it("should skip unknown node types", () => {
-      const nodes = [
-        {
-          id: "n1",
-          type: "unknown-type",
-          position: { x: 0, y: 0 },
-          selected: false,
-          dragging: false
-        }
-      ];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).not.toContain("unknown-type");
-    });
-    it("should generate XML with proper namespaces", () => {
-      const nodes = [createMockNode("n1", "bpmn-start")];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain('xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL"');
-    });
-    it("should include edges in XML", () => {
-      const nodes = [createMockNode("n1", "bpmn-start"), createMockNode("n2", "bpmn-end")];
-      const edges = [createMockEdge("e1", "n1", "n2")];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.xml).toContain("sequenceFlow");
-      expect(result.xml).toContain('sourceRef="n1"');
-      expect(result.xml).toContain('targetRef="n2"');
-    });
-    it("should generate valid processId", () => {
-      const nodes = [createMockNode("n1", "bpmn-start")];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges, { processId: "MyProcess" });
-      expect(result.processId).toBe("MyProcess");
-    });
-    it("should generate default processId with timestamp", () => {
-      const nodes = [createMockNode("n1", "bpmn-start")];
-      const edges = [];
-      const result = flowToBpmnXml(nodes, edges);
-      expect(result.processId).toMatch(/^Process_\d+$/);
-    });
-  });
-  describe("validateBpmnXml", () => {
-    it("should return invalid for missing definitions", () => {
-      const xml = `<notbpmn></notbpmn>`;
-      const result = validateBpmnXml(xml);
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-    it("should return invalid for missing process", () => {
-      const xml = `<?xml version="1.0"?>
-<bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" id="def1">
-</bpmn:definitions>`;
-      const result = validateBpmnXml(xml);
-      expect(result.valid).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-    it("should return invalid for malformed XML", () => {
-      const xml = `<?xml version="1.0"?><invalid`;
-      const result = validateBpmnXml(xml);
-      expect(result.valid).toBe(false);
-    });
-  });
-  describe("generateSampleBpmnXml", () => {
-    it("should generate a sample BPMN XML string", () => {
-      const xml = generateSampleBpmnXml();
-      expect(xml).toContain("<?xml");
-      expect(xml).toContain("bpmn:definitions");
-      expect(xml).toContain("SampleProcess");
-    });
-    it("should contain start and end events", () => {
-      const xml = generateSampleBpmnXml();
-      expect(xml).toContain("startEvent");
-      expect(xml).toContain("endEvent");
-    });
-    it("should contain user task and service task", () => {
-      const xml = generateSampleBpmnXml();
-      expect(xml).toContain("userTask");
-      expect(xml).toContain("serviceTask");
-    });
-    it("should contain gateway", () => {
-      const xml = generateSampleBpmnXml();
-      expect(xml).toContain("exclusiveGateway");
-    });
-  });
-});

package/dist/__tests__/bpmn-xml.test.cjs

@@ -1,150 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _bpmn = require("../utils/bpmn.cjs");
-function minimalFlow() {
-  const nodes = [{
-    id: "n_start",
-    type: "bpmn-start",
-    position: {
-      x: 100,
-      y: 100
-    },
-    data: {
-      label: "Start",
-      name: "Start"
-    },
-    width: 40,
-    height: 40,
-    selected: false,
-    dragging: false
-  }, {
-    id: "n_task",
-    type: "bpmn-user-task",
-    position: {
-      x: 300,
-      y: 90
-    },
-    data: {
-      label: "Task",
-      name: "Task",
-      assignee: "u1",
-      candidateUsers: "a,b"
-    },
-    width: 120,
-    height: 80,
-    selected: false,
-    dragging: false
-  }, {
-    id: "n_gw",
-    type: "bpmn-exclusive-gateway",
-    position: {
-      x: 500,
-      y: 100
-    },
-    data: {
-      label: "GW"
-    },
-    width: 50,
-    height: 50,
-    selected: false,
-    dragging: false
-  }, {
-    id: "n_end",
-    type: "bpmn-end",
-    position: {
-      x: 700,
-      y: 100
-    },
-    data: {
-      label: "End"
-    },
-    width: 40,
-    height: 40,
-    selected: false,
-    dragging: false
-  }];
-  const edges = [{
-    id: "e1",
-    source: "n_start",
-    target: "n_task"
-  }, {
-    id: "e2",
-    source: "n_task",
-    target: "n_gw",
-    type: "smoothstep",
-    data: {
-      conditionExpression: "${approved}"
-    }
-  }, {
-    id: "e3",
-    source: "n_gw",
-    target: "n_end"
-  }];
-  return {
-    nodes,
-    edges
-  };
-}
-(0, _vitest.describe)("flow/utils/bpmn XML", () => {
-  (0, _vitest.it)("flowToBpmnXml produces definitions and round-trips via bpmnXmlToFlow", () => {
-    const {
-      nodes,
-      edges
-    } = minimalFlow();
-    const {
-      xml,
-      processId
-    } = (0, _bpmn.flowToBpmnXml)(nodes, edges, {
-      processId: "Proc_test",
-      processName: "Test proc",
-      includeDi: true
-    });
-    (0, _vitest.expect)(xml).toContain("bpmn:definitions");
-    (0, _vitest.expect)(xml).toContain(`id="${processId}"`);
-    (0, _vitest.expect)(xml).toContain("bpmn:userTask");
-    (0, _vitest.expect)(xml).toContain('assignee="u1"');
-    (0, _vitest.expect)(xml).toContain("conditionExpression");
-    const parsed = (0, _bpmn.bpmnXmlToFlow)(xml);
-    (0, _vitest.expect)(parsed.processId).toBe("Proc_test");
-    (0, _vitest.expect)(parsed.nodes.length).toBeGreaterThanOrEqual(4);
-    (0, _vitest.expect)(parsed.edges.length).toBeGreaterThanOrEqual(3);
-    const types = new Set(parsed.nodes.map(n => n.type));
-    (0, _vitest.expect)(types.has("bpmn-start")).toBe(true);
-    (0, _vitest.expect)(types.has("bpmn-user-task")).toBe(true);
-    (0, _vitest.expect)(types.has("bpmn-exclusive-gateway")).toBe(true);
-    (0, _vitest.expect)(types.has("bpmn-end")).toBe(true);
-  });
-  (0, _vitest.it)("flowToBpmnXml can omit DI", () => {
-    const {
-      nodes,
-      edges
-    } = minimalFlow();
-    const {
-      xml
-    } = (0, _bpmn.flowToBpmnXml)(nodes, edges, {
-      includeDi: false
-    });
-    (0, _vitest.expect)(xml).toContain("<bpmn:process");
-    (0, _vitest.expect)(xml).not.toContain("BPMNDiagram");
-  });
-  (0, _vitest.it)("validateBpmnXml validates exported sample", () => {
-    const sample = (0, _bpmn.generateSampleBpmnXml)();
-    (0, _vitest.expect)((0, _bpmn.validateBpmnXml)(sample).valid).toBe(true);
-  });
-  (0, _vitest.it)("validateBpmnXml rejects malformed XML", () => {
-    const r = (0, _bpmn.validateBpmnXml)("<<<");
-    (0, _vitest.expect)(r.valid).toBe(false);
-    (0, _vitest.expect)(r.error).toBeDefined();
-  });
-  (0, _vitest.it)("validateBpmnXml rejects missing definitions", () => {
-    const r = (0, _bpmn.validateBpmnXml)('<?xml version="1.0"?><root/>');
-    (0, _vitest.expect)(r.valid).toBe(false);
-  });
-  (0, _vitest.it)("generateSampleBpmnXml includes multiple node kinds", () => {
-    const xml = (0, _bpmn.generateSampleBpmnXml)();
-    (0, _vitest.expect)(xml).toContain("bpmn:startEvent");
-    (0, _vitest.expect)(xml).toContain("bpmn:userTask");
-    (0, _vitest.expect)((0, _bpmn.validateBpmnXml)(xml).valid).toBe(true);
-  });
-});

package/dist/__tests__/bpmn-xml.test.d.ts

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

package/dist/__tests__/bpmn-xml.test.mjs

@@ -1,112 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  flowToBpmnXml,
-  bpmnXmlToFlow,
-  validateBpmnXml,
-  generateSampleBpmnXml
-} from "../utils/bpmn.mjs";
-function minimalFlow() {
-  const nodes = [
-    {
-      id: "n_start",
-      type: "bpmn-start",
-      position: { x: 100, y: 100 },
-      data: { label: "Start", name: "Start" },
-      width: 40,
-      height: 40,
-      selected: false,
-      dragging: false
-    },
-    {
-      id: "n_task",
-      type: "bpmn-user-task",
-      position: { x: 300, y: 90 },
-      data: { label: "Task", name: "Task", assignee: "u1", candidateUsers: "a,b" },
-      width: 120,
-      height: 80,
-      selected: false,
-      dragging: false
-    },
-    {
-      id: "n_gw",
-      type: "bpmn-exclusive-gateway",
-      position: { x: 500, y: 100 },
-      data: { label: "GW" },
-      width: 50,
-      height: 50,
-      selected: false,
-      dragging: false
-    },
-    {
-      id: "n_end",
-      type: "bpmn-end",
-      position: { x: 700, y: 100 },
-      data: { label: "End" },
-      width: 40,
-      height: 40,
-      selected: false,
-      dragging: false
-    }
-  ];
-  const edges = [
-    { id: "e1", source: "n_start", target: "n_task" },
-    {
-      id: "e2",
-      source: "n_task",
-      target: "n_gw",
-      type: "smoothstep",
-      data: { conditionExpression: "${approved}" }
-    },
-    { id: "e3", source: "n_gw", target: "n_end" }
-  ];
-  return { nodes, edges };
-}
-describe("flow/utils/bpmn XML", () => {
-  it("flowToBpmnXml produces definitions and round-trips via bpmnXmlToFlow", () => {
-    const { nodes, edges } = minimalFlow();
-    const { xml, processId } = flowToBpmnXml(nodes, edges, {
-      processId: "Proc_test",
-      processName: "Test proc",
-      includeDi: true
-    });
-    expect(xml).toContain("bpmn:definitions");
-    expect(xml).toContain(`id="${processId}"`);
-    expect(xml).toContain("bpmn:userTask");
-    expect(xml).toContain('assignee="u1"');
-    expect(xml).toContain("conditionExpression");
-    const parsed = bpmnXmlToFlow(xml);
-    expect(parsed.processId).toBe("Proc_test");
-    expect(parsed.nodes.length).toBeGreaterThanOrEqual(4);
-    expect(parsed.edges.length).toBeGreaterThanOrEqual(3);
-    const types = new Set(parsed.nodes.map((n) => n.type));
-    expect(types.has("bpmn-start")).toBe(true);
-    expect(types.has("bpmn-user-task")).toBe(true);
-    expect(types.has("bpmn-exclusive-gateway")).toBe(true);
-    expect(types.has("bpmn-end")).toBe(true);
-  });
-  it("flowToBpmnXml can omit DI", () => {
-    const { nodes, edges } = minimalFlow();
-    const { xml } = flowToBpmnXml(nodes, edges, { includeDi: false });
-    expect(xml).toContain("<bpmn:process");
-    expect(xml).not.toContain("BPMNDiagram");
-  });
-  it("validateBpmnXml validates exported sample", () => {
-    const sample = generateSampleBpmnXml();
-    expect(validateBpmnXml(sample).valid).toBe(true);
-  });
-  it("validateBpmnXml rejects malformed XML", () => {
-    const r = validateBpmnXml("<<<");
-    expect(r.valid).toBe(false);
-    expect(r.error).toBeDefined();
-  });
-  it("validateBpmnXml rejects missing definitions", () => {
-    const r = validateBpmnXml('<?xml version="1.0"?><root/>');
-    expect(r.valid).toBe(false);
-  });
-  it("generateSampleBpmnXml includes multiple node kinds", () => {
-    const xml = generateSampleBpmnXml();
-    expect(xml).toContain("bpmn:startEvent");
-    expect(xml).toContain("bpmn:userTask");
-    expect(validateBpmnXml(xml).valid).toBe(true);
-  });
-});