@aranzatech/diagrams-bpmn 0.2.4 → 0.2.6

package/dist/xml/index.cjs

@@ -1,8 +1,25 @@
 'use strict';
 
-var bpmnModdle = require('bpmn-moddle');
-
-// src/xml/importer.ts
+// src/xml/aranza-descriptor.ts
+var ARANZA_DESCRIPTOR = {
+  name: "Aranza",
+  uri: "http://aranzatech.io/schema/bpmn-extension/1.0",
+  prefix: "aranza",
+  xml: { tagAlias: "lowerCase" },
+  types: [
+    {
+      name: "TaskConfig",
+      superClass: ["Element"],
+      properties: [
+        { name: "priority", isAttr: true, type: "String" },
+        { name: "owner", isAttr: true, type: "String" },
+        { name: "sla", isAttr: true, type: "String" }
+      ]
+    }
+  ],
+  enumerations: [],
+  associations: []
+};
 
 // src/elements/catalog.ts
 var BPMN_ELEMENT_CATALOG = {
@@ -775,9 +792,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";
@@ -785,6 +877,22 @@ function extractSubProcessVariant(el) {
   if (el.triggeredByEvent === true) return "event";
   return "embedded";
 }
+function extractAranzaExtensions(el) {
+  const ext = el.extensionElements;
+  if (!ext) return {};
+  const taskConfig = asElements(ext.values).find((v) => v.$type === "aranza:TaskConfig");
+  if (!taskConfig) return {};
+  const result = {};
+  const priority = asString(taskConfig.priority);
+  if (priority === "critical" || priority === "high" || priority === "medium" || priority === "low") {
+    result.priority = priority;
+  }
+  const owner = asString(taskConfig.owner);
+  if (owner) result.owner = owner;
+  const sla = asString(taskConfig.sla);
+  if (sla) result.sla = sla;
+  return result;
+}
 function walkFlowElements(elements, parentId, ctx, nodes, edges) {
   for (const el of elements) {
     const { $type, id } = el;
@@ -818,15 +926,29 @@ 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 calledElement = elementType === "CallActivity" ? asString(el.calledElement) : void 0;
+  const aranzaExt = extractAranzaExtensions(el);
   const data = {
     elementType,
     ...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 } : {},
+    ...calledElement ? { calledElement } : {},
+    ...aranzaExt
   };
   if (elementType === "SubProcess" || elementType === "Transaction" || elementType === "EventSubProcess" || elementType === "AdHocSubProcess") {
     const variant = extractSubProcessVariant(el);
@@ -926,7 +1048,8 @@ function addLaneNodes(laneSet, poolId, ctx, nodes) {
   }
 }
 async function parseBpmnXml(xml) {
-  const moddle = new bpmnModdle.BpmnModdle();
+  const { BpmnModdle } = await import('bpmn-moddle');
+  const moddle = new BpmnModdle({ aranza: ARANZA_DESCRIPTOR });
   const warnings = [];
   let rootElement;
   try {
@@ -976,10 +1099,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) {
@@ -1003,12 +1139,117 @@ function normalizeChildPositions(nodes, nodeIds) {
     };
   });
 }
+
+// src/xml/exporter.ts
 function uid(prefix, id) {
   return `${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 buildAranzaExtensionElements(moddle, node) {
+  const { priority, owner, sla } = node.data;
+  if (!priority && !owner && !sla) return null;
+  const configAttrs = {};
+  if (priority) configAttrs.priority = priority;
+  if (owner) configAttrs.owner = owner;
+  if (sla) configAttrs.sla = sla;
+  const taskConfig = moddle.create("aranza:TaskConfig", configAttrs);
+  return moddle.create("bpmn:ExtensionElements", { values: [taskConfig] });
+}
 function buildSemanticModel(moddle, nodes, edges, opts) {
   const defId = opts.id ?? "Definitions_1";
   const defName = opts.name;
@@ -1020,13 +1261,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 +1307,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 +1371,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 +1395,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,16 +1409,21 @@ 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;
+  }
+  if (elementType === "CallActivity" && node.data.calledElement) {
+    attrs.calledElement = node.data.calledElement;
   }
+  const aranzaConfig = buildAranzaExtensionElements(moddle, node);
+  if (aranzaConfig) attrs.extensionElements = aranzaConfig;
   const isSubProcess = elementType === "SubProcess" || elementType === "Transaction" || elementType === "EventSubProcess" || elementType === "AdHocSubProcess";
   if (isSubProcess) {
     attrs.flowElements = buildNestedFlowElements(moddle, node, allNodes, allEdges);
@@ -1295,7 +1561,8 @@ function buildAbsolutePositionMap(nodes) {
   return absoluteById;
 }
 async function serializeBpmnXml(nodes, edges, opts = {}) {
-  const moddle = new bpmnModdle.BpmnModdle();
+  const { BpmnModdle } = await import('bpmn-moddle');
+  const moddle = new BpmnModdle({ aranza: ARANZA_DESCRIPTOR });
   const definitions = buildSemanticModel(moddle, nodes, edges, opts);
   buildBpmnDI(moddle, definitions, nodes, edges);
   const { xml } = await moddle.toXML(definitions, {