bpmn-elements 13.1.2 → 14.0.0

package/src/tasks/LoopCharacteristics.js

@@ -1,12 +1,12 @@
-import {RunError} from '../error/Errors.js';
-import {cloneContent, cloneMessage, unshiftParent, cloneParent} from '../messageHelper.js';
+import { RunError } from '../error/Errors.js';
+import { cloneContent, cloneMessage, unshiftParent, cloneParent } from '../messageHelper.js';
 
 export default function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;
   this.loopCharacteristics = loopCharacteristics;
-  const {type = 'LoopCharacteristics', behaviour = {}} = loopCharacteristics;
+  const { type = 'LoopCharacteristics', behaviour = {} } = loopCharacteristics;
   this.type = type;
-  const {isSequential = false, collection} = behaviour;
+  const { isSequential = false, collection } = behaviour;
   this.isSequential = isSequential;
   this.collection = collection;
 
@@ -36,10 +36,12 @@ export default function LoopCharacteristics(activity, loopCharacteristics) {
 
 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);
+  const chr = (this.characteristics = this.characteristics || new Characteristics(this.activity, this.loopCharacteristics, executeMessage));
   if (chr.cardinality === 0) return chr.complete();
 
-  const execution = this.isSequential ? new SequentialLoopCharacteristics(this.activity, chr) : new ParallelLoopCharacteristics(this.activity, chr);
+  const execution = this.isSequential
+    ? new SequentialLoopCharacteristics(this.activity, chr)
+    : new ParallelLoopCharacteristics(this.activity, chr);
   return execution.execute(executeMessage);
 };
 
