bpmn-elements 16.1.0 → 16.2.1

package/dist/Api.js

@@ -72,7 +72,7 @@ Api.prototype.resolveExpression = function resolveExpression(expression) {
   }, this.owner);
 };
 Api.prototype.sendApiMessage = function sendApiMessage(action, content, options) {
-  const correlationId = options && options.correlationId || (0, _shared.getUniqueId)(`${this.id || this.messagePrefix}_signal`);
+  const correlationId = options?.correlationId || (0, _shared.getUniqueId)(`${this.id || this.messagePrefix}_signal`);
   let key = `${this.messagePrefix}.${action}`;
   if (this.executionId) key += `.${this.executionId}`;
   this.broker.publish('api', key, this.createMessage(content), {

package/dist/Context.js

@@ -165,10 +165,8 @@ ContextInstance.prototype.getDataStoreById = function getDataStoreById(reference
   return dataStore;
 };
 ContextInstance.prototype.getStartActivities = function getStartActivities(filterOptions, scopeId) {
-  const {
-    referenceId,
-    referenceType = 'unknown'
-  } = filterOptions || {};
+  const referenceId = filterOptions?.referenceId;
+  const referenceType = filterOptions?.referenceType || 'unknown';
   const result = [];
   for (const activity of this.getActivities()) {
     if (!activity.isStart) continue;

package/dist/Environment.js

@@ -64,7 +64,7 @@ Environment.prototype.recover = function recover(state) {
   if (state.output) Object.assign(this.output, state.output);
   return this;
 };
-Environment.prototype.clone = function clone(overrideOptions = {}) {
+Environment.prototype.clone = function clone(overrideOptions) {
   const services = this[kServices];
   const newOptions = {
     settings: {
@@ -82,7 +82,7 @@ Environment.prototype.clone = function clone(overrideOptions = {}) {
     ...overrideOptions,
     services
   };
-  if (overrideOptions.services) newOptions.services = {
+  if (overrideOptions?.services) newOptions.services = {
     ...services,
     ...overrideOptions.services
   };
@@ -111,7 +111,7 @@ Environment.prototype.registerScript = function registerScript(...args) {
 Environment.prototype.getServiceByName = function getServiceByName(serviceName) {
   return this[kServices][serviceName];
 };
-Environment.prototype.resolveExpression = function resolveExpression(expression, message = {}, expressionFnContext) {
+Environment.prototype.resolveExpression = function resolveExpression(expression, message, expressionFnContext) {
   const from = {
     environment: this,
     ...message

package/dist/EventBroker.js

@@ -111,7 +111,7 @@ EventBroker.prototype.on = function on(eventName, callback, eventOptions = {
     callback(owner.getApi(message));
   }
 };
-EventBroker.prototype.once = function once(eventName, callback, eventOptions = {}) {
+EventBroker.prototype.once = function once(eventName, callback, eventOptions) {
   return this.on(eventName, callback, {
     ...eventOptions,
     once: true

package/dist/MessageFormatter.js

@@ -66,7 +66,7 @@ Formatter.prototype._onMessage = function onMessage(routingKey, message) {
     default:
       {
         message.ack();
-        const endRoutingKey = message.content && message.content.endRoutingKey;
+        const endRoutingKey = message.content?.endRoutingKey;
         if (endRoutingKey) {
           this._decorate(message.content);
           pending.push(message);
@@ -102,7 +102,7 @@ Formatter.prototype._complete = function complete(message, isError) {
   if (executeMessage) executeMessage.ack();
   this.broker.cancel(message.fields.consumerTag);
   if (isError) {
-    const error = message.content && message.content.error || new Error('formatting failed');
+    const error = message.content?.error || new Error('formatting failed');
     const errMessage = error.message || 'formatting failed';
     this._debug(`formatting of ${formatKey} failed with ${message.fields.routingKey}: ${errMessage}`);
     return callback(new _Errors.ActivityError(errMessage, (0, _messageHelper.cloneMessage)(runMessage), error));

package/dist/Tracker.js

@@ -37,6 +37,7 @@ ActivityTracker.prototype.track = function track(routingKey, message) {
       break;
     case 'activity.execution.outbound.take':
     case 'activity.detach':
+    case 'activity.call':
     case 'activity.wait':
       {
         if (content.isMultiInstance) this._waiting(content.parent.executionId);else this._waiting(executionId);

package/dist/activity/Activity.js

@@ -11,6 +11,7 @@ var _EventBroker = require("../EventBroker.js");
 var _MessageFormatter = require("../MessageFormatter.js");
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
+var _outboundEvaluator = require("./outbound-evaluator.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const kActivityDef = Symbol.for('activityDefinition');
 const kConsuming = Symbol.for('consuming');
@@ -84,15 +85,20 @@ function Activity(Behaviour, activityDef, context) {
     inboundTriggers = inboundSequenceFlows.slice();
   }
   const outboundSequenceFlows = context.getOutboundSequenceFlows(id);
+  const isParallelJoin = activityDef.isParallelGateway && inboundSequenceFlows.length > 1;
   const flows = this[kFlows] = {
     inboundSequenceFlows,
     inboundAssociations,
-    inboundJoinFlows: new Set(),
     inboundTriggers,
     outboundSequenceFlows,
-    outboundEvaluator: new OutboundEvaluator(this, outboundSequenceFlows)
+    outboundEvaluator: new _outboundEvaluator.OutboundEvaluator(this, outboundSequenceFlows),
+    ...(isParallelJoin && {
+      inboundJoinFlows: new Set(),
+      inboundSourceIds: new Set(inboundSequenceFlows.map(({
+        sourceId
+      }) => sourceId))
+    })
   };
-  const isParallelJoin = activityDef.isParallelGateway && flows.inboundSequenceFlows.length > 1;
   this[kFlags] = {
     isEnd: flows.outboundSequenceFlows.length === 0,
     isStart: flows.inboundSequenceFlows.length === 0 && !attachedTo && !behaviour.triggeredByEvent && !isForCompensation,
@@ -103,7 +109,7 @@ function Activity(Behaviour, activityDef, context) {
     isTransaction: activityDef.isTransaction,
     isParallelJoin,
     isThrowing: activityDef.isThrowing,
-    lane: activityDef.lane && activityDef.lane.id
+    lane: activityDef.lane?.id
   };
   this[kExec] = new Map();
   this[kMessageHandlers] = {
@@ -112,7 +118,7 @@ function Activity(Behaviour, activityDef, context) {
     onApiMessage: this._onApiMessage.bind(this),
     onExecutionMessage: this._onExecutionMessage.bind(this)
   };
-  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
+  this[kEventDefinitions] = eventDefinitions?.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
   this[kExtensions] = context.loadExtensions(this);
   this[kConsuming] = false;
   this[kConsumingRunQ] = undefined;
@@ -143,7 +149,7 @@ Object.defineProperties(Activity.prototype, {
   bpmnIo: {
     get() {
       const extensions = this[kExtensions];
-      return extensions && extensions.extensions.find(e => e.type === 'bpmnio');
+      return extensions?.extensions.find(e => e.type === 'bpmnio');
     }
   },
   formatter: {
@@ -508,21 +514,21 @@ Activity.prototype._onJoinInbound = function onJoinInbound(routingKey, message)
   } = message;
   const {
     inboundJoinFlows,
-    inboundTriggers
+    inboundSourceIds
   } = this[kFlows];
   let alreadyTouched = false;
   const touched = new Set();
   let taken;
   for (const msg of inboundJoinFlows) {
-    const flowId = msg.content.id;
-    touched.add(flowId);
-    if (flowId === content.id) {
+    const sourceId = msg.content.sourceId;
+    touched.add(sourceId);
+    if (sourceId === content.sourceId) {
       alreadyTouched = true;
     }
   }
   inboundJoinFlows.add(message);
   if (alreadyTouched) return;
-  const remaining = inboundTriggers.length - touched.size - 1;
+  const remaining = inboundSourceIds.size - touched.size - 1;
   if (remaining) {
     return this.logger.debug(`<${this.id}> inbound ${message.content.action} from <${message.content.id}>, ${remaining} remaining`);
   }
@@ -660,7 +666,7 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       }
     case 'run.execute.passthrough':
       {
-        const execution = this.execution;
+        const execution = this[kExec].get('execution');
         if (!isRedelivered && execution) {
           if (execution.completed) return message.ack();
           this[kExecuteMessage] = message;
@@ -671,14 +677,18 @@ Activity.prototype._continueRunMessage = function continueRunMessage(routingKey,
       {
         this.status = 'executing';
         this[kExecuteMessage] = message;
-        const exec = this[kExec];
         if (isRedelivered && this.extensions) this.extensions.activate((0, _messageHelper.cloneMessage)(message));
-        if (!exec.has('execution')) exec.set('execution', new _ActivityExecution.default(this, this.context));
+        const exec = this[kExec];
+        let execution = exec.get('execution');
+        if (!execution) {
+          execution = new _ActivityExecution.default(this, this.context);
+          exec.set('execution', execution);
+        }
         this.broker.getQueue('execution-q').assertConsumer(this[kMessageHandlers].onExecutionMessage, {
           exclusive: true,
           consumerTag: '_activity-execution'
         });
-        return exec.get('execution').execute(message);
+        return execution.execute(message);
       }
     case 'run.end':
       {
@@ -846,16 +856,16 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   if (!outboundSequenceFlows.length) return callback(null, []);
   const fromContent = fromMessage.content;
   let discardSequence = fromContent.discardSequence;
-  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound && fromContent.inbound[0]) {
+  if (isDiscarded && !discardSequence && this[kFlags].attachedTo && fromContent.inbound?.[0]) {
     discardSequence = [fromContent.inbound[0].id];
   }
   let outboundFlows;
   if (isDiscarded) {
-    outboundFlows = outboundSequenceFlows.map(flow => formatFlowAction(flow, {
+    outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, {
       action: 'discard'
     }));
-  } else if (fromContent.outbound && fromContent.outbound.length) {
-    outboundFlows = outboundSequenceFlows.map(flow => formatFlowAction(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
+  } else if (fromContent.outbound?.length) {
+    outboundFlows = outboundSequenceFlows.map(flow => (0, _outboundEvaluator.formatFlowAction)(flow, fromContent.outbound.filter(f => f.id === flow.id).pop()));
   }
   if (outboundFlows) {
     this._doRunOutbound(outboundFlows, fromContent, discardSequence);
@@ -868,25 +878,41 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
   });
 };
 Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
-  for (const outboundFlow of outboundList) {
-    const {
-      id: flowId,
-      action,
-      result
-    } = outboundFlow;
-    this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
-      flow: {
-        ...(result && typeof result === 'object' && result),
-        ...outboundFlow,
-        sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
-        ...(discardSequence && {
-          discardSequence: discardSequence.slice()
-        })
+  if (outboundList.length === 1) {
+    this._publishRunOutbound(outboundList[0], content, discardSequence);
+  } else {
+    const targets = new Map();
+    for (const outboundFlow of outboundList) {
+      const prevTarget = targets.get(outboundFlow.targetId);
+      if (!prevTarget) {
+        targets.set(outboundFlow.targetId, outboundFlow);
+      } else if (outboundFlow.action === 'take' && outboundFlow.action !== prevTarget.action) {
+        targets.set(outboundFlow.targetId, outboundFlow);
       }
-    }));
+    }
+    for (const outboundFlow of targets.values()) {
+      this._publishRunOutbound(outboundFlow, content, discardSequence);
+    }
   }
   return outboundList;
 };
+Activity.prototype._publishRunOutbound = function publishRunOutbound(outboundFlow, content, discardSequence) {
+  const {
+    id: flowId,
+    action,
+    result
+  } = outboundFlow;
+  this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
+    flow: {
+      ...(result && typeof result === 'object' && result),
+      ...outboundFlow,
+      sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
+      ...(discardSequence && {
+        discardSequence: discardSequence.slice()
+      })
+    }
+  }));
+};
 Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   message.ack();
   const stateMessage = this[kStateMessage];
@@ -906,7 +932,7 @@ Activity.prototype._onResumeMessage = function onResumeMessage(message) {
   this.logger.debug(`<${this.id}> resume from ${message.content.status}`);
   return this.broker.publish('run', fields.routingKey, (0, _messageHelper.cloneContent)(stateMessage.content), stateMessage.properties);
 };
-Activity.prototype._publishEvent = function publishEvent(state, content, properties = {}) {
+Activity.prototype._publishEvent = function publishEvent(state, content, properties) {
   this.broker.publish('event', `activity.${state}`, (0, _messageHelper.cloneContent)(content, {
     state
   }), {
@@ -960,9 +986,11 @@ Activity.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   }
 };
 Activity.prototype._createMessage = function createMessage(override) {
-  const name = this.name,
-    status = this.status,
-    parent = this.parent;
+  const {
+    name,
+    status,
+    parent
+  } = this;
   const result = {
     ...override,
     id: this.id,
@@ -991,128 +1019,4 @@ Activity.prototype._deactivateRunConsumers = function _deactivateRunConsumers()
   this._pauseRunQ();
   broker.cancel('_activity-execution');
   this[kConsuming] = false;
-};
-function OutboundEvaluator(activity, outboundFlows) {
-  this.activity = activity;
-  this.broker = activity.broker;
-  const flows = this.outboundFlows = outboundFlows.slice();
-  const defaultFlowIdx = flows.findIndex(({
-    isDefault
-  }) => isDefault);
-  if (defaultFlowIdx > -1) {
-    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
-    flows.push(defaultFlow);
-  }
-  this.defaultFlowIdx = outboundFlows.findIndex(({
-    isDefault
-  }) => isDefault);
-  this._onEvaluated = this.onEvaluated.bind(this);
-  this.evaluateArgs = {};
-}
-OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
-  const outboundFlows = this.outboundFlows;
-  const args = this.evaluateArgs = {
-    fromMessage,
-    evaluationId: fromMessage.content.executionId,
-    discardRestAtTake,
-    callback,
-    conditionMet: false,
-    result: {},
-    takenCount: 0
-  };
-  if (!outboundFlows.length) return this.completed();
-  const flows = args.flows = outboundFlows.slice();
-  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
-    consumerTag: `_flow-evaluation-${args.evaluationId}`
-  });
-  return this.evaluateFlow(flows.shift());
-};
-OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
-  const content = message.content;
-  const {
-    id: flowId,
-    action,
-    evaluationId
-  } = message.content;
-  const args = this.evaluateArgs;
-  if (action === 'take') {
-    args.takenCount++;
-    args.conditionMet = true;
-  }
-  args.result[flowId] = content;
-  if ('result' in content) {
-    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
-  }
-  let nextFlow = args.flows.shift();
-  if (!nextFlow) return this.completed();
-  if (args.discardRestAtTake && args.conditionMet) {
-    do {
-      args.result[nextFlow.id] = formatFlowAction(nextFlow, {
-        action: 'discard'
-      });
-    } while (nextFlow = args.flows.shift());
-    return this.completed();
-  }
-  if (args.conditionMet && nextFlow.isDefault) {
-    args.result[nextFlow.id] = formatFlowAction(nextFlow, {
-      action: 'discard'
-    });
-    return this.completed();
-  }
-  message.ack();
-  this.evaluateFlow(nextFlow);
-};
-OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
-  const broker = this.broker;
-  const {
-    fromMessage,
-    evaluationId
-  } = this.evaluateArgs;
-  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
-    if (err) return this.completed(err);
-    const action = result ? 'take' : 'discard';
-    return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
-      action,
-      result,
-      evaluationId
-    }), {
-      persistent: false
-    });
-  });
-};
-OutboundEvaluator.prototype.completed = function completed(err) {
-  const {
-    callback,
-    evaluationId,
-    fromMessage,
-    result,
-    takenCount
-  } = this.evaluateArgs;
-  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
-  if (err) return callback(err);
-  if (!takenCount && this.outboundFlows.length) {
-    const nonTakenError = new _Errors.ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
-    return callback(nonTakenError);
-  }
-  const message = fromMessage.content.message;
-  const evaluationResult = [];
-  for (const flow of Object.values(result)) {
-    evaluationResult.push({
-      ...flow,
-      ...(message !== undefined && {
-        message
-      })
-    });
-  }
-  return callback(null, evaluationResult);
-};
-function formatFlowAction(flow, options) {
-  return {
-    ...options,
-    id: flow.id,
-    action: options.action,
-    ...(flow.isDefault && {
-      isDefault: true
-    })
-  };
-}
+};

package/dist/activity/ActivityExecution.js

@@ -35,7 +35,7 @@ Object.defineProperty(ActivityExecution.prototype, 'completed', {
 });
 ActivityExecution.prototype.execute = function execute(executeMessage) {
   if (!executeMessage) throw new Error('Execution requires message');
-  const executionId = executeMessage.content && executeMessage.content.executionId;
+  const executionId = executeMessage.content?.executionId;
   if (!executionId) throw new Error('Execution requires execution id');
   this.executionId = executionId;
   const initMessage = this[kExecuteMessage] = (0, _messageHelper.cloneMessage)(executeMessage, {
@@ -338,7 +338,7 @@ ActivityExecution.prototype._onParentApiMessage = function onParentApiMessage(ro
   }
 };
 ActivityExecution.prototype._onStop = function onStop(message) {
-  const stoppedId = message && message.content && message.content.executionId;
+  const stoppedId = message?.content?.executionId;
   const running = this.getPostponed();
   for (const api of running) {
     if (stoppedId !== api.content.executionId) {

package/dist/activity/outbound-evaluator.js

@@ -0,0 +1,131 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OutboundEvaluator = OutboundEvaluator;
+exports.formatFlowAction = formatFlowAction;
+var _Errors = require("../error/Errors.js");
+var _messageHelper = require("../messageHelper.js");
+function OutboundEvaluator(activity, outboundFlows) {
+  this.activity = activity;
+  this.broker = activity.broker;
+  const flows = this.outboundFlows = outboundFlows.slice();
+  const defaultFlowIdx = flows.findIndex(({
+    isDefault
+  }) => isDefault);
+  if (defaultFlowIdx > -1) {
+    const [defaultFlow] = flows.splice(defaultFlowIdx, 1);
+    flows.push(defaultFlow);
+  }
+  this._onEvaluated = this.onEvaluated.bind(this);
+  this.evaluateArgs = {};
+}
+OutboundEvaluator.prototype.evaluate = function evaluate(fromMessage, discardRestAtTake, callback) {
+  const outboundFlows = this.outboundFlows;
+  const args = this.evaluateArgs = {
+    fromMessage,
+    evaluationId: fromMessage.content.executionId,
+    discardRestAtTake,
+    callback,
+    conditionMet: false,
+    result: {},
+    takenCount: 0
+  };
+  if (!outboundFlows.length) return this.completed();
+  const flows = args.flows = outboundFlows.slice();
+  this.broker.subscribeTmp('execution', 'evaluate.flow.#', this._onEvaluated, {
+    consumerTag: `_flow-evaluation-${args.evaluationId}`
+  });
+  return this.evaluateFlow(flows.shift());
+};
+OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, message) {
+  const content = message.content;
+  const {
+    id: flowId,
+    action,
+    evaluationId
+  } = message.content;
+  const args = this.evaluateArgs;
+  if (action === 'take') {
+    args.takenCount++;
+    args.conditionMet = true;
+  }
+  args.result[flowId] = content;
+  if ('result' in content) {
+    this.activity.logger.debug(`<${evaluationId} (${this.activity.id})> flow <${flowId}> evaluated to: ${!!content.result}`);
+  }
+  let nextFlow = args.flows.shift();
+  if (!nextFlow) return this.completed();
+  if (args.discardRestAtTake && args.conditionMet) {
+    do {
+      args.result[nextFlow.id] = formatFlowAction(nextFlow, {
+        action: 'discard'
+      });
+    } while (nextFlow = args.flows.shift());
+    return this.completed();
+  }
+  if (args.conditionMet && nextFlow.isDefault) {
+    args.result[nextFlow.id] = formatFlowAction(nextFlow, {
+      action: 'discard'
+    });
+    return this.completed();
+  }
+  message.ack();
+  this.evaluateFlow(nextFlow);
+};
+OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
+  const broker = this.broker;
+  const {
+    fromMessage,
+    evaluationId
+  } = this.evaluateArgs;
+  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
+    if (err) return this.completed(err);
+    const action = result ? 'take' : 'discard';
+    return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {
+      action,
+      result,
+      evaluationId
+    }), {
+      persistent: false
+    });
+  });
+};
+OutboundEvaluator.prototype.completed = function completed(err) {
+  const {
+    callback,
+    evaluationId,
+    fromMessage,
+    result,
+    takenCount
+  } = this.evaluateArgs;
+  this.broker.cancel(`_flow-evaluation-${evaluationId}`);
+  if (err) return callback(err);
+  if (!takenCount && this.outboundFlows.length) {
+    const nonTakenError = new _Errors.ActivityError(`<${this.activity.id}> no conditional flow taken`, fromMessage);
+    return callback(nonTakenError);
+  }
+  const message = fromMessage.content.message;
+  const evaluationResult = [];
+  for (const flow of Object.values(result)) {
+    evaluationResult.push({
+      ...flow,
+      ...(message !== undefined && {
+        message
+      })
+    });
+  }
+  return callback(null, evaluationResult);
+};
+function formatFlowAction(flow, options) {
+  return {
+    ...options,
+    id: flow.id,
+    action: options.action,
+    targetId: flow.targetId,
+    ...(flow.isDefault && {
+      isDefault: true
+    })
+  };
+}

package/dist/definition/Definition.js

@@ -106,7 +106,7 @@ Object.defineProperties(Definition.prototype, {
   activityStatus: {
     get() {
       const execution = this[kExec].get('execution');
-      return execution && execution.activityStatus || 'idle';
+      return execution?.activityStatus || 'idle';
     }
   }
 });
@@ -159,7 +159,7 @@ Definition.prototype.getState = function getState() {
     stopped: this.stopped,
     counters: this.counters,
     environment: this.environment.getState(),
-    execution: this.execution && this.execution.getState(),
+    execution: this.execution?.getState(),
     broker: this.broker.getState(true)
   });
 };
@@ -272,8 +272,8 @@ Definition.prototype.sendMessage = function sendMessage(message) {
     message
   };
   let messageType = 'message';
-  const reference = message && message.id && this.getElementById(message.id);
-  if (reference && reference.resolve) {
+  const reference = message?.id && this.getElementById(message.id);
+  if (reference?.resolve) {
     const resolvedReference = reference.resolve(this._createMessage({
       message
     }));

package/dist/definition/DefinitionExecution.js

@@ -390,7 +390,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       break;
     case 'process.discarded':
       {
-        if (inbound && inbound.length) {
+        if (inbound?.length) {
           const calledFrom = inbound[0];
           this._getProcessApi({
             content: calledFrom
@@ -402,7 +402,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       }
     case 'process.end':
       {
-        if (inbound && inbound.length) {
+        if (inbound?.length) {
           const calledFrom = inbound[0];
           this._getProcessApi({
             content: calledFrom
@@ -419,7 +419,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
       }
     case 'process.error':
       {
-        if (inbound && inbound.length) {
+        if (inbound?.length) {
           const calledFrom = inbound[0];
           this._getProcessApi({
             content: calledFrom
@@ -467,7 +467,7 @@ DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(
   } = message.content;
   message.ack();
   this._debug(`left <${executionId} (${id})> (${type}), pending runs ${this.postponedCount}`);
-  if (inbound && inbound.length) {
+  if (inbound?.length) {
     const bp = this._removeProcessByExecutionId(executionId);
     this._deactivateProcess(bp);
   }
@@ -627,7 +627,7 @@ DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(ro
   const messageType = executeMessage.properties.type;
   const delegateMessage = executeMessage.content.message;
   const reference = this.context.getActivityById(delegateMessage.id);
-  const message = reference && reference.resolve(executeMessage);
+  const message = reference?.resolve(executeMessage);
   this._debug(`<${reference ? `${messageType} ${delegateMessage.id}>` : `anonymous ${messageType}`} event received from <${content.parent.id}.${content.id}>. Delegating.`);
   this.getApi().sendApiMessage(messageType, {
     source: {
@@ -674,7 +674,7 @@ DefinitionExecution.prototype._complete = function complete(completionType, cont
     ...options
   });
 };
-DefinitionExecution.prototype._createMessage = function createMessage(content = {}) {
+DefinitionExecution.prototype._createMessage = function createMessage(content) {
   return {
     id: this.id,
     type: this.type,