bpmn-elements 17.2.2 → 18.0.0

package/src/shared.js

@@ -8,6 +8,7 @@ export function brokerSafeId(id) {
   return id.replace(safePattern, '_');
 }
 
+/** @param {string} prefix */
 export function getUniqueId(prefix) {
   return `${brokerSafeId(prefix)}_${generateId()}`;
 }

package/src/tasks/CallActivity.js

@@ -1,16 +1,26 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { ActivityError } from '../error/Errors.js';
 import { cloneContent } from '../messageHelper.js';
 
-export default function CallActivity(activityDef, context) {
+/**
+ * Call activity
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function CallActivity(activityDef, context) {
   return new Activity(CallActivityBehaviour, activityDef, context);
 }
 
+/**
+ * Call activity behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function CallActivityBehaviour(activity) {
   const { id, type, behaviour = {} } = activity;
   this.id = id;
   this.type = type;
   this.calledElement = behaviour.calledElement;
+  /** @type {import('./LoopCharacteristics.js').LoopCharacteristics | undefined} */
   this.loopCharacteristics =
     behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
@@ -18,6 +28,10 @@ export function CallActivityBehaviour(activity) {
   this.environment = activity.environment;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 CallActivityBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;

package/src/tasks/LoopCharacteristics.js

@@ -1,18 +1,26 @@
 import { RunError } from '../error/Errors.js';
 import { cloneContent, cloneMessage, unshiftParent, cloneParent } from '../messageHelper.js';
 
-export default function LoopCharacteristics(activity, loopCharacteristics) {
+/**
+ * Loop characteristics
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').SerializableElement} loopCharacteristics
+ */
+export function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;
   this.loopCharacteristics = loopCharacteristics;
   const { type = 'LoopCharacteristics', behaviour = {} } = loopCharacteristics;
   this.type = type;
   const { isSequential = false, collection } = behaviour;
+  /** @type {boolean} */
   this.isSequential = isSequential;
+  /** @type {string | undefined} */
   this.collection = collection;
 
   let completionCondition, startCondition, loopCardinality;
   if ('loopCardinality' in behaviour) loopCardinality = behaviour.loopCardinality;
   else if ('loopMaximum' in behaviour) loopCardinality = behaviour.loopMaximum;
+  /** @type {number | undefined} */
   this.loopCardinality = loopCardinality;
 
   if (behaviour.loopCondition) {
@@ -25,15 +33,21 @@ export default function LoopCharacteristics(activity, loopCharacteristics) {
 
   if (collection) {
     this.loopType = 'collection';
+    /** @type {string | undefined} */
     this.elementVariable = behaviour.elementVariable || 'item';
   } else if (completionCondition) this.loopType = 'complete condition';
   else if (startCondition) this.loopType = 'start condition';
   else if (loopCardinality) this.loopType = 'cardinality';
 
+  /** @type {Characteristics} */
   this.characteristics = null;
   this.execution = null;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 LoopCharacteristics.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new TypeError('LoopCharacteristics execution requires message');
   const chr = (this.characteristics = this.characteristics || new Characteristics(this.activity, this.loopCharacteristics, executeMessage));
@@ -45,12 +59,20 @@ LoopCharacteristics.prototype.execute = function execute(executeMessage) {
   return execution.execute(executeMessage);
 };
 
+/**
+ * @param {import('#types').Activity} activity
+ * @param {Characteristics} characteristics
+ */
 function SequentialLoopCharacteristics(activity, characteristics) {
   this.activity = activity;
   this.id = activity.id;
   this.characteristics = characteristics;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 SequentialLoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const { routingKey: executeRoutingKey, redelivered: isRedelivered } = executeMessage.fields || {};
   const chr = this.characteristics;
@@ -73,11 +95,11 @@ SequentialLoopCharacteristics.prototype._startNext = function startNext(index, i
   if (!content) return;
 
   if (chr.isStartConditionMet({ content })) {
-    chr.debug('start condition met');
+    chr._debug('start condition met');
     return;
   }
 
-  chr.debug(`${ignoreIfExecuting ? 'resume' : 'start'} sequential iteration index ${content.index}`);
+  chr._debug(`${ignoreIfExecuting ? 'resume' : 'start'} sequential iteration index ${content.index}`);
   const broker = this.activity.broker;
   broker.publish('execution', 'execute.iteration.next', {
     ...content,
@@ -108,14 +130,18 @@ SequentialLoopCharacteristics.prototype._onCompleteMessage = function onComplete
   });
 
   if (chr.isCompletionConditionMet(message, loopOutput)) {
-    chr.debug('complete condition met');
+    chr._debug('complete condition met');
   } else if (this._startNext(content.index + 1)) return;
 
-  chr.debug('sequential loop completed');
+  chr._debug('sequential loop completed');
 
   return chr.complete(content);
 };
 
+/**
+ * @param {import('#types').Activity} activity
+ * @param {Characteristics} characteristics
+ */
 function ParallelLoopCharacteristics(activity, characteristics) {
   this.activity = activity;
   this.id = activity.id;
@@ -125,6 +151,10 @@ function ParallelLoopCharacteristics(activity, characteristics) {
   this.discarded = 0;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const chr = this.characteristics;
   if (!chr.cardinality) throw new RunError(`<${this.id}> cardinality or collection is required in parallel loops`, executeMessage);
@@ -150,7 +180,7 @@ ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
 
   let startContent = chr.next(this.index);
   do {
-    chr.debug(`start parallel iteration index ${this.index}`);
+    chr._debug(`start parallel iteration index ${this.index}`);
     batch.add(startContent);
     this.running++;
     this.index++;
@@ -211,6 +241,12 @@ ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMe
   }
 };
 
+/**
+ * Per-execution snapshot of resolved loop characteristics (cardinality, collection, conditions).
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').SerializableElement} loopCharacteristics
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.activity = activity;
   const behaviour = (this.behaviour = loopCharacteristics.behaviour || {});
@@ -221,27 +257,31 @@ function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.broker = activity.broker;
   this.parentExecutionId = executeMessage.content.executionId;
 
+  /** @type {boolean} */
   this.isSequential = behaviour.isSequential || false;
   this.output = executeMessage.content.output || [];
   this.parent = unshiftParent(executeMessage.content.parent, executeMessage.content);
 
-  if ('loopCardinality' in behaviour) this.loopCardinality = behaviour.loopCardinality;
-  else if ('loopMaximum' in behaviour) this.loopCardinality = behaviour.loopMaximum;
+  if ('loopCardinality' in behaviour) this.loopCardinality = /** @type {number} */ (behaviour.loopCardinality);
+  else if ('loopMaximum' in behaviour) this.loopCardinality = /** @type {number} */ (behaviour.loopMaximum);
 
   if (behaviour.loopCondition) {
-    if (behaviour.testBefore) this.startCondition = behaviour.loopCondition;
-    else this.completionCondition = behaviour.loopCondition;
+    if (behaviour.testBefore) this.startCondition = /** @type {string} */ (behaviour.loopCondition);
+    else this.completionCondition = /** @type {string} */ (behaviour.loopCondition);
   }
   if (behaviour.completionCondition) {
+    /** @type {string} */
     this.completionCondition = behaviour.completionCondition;
   }
 
   const collection = (this.collection = this.getCollection());
   if (collection) {
+    /** @type {string} */
     this.elementVariable = behaviour.elementVariable || 'item';
   }
   this.cardinality = this.getCardinality(collection);
 
+  /** @private */
   this.onApiMessage = this.onApiMessage.bind(this);
 
   const environment = activity.environment;
@@ -249,6 +289,7 @@ function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.batchSize = environment.settings.batchSize || 50;
 }
 
+/** @returns {import('#types').ElementMessageContent} */
 Characteristics.prototype.getContent = function getContent() {
   return {
     ...cloneContent(this.message.content),
@@ -258,6 +299,10 @@ Characteristics.prototype.getContent = function getContent() {
   };
 };
 
+/**
+ * @param {number} index
+ * @returns {import('#types').ElementMessageContent}
+ */
 Characteristics.prototype.next = function next(index) {
   const cardinality = this.cardinality;
   if (cardinality > 0 && index >= cardinality) return;
@@ -281,6 +326,10 @@ Characteristics.prototype.next = function next(index) {
   return content;
 };
 
+/**
+ * @param {any} [collection]
+ * @returns {number | undefined} cardinality
+ */
 Characteristics.prototype.getCardinality = function getCardinality(collection) {
   const collectionLen = this.collection && Array.isArray(collection) ? collection.length : undefined;
   if (!this.loopCardinality) {
@@ -294,22 +343,34 @@ Characteristics.prototype.getCardinality = function getCardinality(collection) {
   return Number(value);
 };
 
+/** @returns {Array | undefined} */
 Characteristics.prototype.getCollection = function getCollection() {
   const collectionExpression = this.behaviour.collection;
   if (!collectionExpression) return;
   return this.activity.environment.resolveExpression(collectionExpression, this.message);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 Characteristics.prototype.isStartConditionMet = function isStartConditionMet(message) {
   if (!this.startCondition) return false;
   return this.activity.environment.resolveExpression(this.startCondition, cloneMessage(message));
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 Characteristics.prototype.isCompletionConditionMet = function isCompletionConditionMet(message) {
   if (!this.completionCondition) return false;
   return this.activity.environment.resolveExpression(this.completionCondition, cloneMessage(message, { loopOutput: this.output }));
 };
 
+/**
+ * @param {import('#types').ElementMessageContent} content
+ * @param {boolean} [allDiscarded]
+ * @returns {void}
+ */
 Characteristics.prototype.complete = function complete(content, allDiscarded) {
   this.stop();
 
@@ -320,6 +381,9 @@ Characteristics.prototype.complete = function complete(content, allDiscarded) {
   });
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} onIterationCompleteMessage
+ */
 Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMessage) {
   this.broker.subscribeTmp(
     'api',
@@ -346,6 +410,7 @@ Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMess
   }
 };
 
+/** @internal */
 Characteristics.prototype.onApiMessage = function onApiMessage(_, message) {
   switch (message.properties.type) {
     case 'stop':
@@ -360,6 +425,7 @@ Characteristics.prototype.stop = function stop() {
   this.broker.cancel('_api-multi-instance-tag');
 };
 
-Characteristics.prototype.debug = function debug(msg) {
+/** @internal */
+Characteristics.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.parentExecutionId} (${this.id})> ${msg}`);
 };

package/src/tasks/ReceiveTask.js

@@ -1,12 +1,13 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { cloneContent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
-
-export default function ReceiveTask(activityDef, context) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_REFERENCE_ELEMENT, K_REFERENCE_INFO } from '../constants.js';
+
+/**
+ * Receive task
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function ReceiveTask(activityDef, context) {
   const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
 
   task.broker.assertQueue('message', { autoDelete: false, durable: true });
@@ -15,26 +16,36 @@ export default function ReceiveTask(activityDef, context) {
   return task;
 }
 
+/**
+ * Receive task behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function ReceiveTaskBehaviour(activity) {
   const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.messageRef,
     referenceType: 'message',
-  });
+  };
 
+  /** @type {import('./LoopCharacteristics.js').LoopCharacteristics | undefined } */
   this.loopCharacteristics =
     behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.broker = activity.broker;
 
-  this[kReferenceElement] = reference.id && activity.getActivityById(reference.id);
+  this[K_REFERENCE_ELEMENT] = this.reference.id && activity.getActivityById(this.reference.id);
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
   return new ReceiveTaskExecution(this).execute(executeMessage);
 };
@@ -47,19 +58,19 @@ function ReceiveTaskExecution(parent) {
   this.reference = reference;
   this.broker = broker;
   this.loopCharacteristics = loopCharacteristics;
-  this.referenceElement = parent[kReferenceElement];
+  this.referenceElement = parent[K_REFERENCE_ELEMENT];
 
-  this[kCompleted] = false;
+  this[K_COMPLETED] = false;
 }
 
 ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
 
   const executeContent = executeMessage.content;
   const { executionId, isRootScope } = executeContent;
   this.executionId = executionId;
 
-  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
+  const info = (this[K_REFERENCE_INFO] = this._getReferenceInfo(executeMessage));
 
   if (isRootScope) {
     this._setupMessageHandling(executionId);
@@ -76,7 +87,7 @@ ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
     consumerTag: `_onmessage-${executionId}`,
   });
 
-  if (this[kCompleted]) return;
+  if (this[K_COMPLETED]) return;
 
   broker.subscribeTmp('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
     noAck: true,
@@ -93,7 +104,7 @@ ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routing
   const content = message.content;
 
   const { id: signalId, executionId: signalExecutionId } = content.message || {};
-  const { message: referenceMessage, description } = this[kReferenceInfo];
+  const { message: referenceMessage, description } = this[K_REFERENCE_INFO];
 
   if ((!referenceMessage.id && signalId) || signalExecutionId) {
     if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
@@ -106,7 +117,7 @@ ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routing
 
   const { type: messageType, correlationId } = message.properties;
   const broker = this.broker;
-  const executeContent = this[kExecuteMessage].content;
+  const executeContent = this[K_EXECUTE_MESSAGE].content;
 
   broker.publish('event', 'activity.consumed', cloneContent(executeContent, { message: { ...message.content.message } }), {
     correlationId,
@@ -128,9 +139,9 @@ ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey,
       return this._complete(message.content.message, { correlationId });
     }
     case 'discard': {
-      this[kCompleted] = true;
+      this[K_COMPLETED] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), { correlationId });
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_EXECUTE_MESSAGE].content), { correlationId });
     }
     case 'stop': {
       return this._stop();
@@ -139,9 +150,9 @@ ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey,
 };
 
 ReceiveTaskExecution.prototype._complete = function complete(output, options) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this._stop();
-  return this.broker.publish('execution', 'execute.completed', cloneContent(this[kExecuteMessage].content, { output }), options);
+  return this.broker.publish('execution', 'execute.completed', cloneContent(this[K_EXECUTE_MESSAGE].content, { output }), options);
 };
 
 ReceiveTaskExecution.prototype._stop = function stop() {

package/src/tasks/ScriptTask.js

@@ -1,12 +1,21 @@
-import Activity from '../activity/Activity.js';
-import ExecutionScope from '../activity/ExecutionScope.js';
+import { Activity } from '../activity/Activity.js';
+import { ExecutionScope } from '../activity/ExecutionScope.js';
 import { ActivityError } from '../error/Errors.js';
 import { cloneContent, cloneMessage } from '../messageHelper.js';
 
-export default function ScriptTask(activityDef, context) {
+/**
+ * Script task
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function ScriptTask(activityDef, context) {
   return new Activity(ScriptTaskBehaviour, activityDef, context);
 }
 
+/**
+ * Script task behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function ScriptTaskBehaviour(activity) {
   const { id, type, behaviour } = activity;
 
@@ -14,6 +23,7 @@ export function ScriptTaskBehaviour(activity) {
   this.type = type;
   this.scriptFormat = behaviour.scriptFormat;
 
+  /** @type {import('./LoopCharacteristics.js').LoopCharacteristics | undefined} */
   this.loopCharacteristics =
     behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
@@ -22,6 +32,10 @@ export function ScriptTaskBehaviour(activity) {
   environment.registerScript(activity);
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ScriptTaskBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;

package/src/tasks/ServiceImplementation.js

@@ -1,6 +1,9 @@
-import ExecutionScope from '../activity/ExecutionScope.js';
-
-export default function ServiceImplementation(activity) {
+import { ExecutionScope } from '../activity/ExecutionScope.js';
+/**
+ * Service implementation
+ * @param {import('#types').Activity} activity
+ */
+export function ServiceImplementation(activity) {
   this.type = `${activity.type}:implementation`;
   this.implementation = activity.behaviour.implementation;
   this.activity = activity;

package/src/tasks/ServiceTask.js

@@ -1,16 +1,26 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { ActivityError } from '../error/Errors.js';
 import { cloneMessage, cloneContent } from '../messageHelper.js';
 
-export default function ServiceTask(activityDef, context) {
+/**
+ * Service task
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function ServiceTask(activityDef, context) {
   return new Activity(ServiceTaskBehaviour, activityDef, context);
 }
 
+/**
+ * Service task behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function ServiceTaskBehaviour(activity) {
   const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
+  /** @type {import('./LoopCharacteristics.js').LoopCharacteristics | undefined} */
   this.loopCharacteristics =
     behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
@@ -18,6 +28,10 @@ export function ServiceTaskBehaviour(activity) {
   this.broker = activity.broker;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ServiceTaskBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;

package/src/tasks/SignalTask.js

@@ -1,22 +1,36 @@
-import Activity from '../activity/Activity.js';
+import { Activity } from '../activity/Activity.js';
 import { ActivityError } from '../error/Errors.js';
 import { cloneContent } from '../messageHelper.js';
 
-export default function SignalTask(activityDef, context) {
+/**
+ * Signal task
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function SignalTask(activityDef, context) {
   return new Activity(SignalTaskBehaviour, activityDef, context);
 }
 
+/**
+ * Signal task behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function SignalTaskBehaviour(activity) {
   const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
+  /** @type {import('./LoopCharacteristics.js').LoopCharacteristics | undefined} */
   this.loopCharacteristics =
     behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.broker = activity.broker;
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 SignalTaskBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;

package/src/tasks/StandardLoopCharacteristics.js

@@ -1,6 +1,10 @@
-import LoopCharacteristics from './LoopCharacteristics.js';
-
-export default function StandardLoopCharacteristics(activity, loopCharacteristics) {
+import { LoopCharacteristics } from './LoopCharacteristics.js';
+/**
+ * Standard loop characteristics
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').SerializableElement} loopCharacteristics
+ */
+export function StandardLoopCharacteristics(activity, loopCharacteristics) {
   let { behaviour } = loopCharacteristics;
   behaviour = { ...behaviour, isSequential: true };
   return new LoopCharacteristics(activity, { ...loopCharacteristics, behaviour });