@@ -50,7 +52,7 @@ function SequentialLoopCharacteristics(activity, characteristics) {
 }
 
 SequentialLoopCharacteristics.prototype.execute = function execute(executeMessage) {
-  const {routingKey: executeRoutingKey, redelivered: isRedelivered} = executeMessage.fields || {};
+  const { routingKey: executeRoutingKey, redelivered: isRedelivered } = executeMessage.fields || {};
   const chr = this.characteristics;
   if (!chr.cardinality && !chr.startCondition && !chr.completionCondition) {
     throw new RunError(`<${this.id}> cardinality, collection, or condition is required in sequential loops`, executeMessage);
@@ -70,7 +72,7 @@ SequentialLoopCharacteristics.prototype._startNext = function startNext(index, i
   const content = chr.next(index);
   if (!content) return;
 
-  if (chr.isStartConditionMet({content})) {
+  if (chr.isStartConditionMet({ content })) {
     chr.debug('start condition met');
     return;
   }
@@ -86,12 +88,12 @@ SequentialLoopCharacteristics.prototype._startNext = function startNext(index, i
     state: 'iteration.next',
   });
 
-  broker.publish('execution', 'execute.start', {...content, ignoreIfExecuting});
+  broker.publish('execution', 'execute.start', { ...content, ignoreIfExecuting });
   return content;
 };
 
 SequentialLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
-  const {content} = message;
+  const { content } = message;
   const chr = this.characteristics;
   const loopOutput = chr.output;
 
@@ -175,7 +177,7 @@ ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
 
 ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(routingKey, message) {
   const chr = this.characteristics;
-  const {content} = message;
+  const { content } = message;
   if (content.output !== undefined) chr.output[content.index] = content.output;
 
   if (routingKey === 'execute.discard') {
@@ -211,10 +213,10 @@ ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMe
 
 function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.activity = activity;
-  const behaviour = this.behaviour = loopCharacteristics.behaviour || {};
+  const behaviour = (this.behaviour = loopCharacteristics.behaviour || {});
   this.message = executeMessage;
 
-  const type = this.type = loopCharacteristics.type || 'LoopCharacteristics';
+  const type = (this.type = loopCharacteristics.type || 'LoopCharacteristics');
   this.id = activity.id;
   this.broker = activity.broker;
   this.parentExecutionId = executeMessage.content.executionId;
@@ -234,7 +236,7 @@ function Characteristics(activity, loopCharacteristics, executeMessage) {
     this.completionCondition = behaviour.completionCondition;
   }
 
-  const collection = this.collection = this.getCollection();
+  const collection = (this.collection = this.getCollection());
   if (collection) {
     this.elementVariable = behaviour.elementVariable || 'item';
   }
@@ -285,7 +287,7 @@ Characteristics.prototype.getCardinality = function getCardinality(collection) {
     return collectionLen;
   }
   const value = this.activity.environment.resolveExpression(this.loopCardinality, this.message);
-  if (value !== undefined && isNaN(value) || value < 0) {
+  if ((value !== undefined && isNaN(value)) || value < 0) {
     throw new RunError(`<${this.id}> invalid loop cardinality >${value}<`, this.message);
   }
   if (value === undefined) return collectionLen;
@@ -305,7 +307,7 @@ Characteristics.prototype.isStartConditionMet = function isStartConditionMet(mes
 
 Characteristics.prototype.isCompletionConditionMet = function isCompletionConditionMet(message) {
   if (!this.completionCondition) return false;
-  return this.activity.environment.resolveExpression(this.completionCondition, cloneMessage(message, {loopOutput: this.output}));
+  return this.activity.environment.resolveExpression(this.completionCondition, cloneMessage(message, { loopOutput: this.output }));
 };
 
 Characteristics.prototype.complete = function complete(content, allDiscarded) {
@@ -319,8 +321,18 @@ Characteristics.prototype.complete = function complete(content, allDiscarded) {
 };
 
 Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMessage) {
-  this.broker.subscribeTmp('api', `activity.*.${this.parentExecutionId}`, this.onApiMessage, {noAck: true, consumerTag: '_api-multi-instance-tag'}, {priority: 400});
-  this.broker.subscribeTmp('execution', 'execute.*', onComplete, {noAck: true, consumerTag: '_execute-q-multi-instance-tag', priority: 300});
+  this.broker.subscribeTmp(
+    'api',
+    `activity.*.${this.parentExecutionId}`,
+    this.onApiMessage,
+    { noAck: true, consumerTag: '_api-multi-instance-tag' },
+    { priority: 400 },
+  );
+  this.broker.subscribeTmp('execution', 'execute.*', onComplete, {
+    noAck: true,
+    consumerTag: '_execute-q-multi-instance-tag',
+    priority: 300,
+  });
 
   function onComplete(routingKey, message, ...args) {
     if (!message.content.isMultiInstance) return;

package/src/tasks/ReceiveTask.js

@@ -1,5 +1,5 @@
 import Activity from '../activity/Activity.js';
-import {cloneContent} from '../messageHelper.js';
+import { cloneContent } from '../messageHelper.js';
 
 const kCompleted = Symbol.for('completed');
 const kExecuteMessage = Symbol.for('executeMessage');
@@ -9,25 +9,26 @@ const kReferenceInfo = Symbol.for('referenceInfo');
 export default function ReceiveTask(activityDef, context) {
   const task = new Activity(ReceiveTaskBehaviour, activityDef, context);
 
-  task.broker.assertQueue('message', {autoDelete: false, durable: true});
-  task.broker.bindQueue('message', 'api', '*.message.#', {durable: true});
+  task.broker.assertQueue('message', { autoDelete: false, durable: true });
+  task.broker.bindQueue('message', 'api', '*.message.#', { durable: true });
 
   return task;
 }
 
 export function ReceiveTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
+  const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
 
-  const reference = this.reference = {
+  const reference = (this.reference = {
     name: 'anonymous',
     ...behaviour.messageRef,
     referenceType: 'message',
-  };
+  });
 
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics =
+    behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.broker = activity.broker;
 
@@ -39,7 +40,7 @@ ReceiveTaskBehaviour.prototype.execute = function execute(executeMessage) {
 };
 
 function ReceiveTaskExecution(parent) {
-  const {activity, broker, loopCharacteristics, reference} = parent;
+  const { activity, broker, loopCharacteristics, reference } = parent;
 
   this.id = activity.id;
   this.logger = activity.logger;
@@ -55,10 +56,10 @@ ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
   this[kExecuteMessage] = executeMessage;
 
   const executeContent = executeMessage.content;
-  const {executionId, isRootScope} = executeContent;
+  const { executionId, isRootScope } = executeContent;
   this.executionId = executionId;
 
-  const info = this[kReferenceInfo] = this._getReferenceInfo(executeMessage);
+  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
 
   if (isRootScope) {
     this._setupMessageHandling(executionId);
@@ -85,16 +86,16 @@ ReceiveTaskExecution.prototype.execute = function execute(executeMessage) {
 
   this._debug(`expect ${info.description}`);
 
-  broker.publish('event', 'activity.wait', cloneContent(executeContent, {message: {...info.message}}));
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, { message: { ...info.message } }));
 };
 
 ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
   const content = message.content;
 
-  const {id: signalId, executionId: signalExecutionId} = content.message || {};
-  const {message: referenceMessage, description} = this[kReferenceInfo];
+  const { id: signalId, executionId: signalExecutionId } = content.message || {};
+  const { message: referenceMessage, description } = this[kReferenceInfo];
 
-  if (!referenceMessage.id && signalId || signalExecutionId) {
+  if ((!referenceMessage.id && signalId) || signalExecutionId) {
     if (this.loopCharacteristics && signalExecutionId !== this.executionId) return;
     if (signalId !== this.id && signalExecutionId !== this.executionId) return;
     this._debug('caught direct message');
@@ -103,27 +104,33 @@ ReceiveTaskExecution.prototype._onCatchMessage = function onCatchMessage(routing
     this._debug(`caught ${description}`);
   }
 
-  const {type: messageType, correlationId} = message.properties;
+  const { type: messageType, correlationId } = message.properties;
   const broker = this.broker;
   const executeContent = this[kExecuteMessage].content;
 
-  broker.publish('event', 'activity.consumed', cloneContent(executeContent, {message: {...message.content.message}}), {correlationId, type: messageType});
-  broker.publish('event', 'activity.catch', cloneContent(executeContent, {message: message.content.message}), {type: 'catch', correlationId});
+  broker.publish('event', 'activity.consumed', cloneContent(executeContent, { message: { ...message.content.message } }), {
+    correlationId,
+    type: messageType,
+  });
+  broker.publish('event', 'activity.catch', cloneContent(executeContent, { message: message.content.message }), {
+    type: 'catch',
+    correlationId,
+  });
 
-  this._complete(message.content.message, {correlationId});
+  this._complete(message.content.message, { correlationId });
 };
 
 ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey, message) {
-  const {type: messageType, correlationId} = message.properties;
+  const { type: messageType, correlationId } = message.properties;
   switch (messageType) {
     case 'message':
     case 'signal': {
-      return this._complete(message.content.message, {correlationId});
+      return this._complete(message.content.message, { correlationId });
     }
     case 'discard': {
       this[kCompleted] = true;
       this._stop();
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kExecuteMessage].content), { correlationId });
     }
     case 'stop': {
       return this._stop();
@@ -134,34 +141,47 @@ ReceiveTaskExecution.prototype._onApiMessage = function onApiMessage(routingKey,
 ReceiveTaskExecution.prototype._complete = function complete(output, options) {
   this[kCompleted] = 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[kExecuteMessage].content, { output }), options);
 };
 
 ReceiveTaskExecution.prototype._stop = function stop() {
-  const broker = this.broker, executionId = this.executionId;
+  const broker = this.broker,
+    executionId = this.executionId;
   broker.cancel(`_onmessage-${executionId}`);
   broker.cancel(`_api-${executionId}`);
 };
 
 ReceiveTaskExecution.prototype._setupMessageHandling = function setupMessageHandling(executionId) {
   const broker = this.broker;
-  broker.subscribeTmp('api', '#.signal.*', this._onDelegateMessage.bind(this), {
-    noAck: true,
-    consumerTag: `_api-delegated-${executionId}`,
-  }, {
-    noAck: true,
-  });
+  broker.subscribeTmp(
+    'api',
+    '#.signal.*',
+    this._onDelegateMessage.bind(this),
+    {
+      noAck: true,
+      consumerTag: `_api-delegated-${executionId}`,
+    },
+    {
+      noAck: true,
+    },
+  );
   broker.subscribeTmp('api', `activity.stop.${executionId}`, this._onStopApiMessage.bind(this), {
     noAck: true,
     consumerTag: `_api-stop-${executionId}`,
     priority: 400,
   });
-  broker.subscribeTmp('execution', 'execute.#', this._onExecutionComplete.bind(this), {
-    noAck: true,
-    consumerTag: `_execution-complete-${executionId}`,
-  }, {
-    noAck: true,
-  });
+  broker.subscribeTmp(
+    'execution',
+    'execute.#',
+    this._onExecutionComplete.bind(this),
+    {
+      noAck: true,
+      consumerTag: `_execution-complete-${executionId}`,
+    },
+    {
+      noAck: true,
+    },
+  );
 };
 
 ReceiveTaskExecution.prototype._onDelegateMessage = function onDelegateMessage(_, message) {
@@ -173,7 +193,7 @@ ReceiveTaskExecution.prototype._onStopApiMessage = function onStopApiMessage() {
   this._stopMessageHandling(true);
 };
 
-ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComplete(routingKey, {content}) {
+ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComplete(routingKey, { content }) {
   if (!content.isRootScope) return;
   switch (routingKey) {
     case 'execute.completed':
@@ -185,7 +205,8 @@ ReceiveTaskExecution.prototype._onExecutionComplete = function onExecutionComple
 };
 
 ReceiveTaskExecution.prototype._stopMessageHandling = function stop(keepMessageQ) {
-  const broker = this.broker, executionId = this.executionId;
+  const broker = this.broker,
+    executionId = this.executionId;
   broker.cancel(`_api-delegated-${executionId}`);
   broker.cancel(`_api-stop-${executionId}`);
   broker.cancel(`_execution-complete-${executionId}`);
@@ -196,7 +217,7 @@ ReceiveTaskExecution.prototype._getReferenceInfo = function getReferenceInfo(mes
   const referenceElement = this.referenceElement;
   if (!referenceElement) {
     return {
-      message: {...this.reference},
+      message: { ...this.reference },
       description: 'anonymous message',
     };
   }

package/src/tasks/ScriptTask.js

@@ -1,22 +1,23 @@
 import Activity from '../activity/Activity.js';
 import ExecutionScope from '../activity/ExecutionScope.js';
 import { ActivityError } from '../error/Errors.js';
-import {cloneContent, cloneMessage} from '../messageHelper.js';
+import { cloneContent, cloneMessage } from '../messageHelper.js';
 
 export default function ScriptTask(activityDef, context) {
   return new Activity(ScriptTaskBehaviour, activityDef, context);
 }
 
 export function ScriptTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
+  const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
   this.scriptFormat = behaviour.scriptFormat;
 
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics =
+    behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
-  const environment = this.environment = activity.environment;
+  const environment = (this.environment = activity.environment);
 
   environment.registerScript(activity);
 }
@@ -28,10 +29,14 @@ ScriptTaskBehaviour.prototype.execute = function execute(executeMessage) {
     return loopCharacteristics.execute(executeMessage);
   }
 
-  const activity = this.activity, scriptFormat = this.scriptFormat;
+  const activity = this.activity,
+    scriptFormat = this.scriptFormat;
   const script = this.environment.getScript(scriptFormat, activity, cloneMessage(executeMessage));
   if (!script) {
-    return activity.emitFatal(new ActivityError(`Script format ${scriptFormat} is unsupported or was not registered for <${activity.id}>`, executeMessage), executeContent);
+    return activity.emitFatal(
+      new ActivityError(`Script format ${scriptFormat} is unsupported or was not registered for <${activity.id}>`, executeMessage),
+      executeContent,
+    );
   }
 
   return script.execute(ExecutionScope(activity, executeMessage), scriptCallback);
@@ -39,8 +44,12 @@ ScriptTaskBehaviour.prototype.execute = function execute(executeMessage) {
   function scriptCallback(err, output) {
     if (err) {
       activity.logger.error(`<${executeContent.executionId} (${activity.id})>`, err);
-      return activity.broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
+      return activity.broker.publish(
+        'execution',
+        'execute.error',
+        cloneContent(executeContent, { error: new ActivityError(err.message, executeMessage, err) }, { mandatory: true }),
+      );
     }
-    return activity.broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output}));
+    return activity.broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output }));
   }
 };

package/src/tasks/ServiceTask.js

@@ -1,17 +1,18 @@
 import Activity from '../activity/Activity.js';
-import {ActivityError} from '../error/Errors.js';
-import {cloneMessage, cloneContent} from '../messageHelper.js';
+import { ActivityError } from '../error/Errors.js';
+import { cloneMessage, cloneContent } from '../messageHelper.js';
 
 export default function ServiceTask(activityDef, context) {
   return new Activity(ServiceTaskBehaviour, activityDef, context);
 }
 
 export function ServiceTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
+  const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics =
+    behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.environment = activity.environment;
   this.broker = activity.broker;
@@ -25,20 +26,26 @@ ServiceTaskBehaviour.prototype.execute = function execute(executeMessage) {
   }
 
   const executionId = executeContent.executionId;
-  const service = this.service = this.getService(executeMessage);
+  const service = (this.service = this.getService(executeMessage));
   if (!service) return this.activity.emitFatal(new ActivityError(`<${this.id}> service not defined`, executeMessage), executeContent);
 
   const broker = this.broker;
-  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {consumerTag: `_api-${executionId}`});
+  broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => this._onApiMessage(executeMessage, ...args), {
+    consumerTag: `_api-${executionId}`,
+  });
 
   return service.execute(executeMessage, (err, output) => {
     broker.cancel(`_api-${executionId}`);
     if (err) {
       this.activity.logger.error(`<${executionId} (${this.id})>`, err);
-      return broker.publish('execution', 'execute.error', cloneContent(executeContent, {error: new ActivityError(err.message, executeMessage, err)}, {mandatory: true}));
+      return broker.publish(
+        'execution',
+        'execute.error',
+        cloneContent(executeContent, { error: new ActivityError(err.message, executeMessage, err) }, { mandatory: true }),
+      );
     }
 
-    return broker.publish('execution', 'execute.completed', cloneContent(executeContent, {output, state: 'complete'}));
+    return broker.publish('execution', 'execute.completed', cloneContent(executeContent, { output, state: 'complete' }));
   });
 };
 
@@ -60,7 +67,7 @@ ServiceTaskBehaviour.prototype._onApiMessage = function onApiMessage(executeMess
         else if (service.stop) service.stop(message);
       }
       this.activity.logger.debug(`<${executionId} (${this.id})> discarded`);
-      return broker.publish('execution', 'execute.discard', cloneContent(executeMessage.content, {state: 'discard'}));
+      return broker.publish('execution', 'execute.discard', cloneContent(executeMessage.content, { state: 'discard' }));
     }
     case 'stop': {
       const executionId = executeMessage.content.executionId;

package/src/tasks/SignalTask.js

@@ -1,17 +1,18 @@
 import Activity from '../activity/Activity.js';
-import {ActivityError} from '../error/Errors.js';
-import {cloneContent} from '../messageHelper.js';
+import { ActivityError } from '../error/Errors.js';
+import { cloneContent } from '../messageHelper.js';
 
 export default function SignalTask(activityDef, context) {
   return new Activity(SignalTaskBehaviour, activityDef, context);
 }
 
 export function SignalTaskBehaviour(activity) {
-  const {id, type, behaviour} = activity;
+  const { id, type, behaviour } = activity;
 
   this.id = id;
   this.type = type;
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics =
+    behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.broker = activity.broker;
 }
@@ -34,56 +35,74 @@ SignalTaskBehaviour.prototype.execute = function execute(executeMessage) {
     noAck: true,
     consumerTag: `_api-delegated-${executionId}`,
   });
-  broker.publish('event', 'activity.wait', cloneContent(executeContent, {state: 'wait'}));
+  broker.publish('event', 'activity.wait', cloneContent(executeContent, { state: 'wait' }));
 };
 
 SignalTaskBehaviour.prototype._onDelegatedApiMessage = function onDelegatedApiMessage(executeMessage, routingKey, message) {
   if (!message.properties.delegate) return;
 
-  const {content: delegateContent} = message;
+  const { content: delegateContent } = message;
   if (!delegateContent || !delegateContent.message) return;
 
   const executeContent = executeMessage.content;
-  const {id: signalId, executionId: signalExecutionId} = delegateContent.message;
+  const { id: signalId, executionId: signalExecutionId } = delegateContent.message;
   if (this.loopCharacteristics && signalExecutionId !== executeContent.executionId) return;
   if (signalId !== this.id && signalExecutionId !== executeContent.executionId) return;
 
-  const {type: messageType, correlationId} = message.properties;
-  this.broker.publish('event', 'activity.consumed', cloneContent(executeContent, {
-    message: { ...delegateContent.message},
-  }), {
-    correlationId,
-    type: messageType,
-  });
+  const { type: messageType, correlationId } = message.properties;
+  this.broker.publish(
+    'event',
+    'activity.consumed',
+    cloneContent(executeContent, {
+      message: { ...delegateContent.message },
+    }),
+    {
+      correlationId,
+      type: messageType,
+    },
+  );
 
   return this._onApiMessage(executeMessage, routingKey, message);
 };
 
 SignalTaskBehaviour.prototype._onApiMessage = function onApiMessage(executeMessage, routingKey, message) {
-  const {type: messageType, correlationId} = message.properties;
+  const { type: messageType, correlationId } = message.properties;
   const executeContent = executeMessage.content;
   switch (messageType) {
     case 'stop':
       return this._stop(executeContent.executionId);
     case 'signal':
       this._stop(executeContent.executionId);
-      return this.broker.publish('execution', 'execute.completed', cloneContent(executeContent, {
-        output: message.content.message,
-        state: 'signal',
-      }), {
-        correlationId,
-      });
+      return this.broker.publish(
+        'execution',
+        'execute.completed',
+        cloneContent(executeContent, {
+          output: message.content.message,
+          state: 'signal',
+        }),
+        {
+          correlationId,
+        },
+      );
     case 'error':
       this._stop(executeContent.executionId);
-      return this.broker.publish('execution', 'execute.error', cloneContent(executeContent, {
-        error: new ActivityError(message.content.message, executeMessage, message.content),
-      }, {
-        mandatory: true,
-        correlationId,
-      }));
+      return this.broker.publish(
+        'execution',
+        'execute.error',
+        cloneContent(
+          executeContent,
+          {
+            error: new ActivityError(message.content.message, executeMessage, message.content),
+          },
+          {
+            mandatory: true,
+            correlationId,
+          },
+        ),
+      );
     case 'discard':
       this._stop(executeContent.executionId);
-      return this.broker.publish('execution', 'execute.discard', cloneContent(executeContent), {correlationId});
+      return this.broker.publish('execution', 'execute.discard', cloneContent(executeContent), { correlationId });
   }
 };
 

