bpmn-elements 14.1.0 → 15.0.1

package/src/definition/DefinitionExecution.js

@@ -24,21 +24,21 @@ export default function DefinitionExecution(definition, context) {
   this.context = context;
 
   const processes = context.getProcesses();
-  const ids = [];
-  const executable = [];
+  const ids = new Set();
+  const executable = new Set();
   for (const bp of processes) {
     bp.environment.assignVariables(environment.variables);
     bp.environment.assignSettings(environment.settings);
-    ids.push(bp.id);
-    if (bp.isExecutable) executable.push(bp);
+    ids.add(bp.id);
+    if (bp.isExecutable) executable.add(bp);
   }
 
   this[kProcesses] = {
     processes,
-    running: [],
     ids,
     executable,
-    postponed: [],
+    running: new Set(),
+    postponed: new Set(),
   };
 
   broker.assertExchange('execution', 'topic', { autoDelete: false, durable: true });
@@ -79,12 +79,12 @@ Object.defineProperties(DefinitionExecution.prototype, {
   },
   processes: {
     get() {
-      return this[kProcesses].running;
+      return [...this[kProcesses].running];
     },
   },
   postponedCount: {
     get() {
-      return this[kProcesses].postponed.length;
+      return this[kProcesses].postponed.size;
     },
   },
   isRunning: {
@@ -96,7 +96,7 @@ Object.defineProperties(DefinitionExecution.prototype, {
     get() {
       let status = 'idle';
       const running = this[kProcesses].running;
-      if (!running || !running.length) return status;
+      if (!running.size) return status;
 
       for (const bp of running) {
         const bpStatus = bp.activityStatus;
@@ -143,13 +143,15 @@ DefinitionExecution.prototype.execute = function execute(executeMessage) {
   if (content.processId) {
     const startWithProcess = this.getProcessById(content.processId);
     if (startWithProcess) {
-      executable.splice(0);
-      executable.push(startWithProcess);
+      executable.clear();
+      executable.add(startWithProcess);
     }
   }
 
   this._debug('execute definition');
-  running.push(...executable);
+  for (const bp of executable) {
+    running.add(bp);
+  }
   this._activate(executable);
   this._start();
   return true;
@@ -162,7 +164,7 @@ DefinitionExecution.prototype.resume = function resume() {
 
   const { running, postponed } = this[kProcesses];
   this._activate(running);
-  postponed.splice(0);
+  postponed.clear();
   this[kProcessesQ].consume(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
@@ -184,22 +186,22 @@ DefinitionExecution.prototype.recover = function recover(state) {
   this._debug(`recover ${this[kStatus]} definition execution`);
 
   const running = this[kProcesses].running;
-  running.splice(0);
+  running.clear();
 
-  const ids = [];
+  const ids = new Set();
   for (const bpState of state.processes) {
     const bpid = bpState.id;
     let bp;
-    if (ids.indexOf(bpid) > -1) {
+    if (ids.has(bpid)) {
       bp = this.context.getNewProcessById(bpid);
     } else {
       bp = this.getProcessById(bpid);
     }
     if (!bp) continue;
 
-    ids.push(bpid);
+    ids.add(bpid);
     bp.recover(bpState);
-    running.push(bp);
+    running.add(bp);
   }
 
   return this;
@@ -211,7 +213,7 @@ DefinitionExecution.prototype.stop = function stop() {
 
 DefinitionExecution.prototype.getProcesses = function getProcesses() {
   const { running, processes } = this[kProcesses];
-  const result = running.slice();
+  const result = [...running];
   for (const bp of processes) {
     if (!result.find((runningBp) => bp.id === runningBp.id)) result.push(bp);
   }
@@ -227,26 +229,31 @@ DefinitionExecution.prototype.getProcessesById = function getProcessesById(proce
 };
 
 DefinitionExecution.prototype.getProcessByExecutionId = function getProcessByExecutionId(processExecutionId) {
-  const running = this[kProcesses].running;
-  return running.find((bp) => bp.executionId === processExecutionId);
+  for (const bp of this[kProcesses].running) {
+    if (bp.executionId === processExecutionId) return bp;
+  }
 };
 
 DefinitionExecution.prototype.getRunningProcesses = function getRunningProcesses() {
-  const running = this[kProcesses].running;
-  return running.filter((bp) => bp.executionId);
+  return [...this[kProcesses].running].filter((bp) => bp.executionId);
 };
 
 DefinitionExecution.prototype.getExecutableProcesses = function getExecutableProcesses() {
-  return this[kProcesses].executable.slice();
+  return [...this[kProcesses].executable];
 };
 
 DefinitionExecution.prototype.getState = function getState() {
+  const processes = [];
+  for (const bp of this[kProcesses].running) {
+    processes.push(bp.getState());
+  }
+
   return {
     executionId: this.executionId,
     stopped: this[kStopped],
     completed: this[kCompleted],
     status: this[kStatus],
-    processes: this[kProcesses].running.map((bp) => bp.getState()),
+    processes,
   };
 };
 
@@ -263,31 +270,32 @@ DefinitionExecution.prototype.getApi = function getApi(apiMessage) {
   const self = this;
 
   api.getExecuting = function getExecuting() {
-    return postponed.reduce((result, msg) => {
+    const apis = [];
+    for (const msg of postponed) {
       const bpApi = self._getProcessApi(msg);
-      if (bpApi) result.push(bpApi);
-      return result;
-    }, []);
+      if (bpApi) apis.push(bpApi);
+    }
+    return apis;
   };
 
   return api;
 };
 
 DefinitionExecution.prototype.getPostponed = function getPostponed(...args) {
-  const running = this[kProcesses].running;
-  return running.reduce((result, p) => {
-    result = result.concat(p.getPostponed(...args));
-    return result;
-  }, []);
+  let result = [];
+  for (const bp of this[kProcesses].running) {
+    result = result.concat(bp.getPostponed(...args));
+  }
+  return result;
 };
 
 DefinitionExecution.prototype._start = function start() {
   const { ids, executable, postponed } = this[kProcesses];
-  if (!ids.length) {
+  if (!ids.size) {
     return this._complete('completed');
   }
 
-  if (!executable.length) {
+  if (!executable.size) {
     return this._complete('error', { error: new Error('No executable process') });
   }
 
@@ -296,7 +304,7 @@ DefinitionExecution.prototype._start = function start() {
   for (const bp of executable) bp.init();
   for (const bp of executable) bp.run();
 
-  postponed.splice(0);
+  postponed.clear();
   this[kProcessesQ].assertConsumer(this[kMessageHandlers].onProcessMessage, {
     prefetch: 1000,
     consumerTag: `_definition-activity-${this.executionId}`,
@@ -348,7 +356,7 @@ DefinitionExecution.prototype._onChildEvent = function onChildEvent(routingKey,
   const content = message.content;
   const parent = (content.parent = content.parent || {});
 
-  const isDirectChild = this[kProcesses].ids.indexOf(content.id) > -1;
+  const isDirectChild = this[kProcesses].ids.has(content.id);
   if (isDirectChild) {
     parent.executionId = this.executionId;
   } else {
@@ -434,7 +442,7 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
           { mandatory: true, type: 'error' },
         );
       } else {
-        for (const bp of this[kProcesses].running.slice()) {
+        for (const bp of new Set(this[kProcesses].running)) {
           if (bp.id !== childId) bp.stop();
         }
 
@@ -450,13 +458,16 @@ DefinitionExecution.prototype._onProcessMessage = function onProcessMessage(rout
 DefinitionExecution.prototype._stateChangeMessage = function stateChangeMessage(message, postponeMessage) {
   let previousMsg;
   const postponed = this[kProcesses].postponed;
-  const idx = postponed.findIndex((msg) => msg.content.executionId === message.content.executionId);
-  if (idx > -1) {
-    previousMsg = postponed.splice(idx, 1)[0];
+  for (const msg of postponed) {
+    if (msg.content.executionId === message.content.executionId) {
+      previousMsg = msg;
+      postponed.delete(msg);
+      break;
+    }
   }
 
   if (previousMsg) previousMsg.ack();
-  if (postponeMessage) postponed.push(message);
+  if (postponeMessage) postponed.add(message);
 };
 
 DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(message) {
@@ -479,9 +490,9 @@ DefinitionExecution.prototype._onProcessCompleted = function onProcessCompleted(
 
 DefinitionExecution.prototype._onStopped = function onStopped(message) {
   const running = this[kProcesses].running;
-  this._debug(`stop definition execution (stop process executions ${running.length})`);
+  this._debug(`stop definition execution (stop process executions ${running.size})`);
   this[kProcessesQ].close();
-  for (const bp of running.slice()) bp.stop();
+  for (const bp of new Set(running)) bp.stop();
   this._deactivate();
 
   this[kStopped] = true;
@@ -505,7 +516,7 @@ DefinitionExecution.prototype._onApiMessage = function onApiMessage(routingKey,
   }
 
   if (delegate) {
-    for (const bp of this[kProcesses].running.slice()) {
+    for (const bp of new Set(this[kProcesses].running)) {
       bp.broker.publish('api', routingKey, cloneContent(message.content), message.properties);
     }
   }
@@ -528,7 +539,7 @@ DefinitionExecution.prototype._startProcessesByMessage = function startProcesses
     if (!bp.executionId) {
       this._debug(`start <${bp.id}> by <${reference.referenceId}> (${reference.referenceType})`);
       this._activateProcess(bp);
-      running.push(bp);
+      running.add(bp);
       bp.init();
       bp.run();
       if (reference.referenceType === 'message') return;
@@ -539,7 +550,7 @@ DefinitionExecution.prototype._startProcessesByMessage = function startProcesses
 
     const targetProcess = this.context.getNewProcessById(bp.id);
     this._activateProcess(targetProcess);
-    running.push(targetProcess);
+    running.add(targetProcess);
     targetProcess.init();
     targetProcess.run();
     if (reference.referenceType === 'message') return;
@@ -573,7 +584,7 @@ DefinitionExecution.prototype._onMessageOutbound = function onMessageOutbound(ro
   targetProcess = targetProcess || this.context.getNewProcessById(target.processId);
 
   this._activateProcess(targetProcess);
-  this[kProcesses].running.push(targetProcess);
+  this[kProcesses].running.add(targetProcess);
   targetProcess.init();
   targetProcess.run();
   targetProcess.sendMessage(message);
@@ -605,7 +616,7 @@ DefinitionExecution.prototype._onCallActivity = function onCallActivity(routingK
   this._debug(`call from <${fromParent.id}.${fromId}> to <${calledElement}>`);
 
   this._activateProcess(targetProcess);
-  this[kProcesses].running.push(targetProcess);
+  this[kProcesses].running.add(targetProcess);
   targetProcess.init(bpExecutionId);
   targetProcess.run({ inbound: [cloneContent(content)] });
 };
@@ -672,10 +683,9 @@ DefinitionExecution.prototype._onDelegateMessage = function onDelegateMessage(ro
 };
 
 DefinitionExecution.prototype._removeProcessByExecutionId = function removeProcessByExecutionId(processExecutionId) {
-  const running = this[kProcesses].running;
-  const idx = running.findIndex((p) => p.executionId === processExecutionId);
-  if (idx === -1) return;
-  return running.splice(idx, 1)[0];
+  const bp = this.getProcessByExecutionId(processExecutionId);
+  if (bp) this[kProcesses].running.delete(bp);
+  return bp;
 };
 
 DefinitionExecution.prototype._complete = function complete(completionType, content, options) {

package/src/eventDefinitions/TimerEventDefinition.js

@@ -6,7 +6,7 @@ const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
 
-const timerTypes = ['timeDuration', 'timeDate', 'timeCycle'];
+const timerTypes = new Set(['timeDuration', 'timeDate', 'timeCycle']);
 
 export default function TimerEventDefinition(activity, eventDefinition) {
   const type = (this.type = eventDefinition.type || 'TimerEventDefinition');

package/src/events/BoundaryEvent.js

@@ -22,8 +22,8 @@ export function BoundaryEventBehaviour(activity) {
   this.broker = activity.broker;
   this[kExecution] =
     activity.eventDefinitions && new EventDefinitionExecution(activity, activity.eventDefinitions, 'execute.bound.completed');
-  this[kShovels] = [];
-  this[kAttachedTags] = [];
+  this[kShovels] = new Set();
+  this[kAttachedTags] = new Set();
 }
 
 Object.defineProperties(BoundaryEventBehaviour.prototype, {
@@ -60,7 +60,7 @@ BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {
       consumerTag,
       priority: 300,
     });
-    this[kAttachedTags].push(consumerTag);
+    this[kAttachedTags].add(consumerTag);
 
     broker.subscribeOnce('api', `activity.#.${executionId}`, this._onApiMessage.bind(this), {
       consumerTag: `_api-${executionId}`,
@@ -118,7 +118,7 @@ BoundaryEventBehaviour.prototype._onCompleted = function onCompleted(_, { conten
 
   if (content.isRecovered && !attachedTo.isRunning) {
     const attachedExecuteTag = `_on-attached-execute-${executionId}`;
-    this[kAttachedTags].push(attachedExecuteTag);
+    this[kAttachedTags].add(attachedExecuteTag);
     attachedTo.broker.subscribeOnce(
       'execution',
       '#',
@@ -146,7 +146,7 @@ BoundaryEventBehaviour.prototype._onExpectMessage = function onExpectMessage(_,
   const attachedTo = this.attachedTo;
 
   const errorConsumerTag = `_bound-error-listener-${executionId}`;
-  this[kAttachedTags].push(errorConsumerTag);
+  this[kAttachedTags].add(errorConsumerTag);
 
   attachedTo.broker.subscribeTmp(
     'event',
@@ -177,7 +177,7 @@ BoundaryEventBehaviour.prototype._onDetachMessage = function onDetachMessage(_,
   const { executionId: detachId, bindExchange, sourceExchange, sourcePattern } = content;
 
   const shovelName = `_detached-${brokerSafeId(id)}_${detachId}`;
-  this[kShovels].push(shovelName);
+  this[kShovels].add(shovelName);
 
   const broker = this.broker;
   attachedTo.broker.createShovel(
@@ -238,8 +238,10 @@ BoundaryEventBehaviour.prototype._stop = function stop(detach) {
   const attachedTo = this.attachedTo,
     broker = this.broker,
     executionId = this.executionId;
-  for (const tag of this[kAttachedTags].splice(0)) attachedTo.broker.cancel(tag);
-  for (const shovelName of this[kShovels].splice(0)) attachedTo.broker.closeShovel(shovelName);
+  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();
 
   broker.cancel('_execution-tag');
   broker.cancel(`_execution-completed-${executionId}`);

package/src/process/Process.js

@@ -36,7 +36,7 @@ export function Process(processDef, context) {
     discarded: 0,
   };
   this[kConsuming] = false;
-  this[kExec] = {};
+  this[kExec] = new Map();
   this[kStatus] = undefined;
   this[kStopped] = false;
 
@@ -90,13 +90,13 @@ Object.defineProperties(Process.prototype, {
   },
   executionId: {
     get() {
-      const { executionId, initExecutionId } = this[kExec];
-      return executionId || initExecutionId;
+      const exec = this[kExec];
+      return exec.get('executionId') || exec.get('initExecutionId');
     },
   },
   execution: {
     get() {
-      return this[kExec].execution;
+      return this[kExec].get('execution');
     },
   },
   status: {
@@ -106,14 +106,16 @@ Object.defineProperties(Process.prototype, {
   },
   activityStatus: {
     get() {
-      return (this[kExec].execution && this[kExec].execution.activityStatus) || 'idle';
+      const execution = this[kExec].get('execution');
+      return (execution && execution.activityStatus) || 'idle';
     },
   },
 });
 
 Process.prototype.init = function init(useAsExecutionId) {
-  const exec = this[kExec];
-  const initExecutionId = (exec.initExecutionId = useAsExecutionId || getUniqueId(this.id));
+  const initExecutionId = useAsExecutionId || getUniqueId(this.id);
+  this[kExec].set('initExecutionId', initExecutionId);
+
   this._debug(`initialized with executionId <${initExecutionId}>`);
   this._publishEvent('init', this._createMessage({ executionId: initExecutionId }));
 };
@@ -122,8 +124,9 @@ Process.prototype.run = function run(runContent) {
   if (this.isRunning) throw new Error(`process <${this.id}> is already running`);
 
   const exec = this[kExec];
-  const executionId = (exec.executionId = exec.initExecutionId || getUniqueId(this.id));
-  exec.initExecutionId = undefined;
+  const executionId = exec.get('initExecutionId') || getUniqueId(this.id);
+  exec.delete('initExecutionId');
+  exec.set('executionId', executionId);
 
   const content = this._createMessage({ ...runContent, executionId });
 
@@ -168,12 +171,12 @@ Process.prototype.recover = function recover(state) {
   this[kStopped] = !!state.stopped;
   this[kStatus] = state.status;
   const exec = this[kExec];
-  exec.executionId = state.executionId;
+  exec.set('executionId', state.executionId);
   this[kCounters] = { ...this[kCounters], ...state.counters };
   this.environment.recover(state.environment);
 
   if (state.execution) {
-    exec.execution = new ProcessExecution(this, this.context).recover(state.execution);
+    exec.set('execution', new ProcessExecution(this, this.context).recover(state.execution));
   }
 
   this.broker.recover(state.broker);
@@ -228,7 +231,6 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
     return this._onResumeMessage(message);
   }
 
-  const exec = this[kExec];
   this[kStateMessage] = message;
 
   switch (routingKey) {
@@ -238,7 +240,7 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
       this[kStatus] = 'entered';
       if (fields.redelivered) break;
 
-      exec.execution = undefined;
+      this[kExec].delete('execution');
       this._publishEvent('enter', content);
 
       break;
@@ -250,9 +252,11 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
       break;
     }
     case 'run.execute': {
+      const exec = this[kExec];
       this[kStatus] = 'executing';
       const executeMessage = cloneMessage(message);
-      if (fields.redelivered && !exec.execution) {
+      let execution = exec.get('execution');
+      if (fields.redelivered && !execution) {
         executeMessage.fields.redelivered = undefined;
       }
       this[kExecuteMessage] = message;
@@ -262,7 +266,8 @@ Process.prototype._onRunMessage = function onRunMessage(routingKey, message) {
         consumerTag: '_process-execution',
       });
 
-      const execution = (exec.execution = exec.execution || new ProcessExecution(this, this.context));
+      execution = execution || new ProcessExecution(this, this.context);
+      exec.set('execution', execution);
       return execution.execute(executeMessage);
     }
     case 'run.error': {