bpmn-elements 17.2.2 → 18.0.0

package/src/eventDefinitions/SignalEventDefinition.js

@@ -1,69 +1,77 @@
-import getPropertyValue from '../getPropertyValue.js';
+import { getPropertyValue } from '../getPropertyValue.js';
 import { brokerSafeId } from '../shared.js';
 import { cloneContent, shiftParent } from '../messageHelper.js';
-
-const kCompleted = Symbol.for('completed');
-const kMessageQ = Symbol.for('messageQ');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kReferenceElement = Symbol.for('referenceElement');
-const kReferenceInfo = Symbol.for('referenceInfo');
-
-export default function SignalEventDefinition(activity, eventDefinition) {
+import { K_COMPLETED, K_EXECUTE_MESSAGE, K_MESSAGE_Q, K_REFERENCE_ELEMENT, K_REFERENCE_INFO } from '../constants.js';
+
+/**
+ * Signal event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function SignalEventDefinition(activity, eventDefinition) {
   const { id, broker, environment, isStart, isThrowing } = activity;
   const { type, behaviour = {} } = eventDefinition;
 
   this.id = id;
   this.type = type;
 
-  const reference = (this.reference = {
+  /** @type {import('#types').EventReference} */
+  this.reference = {
     name: 'anonymous',
     ...behaviour.signalRef,
     referenceType: 'signal',
-  });
+  };
 
   this.isThrowing = isThrowing;
   this.activity = activity;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  const referenceElement = (this[kReferenceElement] = reference.id && activity.getActivityById(reference.id));
