@aranzatech/diagrams-bpmn 0.2.4 → 0.2.5

package/dist/xml/index.cjs

@@ -775,9 +775,84 @@ function extractLaneMembership(process) {
 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";
+  if (defs.length > 1) {
+    return defs.some((def) => def.$type === "bpmn:ParallelMultipleEventDefinition") ? "parallelMultiple" : "multiple";
+  }
   return EVENT_DEF_TO_TRIGGER[defs[0].$type];
 }
+function parseVariableType(value) {
+  const text = asString(value) ?? "";
+  if (text.includes("int")) return "integer";
+  if (text.includes("boolean")) return "boolean";
+  if (text.includes("date")) return "date";
+  if (text.includes("array")) return "array";
+  if (text.includes("anyType")) return "object";
+  return "string";
+}
+function extractEventDefinition(el) {
+  const defs = asElements(el.eventDefinitions);
+  if (defs.length === 0) return void 0;
+  if (defs.length > 1) {
+    return {
+      type: defs.some((def2) => def2.$type === "bpmn:ParallelMultipleEventDefinition") ? "parallelMultiple" : "multiple"
+    };
+  }
+  const [def] = defs;
+  const type = EVENT_DEF_TO_TRIGGER[def.$type];
+  if (!type) return void 0;
+  const eventDefinition = {
+    type,
+    ...asString(def.messageRef?.id) ? { messageRef: def.messageRef.id } : {},
+    ...asString(def.signalRef?.id) ? { signalRef: def.signalRef.id } : {},
+    ...asString(def.errorRef?.id) ? { errorRef: def.errorRef.id } : {},
+    ...asString(def.escalationRef?.id) ? { escalationRef: def.escalationRef.id } : {},
+    ...asString(def.condition?.body) ? { conditionExpression: def.condition.body } : {}
+  };
+  const timeDate = asString(def.timeDate?.body);
+  const timeDuration = asString(def.timeDuration?.body);
+  const timeCycle = asString(def.timeCycle?.body);
+  if (timeDate) eventDefinition.timer = { kind: "date", value: timeDate };
+  else if (timeCycle) eventDefinition.timer = { kind: "cycle", value: timeCycle };
+  else if (timeDuration) eventDefinition.timer = { kind: "duration", value: timeDuration };
+  if (type === "link") {
+    const linkName = asString(el.name) ?? asString(def.name);
+    if (linkName) eventDefinition.linkName = linkName;
+  }
+  return eventDefinition;
+}
+function extractDefinitions(rootElement) {
+  const definitions = {};
+  const rootElements = asElements(rootElement.rootElements);
+  const messages = rootElements.filter((element) => element.$type === "bpmn:Message" && asString(element.id)).map((message) => ({
+    id: message.id,
+    name: asString(message.name) ?? message.id
+  }));
+  if (messages.length > 0) definitions.messages = messages;
+  const signals = rootElements.filter((element) => element.$type === "bpmn:Signal" && asString(element.id)).map((signal) => ({
+    id: signal.id,
+    name: asString(signal.name) ?? signal.id
+  }));
+  if (signals.length > 0) definitions.signals = signals;
+  const errors = rootElements.filter((element) => element.$type === "bpmn:Error" && asString(element.id)).map((error) => ({
+    id: error.id,
+    name: asString(error.name) ?? error.id,
+    ...asString(error.errorCode) ? { errorCode: error.errorCode } : {}
+  }));
+  if (errors.length > 0) definitions.errors = errors;
+  const escalations = rootElements.filter((element) => element.$type === "bpmn:Escalation" && asString(element.id)).map((escalation) => ({
+    id: escalation.id,
+    name: asString(escalation.name) ?? escalation.id,
+    ...asString(escalation.escalationCode) ? { escalationCode: escalation.escalationCode } : {}
+  }));
+  if (escalations.length > 0) definitions.escalations = escalations;
+  const itemDefinitions = asElements(rootElement.itemDefinitions).filter((item) => asString(item.id)).map((item) => ({
+    id: String(item.id).replace(/_item$/, ""),
+    name: String(item.id).replace(/_item$/, ""),
+    type: parseVariableType(item.structureRef)
+  }));
+  if (itemDefinitions.length > 0) definitions.variables = itemDefinitions;
+  return Object.keys(definitions).length > 0 ? definitions : void 0;
+}
 function extractSubProcessVariant(el) {
   if (el.$type === "bpmn:Transaction") return "transaction";
   if (el.$type === "bpmn:AdHocSubProcess") return "adhoc";
@@ -818,6 +893,7 @@ function buildNode(el, elementType, parentId, ctx, nodes) {
   const label = asString(el.name);
   const documentation = extractDocumentation(el);
   const trigger = extractTrigger(el);
+  const eventDefinition = extractEventDefinition(el);
   const isNonInterrupting = el.cancelActivity === false;
   const attachedToRef = el.attachedToRef?.id;
   const data = {
@@ -825,8 +901,17 @@ function buildNode(el, elementType, parentId, ctx, nodes) {
     ...label ? { label } : {},
     ...documentation ? { documentation } : {},
     ...trigger ? { trigger } : {},
+    ...eventDefinition ? { eventDefinition } : {},
     ...isNonInterrupting ? { isNonInterrupting: true } : {},
-    ...attachedToRef ? { attachedToRef } : {}
+    ...elementType === "BoundaryEvent" ? { cancelActivity: el.cancelActivity !== false } : {},
+    ...attachedToRef ? { attachedToRef } : {},
+    ...eventDefinition?.timer ? { timer: eventDefinition.timer, timerExpression: eventDefinition.timer } : {},
+    ...eventDefinition?.messageRef ? { messageRef: eventDefinition.messageRef } : {},
+    ...eventDefinition?.signalRef ? { signalRef: eventDefinition.signalRef } : {},
+    ...eventDefinition?.errorRef ? { errorRef: eventDefinition.errorRef } : {},
+    ...eventDefinition?.escalationRef ? { escalationRef: eventDefinition.escalationRef } : {},
+    ...eventDefinition?.conditionExpression ? { conditionExpression: eventDefinition.conditionExpression } : {},
+    ...eventDefinition?.linkName ? { linkName: eventDefinition.linkName } : {}
   };
   if (elementType === "SubProcess" || elementType === "Transaction" || elementType === "EventSubProcess" || elementType === "AdHocSubProcess") {
     const variant = extractSubProcessVariant(el);
@@ -976,10 +1061,23 @@ async function parseBpmnXml(xml) {
     };
     return { ...edge, data };
   });
+  const firstProcess = asElements(rootElement.rootElements).find((rootEl) => rootEl.$type === "bpmn:Process");
+  const importedDefinitions = extractDefinitions(rootElement);
+  const process = firstProcess ? (() => {
+    const importedProcess = {};
+    const processId = asString(firstProcess.id);
+    const documentation = extractDocumentation(firstProcess);
+    if (processId) importedProcess.processId = processId;
+    if (typeof firstProcess.isExecutable === "boolean") importedProcess.executable = firstProcess.isExecutable;
+    if (documentation) importedProcess.documentation = documentation;
+    if (importedDefinitions) importedProcess.definitions = importedDefinitions;
+    return importedProcess;
+  })() : importedDefinitions ? { definitions: importedDefinitions } : void 0;
   return {
     nodes: normalizeChildPositions(nodes, nodeIds),
     edges: normalizedEdges,
-    warnings
+    warnings,
+    ...process ? { process } : {}
   };
 }
 function collectDefaultFlows(el, defaultFlowById) {
@@ -1009,6 +1107,99 @@ function uid(prefix, id) {
 function asNodes(nodes, types) {
   return nodes.filter((n) => types.includes(n.data.elementType));
 }
+function normalizeEventDefinition(data) {
+  const trigger = data.eventDefinition?.type ?? data.trigger;
+  if (!trigger || trigger === "none") return void 0;
+  const normalized = { type: trigger };
+  const timer = data.eventDefinition?.timer ?? data.timer ?? data.timerExpression;
+  const messageRef = data.eventDefinition?.messageRef ?? (typeof data.messageRef === "string" ? data.messageRef : void 0);
+  const signalRef = data.eventDefinition?.signalRef ?? (typeof data.signalRef === "string" ? data.signalRef : void 0);
+  const errorRef = data.eventDefinition?.errorRef ?? (typeof data.errorRef === "string" ? data.errorRef : void 0);
+  const escalationRef = data.eventDefinition?.escalationRef ?? (typeof data.escalationRef === "string" ? data.escalationRef : void 0);
+  const conditionExpression = data.eventDefinition?.conditionExpression ?? (typeof data.conditionExpression === "string" ? data.conditionExpression : void 0);
+  const linkName = data.eventDefinition?.linkName ?? (typeof data.linkName === "string" ? data.linkName : void 0);
+  if (timer) normalized.timer = timer;
+  if (messageRef) normalized.messageRef = messageRef;
+  if (signalRef) normalized.signalRef = signalRef;
+  if (errorRef) normalized.errorRef = errorRef;
+  if (escalationRef) normalized.escalationRef = escalationRef;
+  if (conditionExpression) normalized.conditionExpression = conditionExpression;
+  if (linkName) normalized.linkName = linkName;
+  return normalized;
+}
+function parseVariableType2(type) {
+  switch (type) {
+    case "integer":
+      return "xsd:int";
+    case "boolean":
+      return "xsd:boolean";
+    case "date":
+      return "xsd:dateTime";
+    case "object":
+      return "xsd:anyType";
+    case "array":
+      return "xsd:anyType";
+    default:
+      return "xsd:string";
+  }
+}
+function buildGlobalDefinitions(moddle, definitionsSet) {
+  if (!definitionsSet) return [];
+  const rootElements = [];
+  for (const message of definitionsSet.messages ?? []) {
+    rootElements.push(moddle.create("bpmn:Message", { id: message.id, name: message.name }));
+  }
+  for (const signal of definitionsSet.signals ?? []) {
+    rootElements.push(moddle.create("bpmn:Signal", { id: signal.id, name: signal.name }));
+  }
+  for (const error of definitionsSet.errors ?? []) {
+    rootElements.push(moddle.create("bpmn:Error", {
+      id: error.id,
+      name: error.name,
+      ...error.errorCode ? { errorCode: error.errorCode } : {}
+    }));
+  }
+  for (const escalation of definitionsSet.escalations ?? []) {
+    rootElements.push(moddle.create("bpmn:Escalation", {
+      id: escalation.id,
+      name: escalation.name,
+      ...escalation.escalationCode ? { escalationCode: escalation.escalationCode } : {}
+    }));
+  }
+  return rootElements;
+}
+function buildItemDefinitions(moddle, variables) {
+  return (variables ?? []).map(
+    (variable) => moddle.create("bpmn:ItemDefinition", {
+      id: `${variable.id}_item`,
+      itemKind: "Information",
+      structureRef: parseVariableType2(variable.type)
+    })
+  );
+}
+function buildEventDefinitions(moddle, node, eventDefinition) {
+  if (eventDefinition.type === "multiple" || eventDefinition.type === "parallelMultiple") {
+    return [];
+  }
+  const defType = TRIGGER_TO_EVENT_DEF[eventDefinition.type];
+  if (!defType) return [];
+  const attrs = { id: uid("EventDef", node.id) };
+  if (eventDefinition.messageRef) attrs.messageRef = { id: eventDefinition.messageRef };
+  if (eventDefinition.signalRef) attrs.signalRef = { id: eventDefinition.signalRef };
+  if (eventDefinition.errorRef) attrs.errorRef = { id: eventDefinition.errorRef };
+  if (eventDefinition.escalationRef) attrs.escalationRef = { id: eventDefinition.escalationRef };
+  if (eventDefinition.conditionExpression) {
+    attrs.condition = moddle.create("bpmn:FormalExpression", {
+      body: eventDefinition.conditionExpression
+    });
+  }
+  if (eventDefinition.timer?.value) {
+    attrs[eventDefinition.timer.kind === "date" ? "timeDate" : eventDefinition.timer.kind === "cycle" ? "timeCycle" : "timeDuration"] = moddle.create("bpmn:FormalExpression", {
+      body: eventDefinition.timer.value
+    });
+  }
+  return [moddle.create(defType, attrs)];
+}
 function buildSemanticModel(moddle, nodes, edges, opts) {
   const defId = opts.id ?? "Definitions_1";
   const defName = opts.name;
@@ -1020,13 +1211,19 @@ function buildSemanticModel(moddle, nodes, edges, opts) {
     targetNamespace: "http://bpmn.io/schema/bpmn",
     ...defName ? { name: defName } : {}
   });
-  const rootElements = [];
+  const rootElements = [
+    ...buildGlobalDefinitions(moddle, opts.process?.definitions)
+  ];
+  const itemDefinitions = buildItemDefinitions(moddle, opts.process?.definitions?.variables);
+  if (itemDefinitions.length > 0) {
+    definitions.itemDefinitions = itemDefinitions;
+  }
   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);
+      const process = buildProcess(moddle, nodes, edges, pool.id, laneNodes, processId, opts);
       processes.push(process);
       const participant = moddle.create("bpmn:Participant", {
         id: pool.id,
@@ -1060,13 +1257,21 @@ function buildSemanticModel(moddle, nodes, edges, opts) {
     });
     rootElements.push(collaboration, ...processes);
   } else {
-    const process = buildProcess(moddle, nodes, edges, void 0, laneNodes, "Process_1");
+    const process = buildProcess(
+      moddle,
+      nodes,
+      edges,
+      void 0,
+      laneNodes,
+      opts.process?.processId ?? "Process_1",
+      opts
+    );
     rootElements.push(process);
   }
   definitions.rootElements = rootElements;
   return definitions;
 }
-function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId) {
+function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId, opts) {
   const subProcessIds = new Set(
     allNodes.filter(
       (n) => n.data.elementType === "SubProcess" || n.data.elementType === "Transaction" || n.data.elementType === "EventSubProcess" || n.data.elementType === "AdHocSubProcess"
@@ -1116,9 +1321,14 @@ function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId)
   }
   const process = moddle.create("bpmn:Process", {
     id: processId,
-    isExecutable: true,
+    isExecutable: opts.process?.executable ?? true,
     flowElements
   });
+  if (opts.process?.documentation) {
+    process.documentation = [
+      moddle.create("bpmn:Documentation", { text: opts.process.documentation })
+    ];
+  }
   if (myLanes.length > 0) {
     const laneElements = myLanes.map(
       (l) => moddle.create("bpmn:Lane", {
@@ -1135,7 +1345,8 @@ function buildProcess(moddle, allNodes, allEdges, poolId, laneNodes, processId)
   return process;
 }
 function buildFlowElement(moddle, node, allNodes, allEdges) {
-  const { elementType, label, trigger } = node.data;
+  const { elementType, label } = node.data;
+  const eventDefinition = normalizeEventDefinition(node.data);
   if (elementType === "Pool" || elementType === "Lane") return null;
   const moddleType = ELEMENT_TYPE_TO_MODDLE[elementType];
   if (!moddleType) return null;
@@ -1148,15 +1359,15 @@ function buildFlowElement(moddle, node, allNodes, allEdges) {
       moddle.create("bpmn:Documentation", { text: node.data.documentation })
     ];
   }
-  if (trigger && trigger !== "none") {
-    const defType = TRIGGER_TO_EVENT_DEF[trigger];
-    if (defType) {
-      attrs.eventDefinitions = [moddle.create(defType, { id: uid("EventDef", node.id) })];
-    }
+  if (eventDefinition) {
+    const eventDefinitions = buildEventDefinitions(moddle, node, eventDefinition);
+    if (eventDefinitions.length > 0) attrs.eventDefinitions = eventDefinitions;
+    if (eventDefinition.linkName) attrs.name = eventDefinition.linkName;
   }
   if (elementType === "BoundaryEvent") {
     attrs.attachedToRef = { id: node.data.attachedToRef ?? node.parentId };
-    attrs.cancelActivity = node.data.isNonInterrupting ? false : true;
+    const interrupting = node.data.cancelActivity ?? !node.data.isNonInterrupting;
+    attrs.cancelActivity = interrupting;
   }
   const isSubProcess = elementType === "SubProcess" || elementType === "Transaction" || elementType === "EventSubProcess" || elementType === "AdHocSubProcess";
   if (isSubProcess) {