package/src/tasks/StandardLoopCharacteristics.js

@@ -1,7 +1,7 @@
 import LoopCharacteristics from './LoopCharacteristics.js';
 
 export default function StandardLoopCharacteristics(activity, loopCharacteristics) {
-  let {behaviour} = loopCharacteristics;
-  behaviour = {...behaviour, isSequential: true};
-  return new LoopCharacteristics(activity, {...loopCharacteristics, behaviour});
+  let { behaviour } = loopCharacteristics;
+  behaviour = { ...behaviour, isSequential: true };
+  return new LoopCharacteristics(activity, { ...loopCharacteristics, behaviour });
 }

package/src/tasks/SubProcess.js

@@ -1,36 +1,37 @@
 import Activity from '../activity/Activity.js';
 import ProcessExecution from '../process/ProcessExecution.js';
-import {cloneContent} from '../messageHelper.js';
+import { cloneContent } from '../messageHelper.js';
 
 const kExecutions = Symbol.for('executions');
 const kMessageHandlers = Symbol.for('messageHandlers');
 
 export default function SubProcess(activityDef, context) {
   const triggeredByEvent = activityDef.behaviour && activityDef.behaviour.triggeredByEvent;
-  const subProcess = new Activity(SubProcessBehaviour, {...activityDef, isSubProcess: true, triggeredByEvent}, context);
+  const subProcess = new Activity(SubProcessBehaviour, { ...activityDef, isSubProcess: true, triggeredByEvent }, context);
 
   subProcess.getStartActivities = function getStartActivities(filterOptions) {
     return context.getStartActivities(filterOptions, activityDef.id);
   };
 
   subProcess.broker.cancel('_api-shake');
-  subProcess.broker.subscribeTmp('api', 'activity.shake.*', onShake, {noAck: true, consumerTag: '_api-shake'});
+  subProcess.broker.subscribeTmp('api', 'activity.shake.*', onShake, { noAck: true, consumerTag: '_api-shake' });
 
   return subProcess;
 
   function onShake(_, message) {
-    const {startId} = message.content;
+    const { startId } = message.content;
     const last = message.content.sequence.pop();
     const sequence = new ProcessExecution(subProcess, context).shake(startId);
-    message.content.sequence.push({...last, isSubProcess: true, sequence});
+    message.content.sequence.push({ ...last, isSubProcess: true, sequence });
   }
 }
 
 export function SubProcessBehaviour(activity, context) {
-  const {id, type, behaviour} = activity;
+  const { id, type, behaviour } = activity;
   this.id = id;
   this.type = type;
-  this.loopCharacteristics = behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
+  this.loopCharacteristics =
+    behaviour.loopCharacteristics && new behaviour.loopCharacteristics.Behaviour(activity, behaviour.loopCharacteristics);
   this.activity = activity;
   this.context = context;
   this.environment = activity.environment;
@@ -173,7 +174,7 @@ SubProcessBehaviour.prototype._onExecutionCompleted = function onExecutionComple
     case 'error': {
       broker.cancel(message.fields.consumerTag);
 
-      const {error} = content;
+      const { error } = content;
       this.activity.logger.error(`<${this.id}>`, error);
 
       return this._completeExecution('execute.error', content);