+  const referenceElement = (this[K_REFERENCE_ELEMENT] = this.reference.id && activity.getActivityById(this.reference.id));
   if (!isThrowing && isStart) {
-    this[kCompleted] = false;
+    this[K_COMPLETED] = false;
     const referenceId = referenceElement ? referenceElement.id : 'anonymous';
-    const messageQueueName = `${reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
-    this[kMessageQ] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
-    broker.bindQueue(messageQueueName, 'api', `*.${reference.referenceType}.#`, { durable: true });
+    const messageQueueName = `${this.reference.referenceType}-${brokerSafeId(id)}-${brokerSafeId(referenceId)}-q`;
+    this[K_MESSAGE_Q] = broker.assertQueue(messageQueueName, { autoDelete: false, durable: true });
+    broker.bindQueue(messageQueueName, 'api', `*.${this.reference.referenceType}.#`, { durable: true });
   }
 }
 
 Object.defineProperty(SignalEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
   get() {
-    return this[kExecuteMessage]?.content.executionId;
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 SignalEventDefinition.prototype.execute = function execute(executeMessage) {
   return this.isThrowing ? this.executeThrow(executeMessage) : this.executeCatch(executeMessage);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 SignalEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  this[kExecuteMessage] = executeMessage;
-  this[kCompleted] = false;
+  this[K_EXECUTE_MESSAGE] = executeMessage;
+  this[K_COMPLETED] = false;
 
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
   const parentExecutionId = parent?.executionId;
 
-  const info = (this[kReferenceInfo] = this._getReferenceInfo(executeMessage));
+  const info = (this[K_REFERENCE_INFO] = this._getReferenceInfo(executeMessage));
   const broker = this.broker;
 
   const onCatchMessage = this._onCatchMessage.bind(this);
   if (this.activity.isStart) {
-    this[kMessageQ].consume(onCatchMessage, {
+    this[K_MESSAGE_Q].consume(onCatchMessage, {
       noAck: true,
       consumerTag: `_api-signal-${executionId}`,
     });
-    if (this[kCompleted]) return;
+    if (this[K_COMPLETED]) return;
   }
 
   const onApiMessage = this._onApiMessage.bind(this);
@@ -91,6 +99,9 @@ SignalEventDefinition.prototype.executeCatch = function executeCatch(executeMess
   broker.publish('event', 'activity.wait', waitContent);
 };
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 SignalEventDefinition.prototype.executeThrow = function executeThrow(executeMessage) {
   const executeContent = executeMessage.content;
   const { executionId, parent } = executeContent;
@@ -113,16 +124,16 @@ SignalEventDefinition.prototype.executeThrow = function executeThrow(executeMess
 };
 
 SignalEventDefinition.prototype._onCatchMessage = function onCatchMessage(routingKey, message) {
-  const info = this[kReferenceInfo];
+  const info = this[K_REFERENCE_INFO];
   if (getPropertyValue(message, 'content.message.id') !== info.message.id) return;
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this._stop();
 
   const { type, correlationId } = message.properties;
   this.broker.publish(
     'event',
     'activity.consumed',
-    cloneContent(this[kExecuteMessage].content, {
+    cloneContent(this[K_EXECUTE_MESSAGE].content, {
       message: { ...message.content.message },
     }),
     {
@@ -142,9 +153,9 @@ SignalEventDefinition.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': {
       this._stop();
@@ -154,13 +165,13 @@ SignalEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey
 };
 
 SignalEventDefinition.prototype._complete = function complete(output, options) {
-  this[kCompleted] = true;
+  this[K_COMPLETED] = true;
   this._stop();
-  this._debug(`signaled with ${this[kReferenceInfo].description}`);
+  this._debug(`signaled with ${this[K_REFERENCE_INFO].description}`);
   return this.broker.publish(
     'execution',
     'execute.completed',
-    cloneContent(this[kExecuteMessage].content, {
+    cloneContent(this[K_EXECUTE_MESSAGE].content, {
       output,
       state: 'signal',
     }),
@@ -175,11 +186,11 @@ SignalEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_api-parent-${executionId}`);
   broker.cancel(`_api-${executionId}`);
   broker.cancel(`_api-delegated-${executionId}`);
-  if (this.activity.isStart) this[kMessageQ].purge();
+  if (this.activity.isStart) this[K_MESSAGE_Q].purge();
 };
 
 SignalEventDefinition.prototype._getReferenceInfo = function getReferenceInfo(message) {
-  const referenceElement = this[kReferenceElement];
+  const referenceElement = this[K_REFERENCE_ELEMENT];
   if (!referenceElement) {
     return {
       message: { ...this.reference },

package/src/eventDefinitions/TerminateEventDefinition.js

@@ -1,6 +1,11 @@
 import { cloneContent, shiftParent } from '../messageHelper.js';
 
-export default function TerminateEventDefinition(activity, eventDefinition) {
+/**
+ * Terminate event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function TerminateEventDefinition(activity, eventDefinition) {
   const { id, broker, environment } = activity;
   const { type = 'TerminateEventDefinition' } = eventDefinition;
 
@@ -11,6 +16,9 @@ export default function TerminateEventDefinition(activity, eventDefinition) {
   this.logger = environment.Logger(type.toLowerCase());
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 TerminateEventDefinition.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
 

package/src/eventDefinitions/TimerEventDefinition.js

@@ -1,58 +1,69 @@
 import { ISOInterval, getDate } from '@0dep/piso';
 import { cloneContent } from '../messageHelper.js';
 import { RunError } from '../error/Errors.js';
+import { K_STOPPED } from '../constants.js';
 
-const kStopped = Symbol.for('stopped');
-const kTimerContent = Symbol.for('timerContent');
-const kTimer = Symbol.for('timer');
+const K_TIMER_CONTENT = Symbol.for('timerContent');
+const K_TIMER = Symbol.for('timer');
 
 const timerTypes = new Set(['timeDuration', 'timeDate', 'timeCycle']);
 
-export default function TimerEventDefinition(activity, eventDefinition) {
+/**
+ * Timer event definition
+ * @param {import('#types').Activity} activity
+ * @param {import('moddle-context-serializer').EventDefinition} eventDefinition
+ */
+export function TimerEventDefinition(activity, eventDefinition) {
   const type = (this.type = eventDefinition.type || 'TimerEventDefinition');
   this.activity = activity;
   const environment = (this.environment = activity.environment);
   this.eventDefinition = eventDefinition;
 
   const { timeDuration, timeCycle, timeDate } = eventDefinition.behaviour || {};
-  if (timeDuration) this.timeDuration = timeDuration;
-  if (timeCycle) this.timeCycle = timeCycle;
-  if (timeDate) this.timeDate = timeDate;
+  if (timeDuration) this.timeDuration = /** @type {string} */ (timeDuration);
+  if (timeCycle) this.timeCycle = /** @type {string} */ (timeCycle);
+  if (timeDate) this.timeDate = /** @type {string} */ (timeDate);
 
   this.broker = activity.broker;
   this.logger = environment.Logger(type.toLowerCase());
 
-  this[kStopped] = false;
-  this[kTimer] = null;
+  this[K_STOPPED] = false;
+  this[K_TIMER] = null;
 }
 
-Object.defineProperties(TimerEventDefinition.prototype, {
-  executionId: {
-    get() {
-      return this[kTimerContent]?.executionId;
-    },
+Object.defineProperty(TimerEventDefinition.prototype, 'executionId', {
+  /** @returns {string} */
+  get() {
+    return this[K_TIMER_CONTENT]?.executionId;
   },
-  stopped: {
-    get() {
-      return this[kStopped];
-    },
+});
+
+Object.defineProperty(TimerEventDefinition.prototype, 'stopped', {
+  /** @returns {boolean} */
+  get() {
+    return this[K_STOPPED];
   },
-  timer: {
-    get() {
-      return this[kTimer];
-    },
+});
+
+Object.defineProperty(TimerEventDefinition.prototype, 'timer', {
+  /** @returns {import('#types').Timer | null} */
+  get() {
+    return this[K_TIMER];
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ */
 TimerEventDefinition.prototype.execute = function execute(executeMessage) {
   const { routingKey: executeKey, redelivered: isResumed } = executeMessage.fields;
-  const timer = this[kTimer];
+  const timer = this[K_TIMER];
   if (timer && executeKey === 'execute.timer') {
     return;
   }
 
-  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
-  this[kStopped] = false;
+  if (timer) this[K_TIMER] = this.environment.timers.clearTimeout(timer);
+  this[K_STOPPED] = false;
 
   const content = executeMessage.content;
   const executionId = content.executionId;
@@ -66,7 +77,7 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
     throw new RunError(err.message, executeMessage, err);
   }
 
-  const timerContent = (this[kTimerContent] = cloneContent(content, {
+  const timerContent = (this[K_TIMER_CONTENT] = cloneContent(content, {
     ...resolvedTimer,
     ...(isResumed && { isResumed }),
     startedAt,
@@ -93,7 +104,7 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
 
   const timers = this.environment.timers.register(timerContent);
   const delay = timerContent.timeout;
-  this[kTimer] = timers.setTimeout(this._completed.bind(this), delay, {
+  this[K_TIMER] = timers.setTimeout(this._completed.bind(this), delay, {
     id: content.id,
     type: this.type,
     executionId,
@@ -103,8 +114,8 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
 };
 
 TimerEventDefinition.prototype.stop = function stopTimer() {
-  const timer = this[kTimer];
-  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
+  const timer = this[K_TIMER];
+  if (timer) this[K_TIMER] = this.environment.timers.clearTimeout(timer);
 };
 
 TimerEventDefinition.prototype._completed = function completed(completeContent, options) {
@@ -115,7 +126,7 @@ TimerEventDefinition.prototype._completed = function completed(completeContent,
   const runningTime = stoppedAt.getTime() - this.startedAt.getTime();
   this._debug(`completed in ${runningTime}ms`);
 
-  const timerContent = this[kTimerContent];
+  const timerContent = this[K_TIMER_CONTENT];
   const content = { stoppedAt, runningTime, state: 'timeout', ...completeContent };
 
   const broker = this.broker;
@@ -148,7 +159,7 @@ TimerEventDefinition.prototype._onDelegatedApiMessage = function onDelegatedApiM
   this.broker.publish(
     'event',
     'activity.consumed',
-    cloneContent(this[kTimerContent], {
+    cloneContent(this[K_TIMER_CONTENT], {
       message: {
         ...content.message,
       },
@@ -180,22 +191,29 @@ TimerEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
     case 'discard': {
       this._stop();
       this._debug('discarded');
-      return this.broker.publish('execution', 'execute.discard', cloneContent(this[kTimerContent], { state: 'discard' }), {
+      return this.broker.publish('execution', 'execute.discard', cloneContent(this[K_TIMER_CONTENT], { state: 'discard' }), {
         correlationId,
       });
     }
   }
 };
 
+/** @private */
 TimerEventDefinition.prototype._stop = function stop() {
-  this[kStopped] = true;
-  const timer = this[kTimer];
-  if (timer) this[kTimer] = this.environment.timers.clearTimeout(timer);
+  this[K_STOPPED] = true;
+  const timer = this[K_TIMER];
+  if (timer) this[K_TIMER] = this.environment.timers.clearTimeout(timer);
   const broker = this.broker;
   broker.cancel(`_api-${this.executionId}`);
   broker.cancel(`_api-delegated-${this.executionId}`);
 };
 
+/**
+ * Parse timer
+ * @param {import('#types').TimerType} timerType
+ * @param {string} value
+ * @returns {import('#types').parsedTimer}
+ */
 TimerEventDefinition.prototype.parse = function parse(timerType, value) {
   let repeat, delay, expireAt;
   const now = new Date();

package/src/eventDefinitions/index.js

@@ -1,23 +1,10 @@
-import CancelEventDefinition from './CancelEventDefinition.js';
-import CompensateEventDefinition from './CompensateEventDefinition.js';
-import ConditionalEventDefinition from './ConditionalEventDefinition.js';
-import ErrorEventDefinition from './ErrorEventDefinition.js';
-import EscalationEventDefinition from './EscalationEventDefinition.js';
-import LinkEventDefinition from './LinkEventDefinition.js';
-import MessageEventDefinition from './MessageEventDefinition.js';
-import SignalEventDefinition from './SignalEventDefinition.js';
-import TerminateEventDefinition from './TerminateEventDefinition.js';
-import TimerEventDefinition from './TimerEventDefinition.js';
-
-export {
-  CancelEventDefinition,
-  CompensateEventDefinition,
-  ConditionalEventDefinition,
-  ErrorEventDefinition,
-  EscalationEventDefinition,
-  LinkEventDefinition,
-  MessageEventDefinition,
-  SignalEventDefinition,
-  TerminateEventDefinition,
-  TimerEventDefinition,
-};
+export { CancelEventDefinition } from './CancelEventDefinition.js';
+export { CompensateEventDefinition } from './CompensateEventDefinition.js';
+export { ConditionalEventDefinition } from './ConditionalEventDefinition.js';
+export { ErrorEventDefinition } from './ErrorEventDefinition.js';
+export { EscalationEventDefinition } from './EscalationEventDefinition.js';
+export { LinkEventDefinition } from './LinkEventDefinition.js';
+export { MessageEventDefinition } from './MessageEventDefinition.js';
+export { SignalEventDefinition } from './SignalEventDefinition.js';
+export { TerminateEventDefinition } from './TerminateEventDefinition.js';
+export { TimerEventDefinition } from './TimerEventDefinition.js';

package/src/events/BoundaryEvent.js

@@ -1,18 +1,26 @@
-import Activity from '../activity/Activity.js';
-import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution.js';
+import { Activity } from '../activity/Activity.js';
+import { EventDefinitionExecution } from '../eventDefinitions/EventDefinitionExecution.js';
 import { cloneContent, cloneMessage } from '../messageHelper.js';
 import { brokerSafeId } from '../shared.js';
-
-const kAttachedTags = Symbol.for('attachedConsumers');
-const kCompleteContent = Symbol.for('completeContent');
-const kExecuteMessage = Symbol.for('executeMessage');
-const kExecution = Symbol.for('execution');
-const kShovels = Symbol.for('shovels');
-
-export default function BoundaryEvent(activityDef, context) {
+import { K_EXECUTE_MESSAGE, K_EXECUTION } from '../constants.js';
+
+const K_ATTACHED_TAGS = Symbol.for('attachedConsumers');
+const K_COMPLETE_CONTENT = Symbol.for('completeContent');
+const K_SHOVELS = Symbol.for('shovels');
+
+/**
+ * Boundary event
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function BoundaryEvent(activityDef, context) {
   return new Activity(BoundaryEventBehaviour, activityDef, context);
 }
 
+/**
+ * Boundary event behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function BoundaryEventBehaviour(activity) {
   this.id = activity.id;
   this.type = activity.type;
@@ -20,32 +28,35 @@ export function BoundaryEventBehaviour(activity) {
   this.activity = activity;
   this.environment = activity.environment;
   this.broker = activity.broker;
-  this[kExecution] =
+  this[K_EXECUTION] =
     activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
-  this[kShovels] = new Set();
-  this[kAttachedTags] = new Set();
+  this[K_SHOVELS] = new Set();
+  this[K_ATTACHED_TAGS] = new Set();
 }
 
-Object.defineProperties(BoundaryEventBehaviour.prototype, {
-  executionId: {
-    get() {
-      return this[kExecuteMessage]?.content.executionId;
-    },
+Object.defineProperty(BoundaryEventBehaviour.prototype, 'executionId', {
+  get() {
+    return this[K_EXECUTE_MESSAGE]?.content.executionId;
   },
-  cancelActivity: {
-    get() {
-      const behaviour = this.activity.behaviour || {};
-      return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
-    },
+});
+
+Object.defineProperty(BoundaryEventBehaviour.prototype, 'cancelActivity', {
+  get() {
+    const behaviour = this.activity.behaviour || {};
+    return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
   },
 });
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
   const { isRootScope, executionId } = executeMessage.content;
 
-  const eventDefinitionExecution = this[kExecution];
+  const eventDefinitionExecution = this[K_EXECUTION];
   if (isRootScope && executeMessage.content.id === this.id) {
-    this[kExecuteMessage] = executeMessage;
+    this[K_EXECUTE_MESSAGE] = executeMessage;
 
     const broker = this.broker;
     if (executeMessage.fields.routingKey === 'execute.bound.completed') {
@@ -59,7 +70,7 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
       consumerTag,
       priority: 300,
     });
-    this[kAttachedTags].add(consumerTag);
+    this[K_ATTACHED_TAGS].add(consumerTag);
 
     broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
       consumerTag: `_api-${executionId}`,
@@ -109,9 +120,9 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, { conten
     );
   }
 
-  this[kCompleteContent] = content;
+  this[K_COMPLETE_CONTENT] = content;
 
-  const { inbound, executionId } = this[kExecuteMessage].content;
+  const { inbound, executionId } = this[K_EXECUTE_MESSAGE].content;
   const attachedToContent = inbound?.[0];
   const attachedTo = this.attachedTo;
 
@@ -121,7 +132,7 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, { conten
 
   if (content.isRecovered && !attachedTo.isRunning) {
     const attachedExecuteTag = `_on-attached-execute-${executionId}`;
-    this[kAttachedTags].add(attachedExecuteTag);
+    this[K_ATTACHED_TAGS].add(attachedExecuteTag);
     attachedTo.broker.subscribeOnce(
       'execution',
       '#',
@@ -139,8 +150,8 @@ BoundaryEventBehaviour.prototype._onAttachedLeave = function onAttachedLeave(_,
   if (content.id !== this.attachedTo.id) return;
 
   this._stop();
-  const completeContent = this[kCompleteContent];
-  if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[kExecuteMessage].content);
+  const completeContent = this[K_COMPLETE_CONTENT];
+  if (!completeContent) return this.broker.publish('execution', 'execute.discard', this[K_EXECUTE_MESSAGE].content);
   return this.broker.publish('execution', 'execute.completed', cloneContent(completeContent));
 };
 
@@ -149,7 +160,7 @@ BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_,
   const attachedTo = this.attachedTo;
 
   const errorConsumerTag = `_bound-error-listener-${executionId}`;
-  this[kAttachedTags].add(errorConsumerTag);
+  this[K_ATTACHED_TAGS].add(errorConsumerTag);
 
   attachedTo.broker.subscribeTmp(
     'event',
@@ -171,7 +182,7 @@ BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_,
 
 BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_, message) {
   const content = message.content;
-  const { executionId, parent } = this[kExecuteMessage].content;
+  const { executionId, parent } = this[K_EXECUTE_MESSAGE].content;
   const id = this.id,
     attachedTo = this.attachedTo;
   this.activity.logger.debug(`<${executionId} (${id})> detach from activity <${attachedTo.id}>`);
@@ -180,7 +191,7 @@ BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_,
   const { executionId: detachId, bindExchange, sourceExchange, sourcePattern } = content;
 
   const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
-  this[kShovels].add(shovelName);
+  this[K_SHOVELS].add(shovelName);
 
   const broker = this.broker;
   attachedTo.broker.createShovel(
@@ -229,7 +240,7 @@ BoundaryEventBehaviour.prototype._onApiMessage = function onApiMessage(_, messag
 };
 
 BoundaryEventBehaviour.prototype._onRepeatMessage = function onRepeatMessage(_, message) {
-  const executeMessage = this[kExecuteMessage];
+  const executeMessage = this[K_EXECUTE_MESSAGE];
   const repeat = message.content.repeat;
   this.broker
     .getQueue('inbound-q')
@@ -240,10 +251,10 @@ BoundaryEventBehaviour.prototype._stop = function stop(detach) {
   const attachedTo = this.attachedTo,
     broker = this.broker,
     executionId = this.executionId;
-  for (const tag of this[kAttachedTags]) attachedTo.broker.cancel(tag);
-  this[kAttachedTags].clear();
-  for (const shovelName of this[kShovels]) attachedTo.broker.closeShovel(shovelName);
-  this[kShovels].clear();
+  for (const tag of this[K_ATTACHED_TAGS]) attachedTo.broker.cancel(tag);
+  this[K_ATTACHED_TAGS].clear();
+  for (const shovelName of this[K_SHOVELS]) attachedTo.broker.closeShovel(shovelName);
+  this[K_SHOVELS].clear();
 
   broker.cancel('_execution-tag');
   broker.cancel(`_execution-completed-${executionId}`);

package/src/events/EndEvent.js

@@ -1,22 +1,34 @@
-import Activity from '../activity/Activity.js';
-import EventDefinitionExecution from '../eventDefinitions/EventDefinitionExecution.js';
+import { Activity } from '../activity/Activity.js';
+import { EventDefinitionExecution } from '../eventDefinitions/EventDefinitionExecution.js';
 import { cloneContent } from '../messageHelper.js';
+import { K_EXECUTION } from '../constants.js';
 
-const kExecution = Symbol.for('execution');
-
-export default function EndEvent(activityDef, context) {
+/**
+ * End event
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
+export function EndEvent(activityDef, context) {
   return new Activity(EndEventBehaviour, { ...activityDef, isThrowing: true }, context);
 }
 
+/**
+ * End event behaviour
+ * @param {import('#types').Activity} activity
+ */
 export function EndEventBehaviour(activity) {
   this.id = activity.id;
   this.type = activity.type;
   this.broker = activity.broker;
-  this[kExecution] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
+  this[K_EXECUTION] = activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions);
 }
 
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 EndEventBehaviour.prototype.execute = function execute(executeMessage) {
-  const execution = this[kExecution];
+  const execution = this[K_EXECUTION];
   if (execution) {
     return execution.execute(executeMessage);
   }