@yh-ui/flow 1.0.1 → 1.0.4

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

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

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

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

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

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