@aranzatech/diagrams-bpmn 0.1.0

package/dist/chunk-4OAEWYYU.js

@@ -0,0 +1,579 @@
+import { BPMN_ELEMENT_CATALOG } from './chunk-6TUC5QX5.js';
+import { BpmnModdle } from 'bpmn-moddle';
+
+// src/xml/mapper.ts
+var MODDLE_TO_ELEMENT_TYPE = {
+  "bpmn:StartEvent": "StartEvent",
+  "bpmn:EndEvent": "EndEvent",
+  "bpmn:IntermediateCatchEvent": "IntermediateCatchEvent",
+  "bpmn:IntermediateThrowEvent": "IntermediateThrowEvent",
+  "bpmn:BoundaryEvent": "BoundaryEvent",
+  "bpmn:Task": "Task",
+  "bpmn:UserTask": "UserTask",
+  "bpmn:ServiceTask": "ServiceTask",
+  "bpmn:ScriptTask": "ScriptTask",
+  "bpmn:ManualTask": "ManualTask",
+  "bpmn:BusinessRuleTask": "BusinessRuleTask",
+  "bpmn:ReceiveTask": "ReceiveTask",
+  "bpmn:SendTask": "SendTask",
+  "bpmn:CallActivity": "CallActivity",
+  "bpmn:ExclusiveGateway": "ExclusiveGateway",
+  "bpmn:InclusiveGateway": "InclusiveGateway",
+  "bpmn:ParallelGateway": "ParallelGateway",
+  "bpmn:EventBasedGateway": "EventBasedGateway",
+  "bpmn:ComplexGateway": "ComplexGateway",
+  "bpmn:SubProcess": "SubProcess",
+  "bpmn:AdHocSubProcess": "SubProcess",
+  "bpmn:Transaction": "SubProcess",
+  "bpmn:TextAnnotation": "Annotation",
+  "bpmn:Group": "Group",
+  "bpmn:DataObject": "DataObject",
+  "bpmn:DataObjectReference": "DataObjectReference",
+  "bpmn:DataInput": "DataInput",
+  "bpmn:DataOutput": "DataOutput",
+  "bpmn:DataStore": "DataStore",
+  "bpmn:DataStoreReference": "DataStoreReference",
+  "bpmn:Conversation": "Conversation",
+  "bpmn:SubConversation": "SubConversation",
+  "bpmn:CallConversation": "CallConversation",
+  "bpmn:ChoreographyTask": "ChoreographyTask",
+  "bpmn:SubChoreography": "SubChoreography",
+  "bpmn:CallChoreography": "CallChoreography",
+  "bpmn:Lane": "Lane"
+};
+var ELEMENT_TYPE_TO_MODDLE = {
+  StartEvent: "bpmn:StartEvent",
+  EndEvent: "bpmn:EndEvent",
+  IntermediateCatchEvent: "bpmn:IntermediateCatchEvent",
+  IntermediateThrowEvent: "bpmn:IntermediateThrowEvent",
+  BoundaryEvent: "bpmn:BoundaryEvent",
+  Task: "bpmn:Task",
+  UserTask: "bpmn:UserTask",
+  ServiceTask: "bpmn:ServiceTask",
+  ScriptTask: "bpmn:ScriptTask",
+  ManualTask: "bpmn:ManualTask",
+  BusinessRuleTask: "bpmn:BusinessRuleTask",
+  ReceiveTask: "bpmn:ReceiveTask",
+  SendTask: "bpmn:SendTask",
+  CallActivity: "bpmn:CallActivity",
+  ExclusiveGateway: "bpmn:ExclusiveGateway",
+  InclusiveGateway: "bpmn:InclusiveGateway",
+  ParallelGateway: "bpmn:ParallelGateway",
+  EventBasedGateway: "bpmn:EventBasedGateway",
+  ComplexGateway: "bpmn:ComplexGateway",
+  SubProcess: "bpmn:SubProcess",
+  Pool: "bpmn:Participant",
+  Lane: "bpmn:Lane",
+  Annotation: "bpmn:TextAnnotation",
+  Group: "bpmn:Group",
+  DataObject: "bpmn:DataObject",
+  DataObjectReference: "bpmn:DataObjectReference",
+  DataInput: "bpmn:DataInput",
+  DataOutput: "bpmn:DataOutput",
+  DataStore: "bpmn:DataStore",
+  DataStoreReference: "bpmn:DataStoreReference",
+  Conversation: "bpmn:Conversation",
+  SubConversation: "bpmn:SubConversation",
+  CallConversation: "bpmn:CallConversation",
+  ChoreographyTask: "bpmn:ChoreographyTask",
+  SubChoreography: "bpmn:SubChoreography",
+  CallChoreography: "bpmn:CallChoreography"
+};
+var MODDLE_TO_EDGE_TYPE = {
+  "bpmn:SequenceFlow": "sequenceFlow",
+  "bpmn:MessageFlow": "messageFlow",
+  "bpmn:Association": "association",
+  "bpmn:DataInputAssociation": "dataAssociation",
+  "bpmn:DataOutputAssociation": "dataAssociation",
+  "bpmn:ConversationLink": "conversationLink"
+};
+var EDGE_TYPE_TO_MODDLE = {
+  sequenceFlow: "bpmn:SequenceFlow",
+  messageFlow: "bpmn:MessageFlow",
+  association: "bpmn:Association",
+  dataAssociation: "bpmn:DataInputAssociation",
+  conversationLink: "bpmn:ConversationLink"
+};
+var EVENT_DEF_TO_TRIGGER = {
+  "bpmn:MessageEventDefinition": "message",
+  "bpmn:TimerEventDefinition": "timer",
+  "bpmn:EscalationEventDefinition": "escalation",
+  "bpmn:ConditionalEventDefinition": "conditional",
+  "bpmn:ErrorEventDefinition": "error",
+  "bpmn:CancelEventDefinition": "cancel",
+  "bpmn:CompensateEventDefinition": "compensation",
+  "bpmn:SignalEventDefinition": "signal",
+  "bpmn:LinkEventDefinition": "link",
+  "bpmn:TerminateEventDefinition": "terminate"
+};
+var TRIGGER_TO_EVENT_DEF = {
+  message: "bpmn:MessageEventDefinition",
+  timer: "bpmn:TimerEventDefinition",
+  escalation: "bpmn:EscalationEventDefinition",
+  conditional: "bpmn:ConditionalEventDefinition",
+  error: "bpmn:ErrorEventDefinition",
+  cancel: "bpmn:CancelEventDefinition",
+  compensation: "bpmn:CompensateEventDefinition",
+  signal: "bpmn:SignalEventDefinition",
+  link: "bpmn:LinkEventDefinition",
+  terminate: "bpmn:TerminateEventDefinition"
+};
+
+// src/xml/importer.ts
+function asElements(v) {
+  return Array.isArray(v) ? v : [];
+}
+function asString(v) {
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function extractDiagramInfo(definitions) {
+  const shapes = /* @__PURE__ */ new Map();
+  const waypoints = /* @__PURE__ */ new Map();
+  for (const diagram of asElements(definitions.diagrams)) {
+    const plane = diagram.plane;
+    if (!plane) continue;
+    for (const el of asElements(plane.planeElement)) {
+      const bpmnEl = el.bpmnElement;
+      if (!bpmnEl?.id) continue;
+      const id = bpmnEl.id;
+      if (el.$type === "bpmndi:BPMNShape") {
+        const b = el.bounds;
+        if (b) {
+          shapes.set(id, {
+            x: b.x,
+            y: b.y,
+            width: b.width,
+            height: b.height,
+            ...typeof el.isExpanded === "boolean" ? { isExpanded: el.isExpanded } : {}
+          });
+        }
+      } else if (el.$type === "bpmndi:BPMNEdge") {
+        const pts = el.waypoint ?? [];
+        if (pts.length) waypoints.set(id, pts);
+      }
+    }
+  }
+  return { shapes, waypoints };
+}
+function extractLaneMembership(process) {
+  const map = /* @__PURE__ */ new Map();
+  function walkLaneSet(laneSet2) {
+    for (const lane of asElements(laneSet2.lanes)) {
+      const laneId = lane.id;
+      if (!laneId) continue;
+      for (const ref of asElements(lane.flowNodeRef)) {
+        if (ref.id) map.set(ref.id, laneId);
+      }
+      const child = lane.childLaneSet;
+      if (child) walkLaneSet(child);
+    }
+  }
+  const laneSet = process.laneSet;
+  if (laneSet) walkLaneSet(laneSet);
+  return map;
+}
+function extractTrigger(el) {
+  const defs = asElements(el.eventDefinitions);
+  if (defs.length === 0) return void 0;
+  if (defs.length > 1) return el.$type.includes("Parallel") ? "parallelMultiple" : "multiple";
+  return EVENT_DEF_TO_TRIGGER[defs[0].$type];
+}
+function extractSubProcessVariant(el) {
+  if (el.$type === "bpmn:Transaction") return "transaction";
+  if (el.$type === "bpmn:AdHocSubProcess") return "adhoc";
+  if (el.triggeredByEvent === true) return "event";
+  return "embedded";
+}
+function walkFlowElements(elements, parentId, ctx, nodes, edges) {
+  for (const el of elements) {
+    const { $type, id } = el;
+    if (!id) continue;
+    const edgeType = MODDLE_TO_EDGE_TYPE[$type];
+    if (edgeType !== void 0) {
+      buildEdge(el, edgeType, ctx, edges);
+      continue;
+    }
+    if ($type === "bpmn:LaneSet") continue;
+    const elementType = MODDLE_TO_ELEMENT_TYPE[$type];
+    if (!elementType) {
+      ctx.warnings.push(`Unknown element type "${$type}" (id=${id}) \u2014 skipped.`);
+      continue;
+    }
+    buildNode(el, elementType, parentId, ctx, nodes);
+    if ($type === "bpmn:SubProcess" || $type === "bpmn:Transaction" || $type === "bpmn:AdHocSubProcess") {
+      const children = asElements(el.flowElements);
+      const laneMembership = extractLaneMembership(el);
+      walkFlowElements(children, id, { ...ctx, laneMembership }, nodes, edges);
+    }
+  }
+}
+function buildNode(el, elementType, parentId, ctx, nodes) {
+  const id = el.id;
+  const meta = BPMN_ELEMENT_CATALOG[elementType];
+  const shape = ctx.shapes.get(id);
+  const x = shape?.x ?? ctx.autoX.value;
+  const y = shape?.y ?? 100;
+  if (!shape) ctx.autoX.value += (meta?.defaultWidth ?? 120) + 20;
+  const label = asString(el.name);
+  const trigger = extractTrigger(el);
+  const isNonInterrupting = el.cancelActivity === false;
+  const data = {
+    elementType,
+    ...label ? { label } : {},
+    ...trigger ? { trigger } : {},
+    ...isNonInterrupting ? { isNonInterrupting: true } : {}
+  };
+  if (elementType === "SubProcess") {
+    const variant = extractSubProcessVariant(el);
+    if (variant) data.subProcessVariant = variant;
+    const isExpanded = shape?.isExpanded ?? true;
+    data.isExpanded = isExpanded;
+  }
+  const laneId = ctx.laneMembership.get(id);
+  const effectiveParentId = laneId ?? parentId;
+  const node = {
+    id,
+    type: elementType,
+    position: { x, y },
+    data,
+    width: shape?.width ?? meta?.defaultWidth,
+    height: shape?.height ?? meta?.defaultHeight,
+    ...effectiveParentId ? { parentId: effectiveParentId } : {}
+  };
+  nodes.push(node);
+}
+function buildEdge(el, edgeType, ctx, edges) {
+  const id = el.id;
+  const source = el.sourceRef?.id;
+  const target = el.targetRef?.id;
+  if (!source || !target) {
+    ctx.warnings.push(`Edge "${id}" missing source or target \u2014 skipped.`);
+    return;
+  }
+  const label = asString(el.name);
+  const condExpr = el.conditionExpression;
+  const data = {
+    edgeType,
+    ...label ? { label } : {},
+    ...condExpr?.body ? { conditionExpression: condExpr.body } : {}
+  };
+  const waypoints = ctx.waypoints.get(id);
+  if (waypoints?.length) data.routingPoints = waypoints;
+  edges.push({ id, type: edgeType, source, target, data });
+}
+function handleCollaboration(collaboration, ctx, nodes, edges) {
+  for (const participant of asElements(collaboration.participants)) {
+    const id = participant.id;
+    if (!id) continue;
+    const label = asString(participant.name);
+    const shape = ctx.shapes.get(id);
+    const poolNode = {
+      id,
+      type: "Pool",
+      position: { x: shape?.x ?? 0, y: shape?.y ?? 0 },
+      data: { elementType: "Pool", ...label ? { label } : {} },
+      width: shape?.width ?? 600,
+      height: shape?.height ?? 200
+    };
+    nodes.push(poolNode);
+    const processRef = participant.processRef;
+    if (processRef) {
+      const laneMembership = extractLaneMembership(processRef);
+      walkFlowElements(
+        asElements(processRef.flowElements),
+        id,
+        { ...ctx, laneMembership },
+        nodes,
+        edges
+      );
+      const laneSet = processRef.laneSet;
+      if (laneSet) {
+        addLaneNodes(laneSet, id, ctx, nodes);
+      }
+    }
+  }
+  for (const mf of asElements(collaboration.messageFlows)) {
+    buildEdge(mf, "messageFlow", ctx, edges);
+  }
+  for (const cl of asElements(collaboration.conversationLinks)) {
+    buildEdge(cl, "conversationLink", ctx, edges);
+  }
+}
+function addLaneNodes(laneSet, poolId, ctx, nodes) {
+  for (const lane of asElements(laneSet.lanes)) {
+    const id = lane.id;
+    if (!id) continue;
+    const label = asString(lane.name);
+    const shape = ctx.shapes.get(id);
+    nodes.push({
+      id,
+      type: "Lane",
+      position: { x: shape?.x ?? 30, y: shape?.y ?? 0 },
+      data: { elementType: "Lane", ...label ? { label } : {} },
+      width: shape?.width ?? 570,
+      height: shape?.height ?? 120,
+      parentId: poolId
+    });
+    const child = lane.childLaneSet;
+    if (child) addLaneNodes(child, poolId, ctx, nodes);
+  }
+}
+async function parseBpmnXml(xml) {
+  const moddle = new BpmnModdle();
+  const warnings = [];
+  let rootElement;
+  try {
+    const result = await moddle.fromXML(xml);
+    rootElement = result.rootElement;
+    for (const w of result.warnings) warnings.push(w.message);
+  } catch (err) {
+    throw new Error(`Failed to parse BPMN XML: ${String(err)}`);
+  }
+  const nodes = [];
+  const edges = [];
+  const { shapes, waypoints } = extractDiagramInfo(rootElement);
+  const ctx = {
+    shapes,
+    waypoints,
+    laneMembership: /* @__PURE__ */ new Map(),
+    warnings,
+    autoX: { value: 50 }
+  };
+  for (const rootEl of asElements(rootElement.rootElements)) {
+    if (rootEl.$type === "bpmn:Collaboration") {
+      handleCollaboration(rootEl, ctx, nodes, edges);
+    } else if (rootEl.$type === "bpmn:Process") {
+      const laneMembership = extractLaneMembership(rootEl);
+      const laneSet = rootEl.laneSet;
+      if (laneSet) addLaneNodes(laneSet, "", ctx, nodes);
+      walkFlowElements(
+        asElements(rootEl.flowElements),
+        void 0,
+        { ...ctx, laneMembership },
+        nodes,
+        edges
+      );
+    }
+  }
+  return { nodes, edges, warnings };
+}
+function uid(prefix, id) {
+  return `${prefix}_${id}`;
+}
+function asNodes(nodes, types) {
+  return nodes.filter((n) => types.includes(n.data.elementType));
+}
+function buildFlowableAttrs(data) {
+  const attrs = {};
+  if (data.flowableAssignee) attrs["flowable:assignee"] = data.flowableAssignee;
+  if (data.flowableCandidateGroups) attrs["flowable:candidateGroups"] = data.flowableCandidateGroups;
+  if (data.flowableCandidateUsers) attrs["flowable:candidateUsers"] = data.flowableCandidateUsers;
+  if (data.flowableFormKey) attrs["flowable:formKey"] = data.flowableFormKey;
+  if (data.flowableDueDate) attrs["flowable:dueDate"] = data.flowableDueDate;
+  if (data.flowableType) attrs["flowable:type"] = data.flowableType;
+  if (data.flowableExpression) attrs["flowable:expression"] = data.flowableExpression;
+  if (data.flowableClass) attrs["flowable:class"] = data.flowableClass;
+  if (data.flowableDelegateExpression) attrs["flowable:delegateExpression"] = data.flowableDelegateExpression;
+  return attrs;
+}
+function buildSemanticModel(moddle, nodes, edges, opts) {
+  const defId = opts.id ?? "Definitions_1";
+  const defName = opts.name;
+  const poolNodes = asNodes(nodes, ["Pool"]);
+  const laneNodes = asNodes(nodes, ["Lane"]);
+  const isCollaboration = poolNodes.length > 0;
+  const definitions = moddle.create("bpmn:Definitions", {
+    id: defId,
+    targetNamespace: "http://bpmn.io/schema/bpmn",
+    ...defName ? { name: defName } : {}
+  });
+  const rootElements = [];
+  if (isCollaboration) {
+    const participants = [];
+    const processes = [];
+    for (const pool of poolNodes) {
+      const processId = `Process_${pool.id}`;
+      const process = buildProcess(moddle, nodes, edges, pool.id, laneNodes, processId);
+      processes.push(process);
+      const participant = moddle.create("bpmn:Participant", {
+        id: pool.id,
+        name: pool.data.label ?? "",
+        processRef: process
+      });
+      participants.push(participant);
+    }
+    const messageFlowEdges = edges.filter((e) => e.data?.edgeType === "messageFlow");
+    const conversationLinkEdges = edges.filter((e) => e.data?.edgeType === "conversationLink");
+    const messageFlows = messageFlowEdges.map(
+      (e) => moddle.create("bpmn:MessageFlow", {
+        id: e.id,
+        name: e.data?.label ?? "",
+        sourceRef: { id: e.source },
+        targetRef: { id: e.target }
+      })
+    );
+    const conversationLinks = conversationLinkEdges.map(
+      (e) => moddle.create("bpmn:ConversationLink", {
+        id: e.id,
+        sourceRef: { id: e.source },
+        targetRef: { id: e.target }
+      })
+    );
+    const collaboration = moddle.create("bpmn:Collaboration", {
+      id: `Collaboration_${defId}`,
+      participants,
+      messageFlows,
+      conversationLinks
+    });
+    rootElements.push(collaboration, ...processes);
+  } else {
+    const process = buildProcess(moddle, nodes, edges, void 0, laneNodes, "Process_1");
+    rootElements.push(process);
+  }
+  definitions.rootElements = rootElements;
+  return definitions;
+}
+function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId) {
+  const myNodes = poolId ? allNodes.filter(
+    (n) => n.parentId === poolId || laneNodes.some((l) => l.id === n.parentId && l.parentId === poolId)
+  ) : allNodes.filter((n) => n.data.elementType !== "Pool" && n.data.elementType !== "Lane");
+  const myLanes = laneNodes.filter((l) => poolId ? l.parentId === poolId : true);
+  const flowElements = [];
+  for (const node of myNodes) {
+    const el = buildFlowElement(moddle, node);
+    if (el) flowElements.push(el);
+  }
+  const myNodeIds = new Set(myNodes.map((n) => n.id));
+  const myEdges = allEdges.filter(
+    (e) => (e.data?.edgeType === "sequenceFlow" || e.data?.edgeType === "association" || e.data?.edgeType === "dataAssociation") && myNodeIds.has(e.source) && myNodeIds.has(e.target)
+  );
+  for (const edge of myEdges) {
+    const edgeMeta = buildEdgeElement(moddle, edge);
+    if (edgeMeta) flowElements.push(edgeMeta);
+  }
+  const process = moddle.create("bpmn:Process", {
+    id: processId,
+    isExecutable: true,
+    flowElements
+  });
+  if (myLanes.length > 0) {
+    const laneElements = myLanes.map(
+      (l) => moddle.create("bpmn:Lane", {
+        id: l.id,
+        name: l.data.label ?? "",
+        flowNodeRef: myNodes.filter((n) => n.parentId === l.id).map((n) => ({ id: n.id }))
+      })
+    );
+    process.laneSet = moddle.create("bpmn:LaneSet", {
+      id: `LaneSet_${processId}`,
+      lanes: laneElements
+    });
+  }
+  return process;
+}
+function buildFlowElement(moddle, node, _allNodes, _allEdges) {
+  const { elementType, label, trigger } = node.data;
+  if (elementType === "Pool" || elementType === "Lane") return null;
+  const moddleType = ELEMENT_TYPE_TO_MODDLE[elementType];
+  if (!moddleType) return null;
+  const attrs = {
+    id: node.id,
+    name: label ?? ""
+  };
+  if (trigger && trigger !== "none") {
+    const defType = TRIGGER_TO_EVENT_DEF[trigger];
+    if (defType) {
+      attrs.eventDefinitions = [moddle.create(defType, { id: uid("EventDef", node.id) })];
+    }
+  }
+  if (elementType === "SubProcess" && node.data.subProcessVariant === "transaction") {
+    return moddle.create("bpmn:Transaction", attrs);
+  }
+  if (elementType === "SubProcess" && node.data.subProcessVariant === "adhoc") {
+    return moddle.create("bpmn:AdHocSubProcess", attrs);
+  }
+  const element = moddle.create(moddleType, attrs);
+  const flowableAttrs = buildFlowableAttrs(node.data);
+  if (Object.keys(flowableAttrs).length > 0) {
+    element.$attrs = flowableAttrs;
+  }
+  return element;
+}
+function buildEdgeElement(moddle, edge) {
+  if (!edge.data) return null;
+  const moddleType = EDGE_TYPE_TO_MODDLE[edge.data.edgeType];
+  if (!moddleType) return null;
+  const attrs = {
+    id: edge.id,
+    name: edge.data.label ?? "",
+    sourceRef: { id: edge.source },
+    targetRef: { id: edge.target }
+  };
+  if (edge.data.conditionExpression) {
+    attrs.conditionExpression = moddle.create("bpmn:FormalExpression", {
+      body: edge.data.conditionExpression
+    });
+  }
+  return moddle.create(moddleType, attrs);
+}
+function buildBpmnDI(moddle, definitions, nodes, edges) {
+  const shapes = [];
+  const edgeShapes = [];
+  for (const node of nodes) {
+    const meta = BPMN_ELEMENT_CATALOG[node.data.elementType];
+    const w = node.width ?? meta?.defaultWidth ?? 120;
+    const h = node.height ?? meta?.defaultHeight ?? 60;
+    const bounds = moddle.create("dc:Bounds", {
+      x: node.position.x,
+      y: node.position.y,
+      width: w,
+      height: h
+    });
+    const shape = moddle.create("bpmndi:BPMNShape", {
+      id: uid("BPMNShape", node.id),
+      bpmnElement: { id: node.id },
+      bounds
+    });
+    if (node.data.isExpanded !== void 0) {
+      shape.isExpanded = node.data.isExpanded;
+    }
+    shapes.push(shape);
+  }
+  for (const edge of edges) {
+    const waypoints = edge.data?.routingPoints?.map(
+      (p) => moddle.create("dc:Point", { x: p.x, y: p.y })
+    ) ?? [];
+    edgeShapes.push(
+      moddle.create("bpmndi:BPMNEdge", {
+        id: uid("BPMNEdge", edge.id),
+        bpmnElement: { id: edge.id },
+        waypoint: waypoints
+      })
+    );
+  }
+  const rootEls = definitions.rootElements;
+  const planeElement = rootEls?.[0];
+  const plane = moddle.create("bpmndi:BPMNPlane", {
+    id: "BPMNPlane_1",
+    bpmnElement: planeElement ?? { id: "unknown" },
+    planeElement: [...shapes, ...edgeShapes]
+  });
+  const diagram = moddle.create("bpmndi:BPMNDiagram", {
+    id: "BPMNDiagram_1",
+    plane
+  });
+  definitions.diagrams = [diagram];
+}
+async function serializeBpmnXml(nodes, edges, opts = {}) {
+  const moddle = new BpmnModdle();
+  const definitions = buildSemanticModel(moddle, nodes, edges, opts);
+  buildBpmnDI(moddle, definitions, nodes, edges);
+  const { xml } = await moddle.toXML(definitions, {
+    format: opts.format ?? true
+  });
+  return xml;
+}
+
+export { parseBpmnXml, serializeBpmnXml };
+//# sourceMappingURL=chunk-4OAEWYYU.js.map
+//# sourceMappingURL=chunk-4OAEWYYU.js.map