bpmn-elements 11.1.1 → 13.0.0

package/src/definition/DefinitionExecution.js

@@ -61,69 +61,61 @@ export default function DefinitionExecution(definition, context) {
   };
 }
 
-Object.defineProperty(DefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+Object.defineProperties(DefinitionExecution.prototype, {
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
+  completed: {
+    get() {
+      return this[kCompleted];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
+  status: {
+    get() {
+      return this[kStatus];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'processes', {
-  enumerable: true,
-  get() {
-    return this[kProcesses].running;
+  processes: {
+    get() {
+      return this[kProcesses].running;
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'postponedCount', {
-  get() {
-    return this[kProcesses].postponed.length;
+  postponedCount: {
+    get() {
+      return this[kProcesses].postponed.length;
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
-  get() {
-    return this[kActivated];
+  isRunning: {
+    get() {
+      return this[kActivated];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'activityStatus', {
-  get() {
-    let status = 'idle';
-    const running = this[kProcesses].running;
-    if (!running || !running.length) return status;
-
-    for (const bp of running) {
-      const bpStatus = bp.activityStatus;
-      switch (bp.activityStatus) {
-        case 'idle':
-          break;
-        case 'executing':
-          return bpStatus;
-        case 'timer':
-          status = bpStatus;
-          break;
-        case 'wait':
-          if (status === 'idle') status = bpStatus;
-          break;
+  activityStatus: {
+    get() {
+      let status = 'idle';
+      const running = this[kProcesses].running;
+      if (!running || !running.length) return status;
+
+      for (const bp of running) {
+        const bpStatus = bp.activityStatus;
+        switch (bp.activityStatus) {
+          case 'idle':
+            break;
+          case 'executing':
+            return bpStatus;
+          case 'timer':
+            status = bpStatus;
+            break;
+          case 'wait':
+            if (status === 'idle') status = bpStatus;
+            break;
+        }
       }
-    }
 
-    return status;
+      return status;
+    },
   },
 });
 

package/src/eventDefinitions/EventDefinitionExecution.js

@@ -15,17 +15,16 @@ export default function EventDefinitionExecution(activity, eventDefinitions, com
   this[kExecuteMessage] = null;
 }
 
-Object.defineProperty(EventDefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
+Object.defineProperties(EventDefinitionExecution.prototype, {
+  completed: {
+    get() {
+      return this[kCompleted];
+    },
   },
-});
-
-Object.defineProperty(EventDefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
 });
 

package/src/eventDefinitions/TimerEventDefinition.js

@@ -23,24 +23,22 @@ export default function TimerEventDefinition(activity, eventDefinition) {
   this[kTimer] = null;
 }
 
-Object.defineProperty(TimerEventDefinition.prototype, 'executionId', {
-  get() {
-    const content = this[kTimerContent];
-    return content && content.executionId;
+Object.defineProperties(TimerEventDefinition.prototype, {
+  executionId: {
+    get() {
+      const content = this[kTimerContent];
+      return content && content.executionId;
+    },
   },
-});
-
-Object.defineProperty(TimerEventDefinition.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
-});
-
-Object.defineProperty(TimerEventDefinition.prototype, 'timer', {
-  enumerable: true,
-  get() {
-    return this[kTimer];
+  timer: {
+    get() {
+      return this[kTimer];
+    },
   },
 });
 

package/src/events/BoundaryEvent.js

@@ -25,18 +25,18 @@ export function BoundaryEventBehaviour(activity) {
   this[kAttachedTags] = [];
 }
 
-Object.defineProperty(BoundaryEventBehaviour.prototype, 'executionId', {
-  get() {
-    const message = this[kExecuteMessage];
-    return message && message.content.executionId;
+Object.defineProperties(BoundaryEventBehaviour.prototype, {
+  executionId: {
+    get() {
+      const message = this[kExecuteMessage];
+      return message && message.content.executionId;
+    },
   },
-});
-
-Object.defineProperty(BoundaryEventBehaviour.prototype, 'cancelActivity', {
-  enumerable: true,
-  get() {
-    const behaviour = this.activity.behaviour || {};
-    return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+  cancelActivity: {
+    get() {
+      const behaviour = this.activity.behaviour || {};
+      return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+    },
   },
 });
 

package/src/events/index.js

@@ -0,0 +1,5 @@
+export * from './BoundaryEvent.js';
+export * from './EndEvent.js';
+export * from './IntermediateCatchEvent.js';
+export * from './IntermediateThrowEvent.js';
+export * from './StartEvent.js';

package/src/flows/Association.js

@@ -34,7 +34,6 @@ export default function Association(associationDef, {environment}) {
 }
 
 Object.defineProperty(Association.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/flows/MessageFlow.js

@@ -35,7 +35,6 @@ export default function MessageFlow(flowDef, context) {
 }
 
 Object.defineProperty(MessageFlow.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/flows/SequenceFlow.js

@@ -41,7 +41,6 @@ function SequenceFlow(flowDef, {environment}) {
 }
 
 Object.defineProperty(SequenceFlow.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/gateways/index.js

@@ -0,0 +1,4 @@
+export * from './EventBasedGateway.js';
+export * from './ExclusiveGateway.js';
+export * from './InclusiveGateway.js';
+export * from './ParallelGateway.js';

package/src/process/Process.js

@@ -60,68 +60,54 @@ export function Process(processDef, context) {
   this[kExtensions] = context.loadExtensions(this);
 }
 
-Object.defineProperty(Process.prototype, 'counters', {
-  enumerable: true,
-  get() {
-    return {...this[kCounters]};
+Object.defineProperties(Process.prototype, {
+  counters: {
+    get() {
+      return {...this[kCounters]};
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'lanes', {
-  enumerable: true,
-  get() {
-    const lanes = this[kLanes];
-    return lanes && lanes.slice();
+  lanes: {
+    get() {
+      const lanes = this[kLanes];
+      return lanes && lanes.slice();
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'extensions', {
-  enumerable: true,
-  get() {
-    return this[kExtensions];
+  extensions: {
+    get() {
+      return this[kExtensions];
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'isRunning', {
-  enumerable: true,
-  get() {
-    if (!this[kConsuming]) return false;
-    return !!this.status;
+  isRunning: {
+    get() {
+      if (!this[kConsuming]) return false;
+      return !!this.status;
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'executionId', {
-  enumerable: true,
-  get() {
-    const {executionId, initExecutionId} = this[kExec];
-    return executionId || initExecutionId;
+  executionId: {
+    get() {
+      const {executionId, initExecutionId} = this[kExec];
+      return executionId || initExecutionId;
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'execution', {
-  enumerable: true,
-  get() {
-    return this[kExec].execution;
+  execution: {
+    get() {
+      return this[kExec].execution;
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
+  status: {
+    get() {
+      return this[kStatus];
+    },
   },
-});
-
-Object.defineProperty(Process.prototype, 'activityStatus', {
-  get() {
-    return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+  activityStatus: {
+    get() {
+      return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+    },
   },
 });
 

package/src/process/ProcessExecution.js

@@ -58,42 +58,36 @@ function ProcessExecution(parentActivity, context) {
   };
 }
 
-Object.defineProperty(ProcessExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+Object.defineProperties(ProcessExecution.prototype, {
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
-});
-
-Object.defineProperty(ProcessExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
+  completed: {
+    get() {
+      return this[kCompleted];
+    },
   },
-});
-
-Object.defineProperty(ProcessExecution.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
+  status: {
+    get() {
+      return this[kStatus];
+    },
   },
-});
-
-Object.defineProperty(ProcessExecution.prototype, 'postponedCount', {
-  get() {
-    return this[kElements].postponed.length;
+  postponedCount: {
+    get() {
+      return this[kElements].postponed.length;
+    },
   },
-});
-
-Object.defineProperty(ProcessExecution.prototype, 'isRunning', {
-  get() {
-    return this[kActivated];
+  isRunning: {
+    get() {
+      return this[kActivated];
+    },
   },
-});
-
-Object.defineProperty(ProcessExecution.prototype, 'activityStatus', {
-  get() {
-    return this[kTracker].activityStatus;
+  activityStatus: {
+    get() {
+      return this[kTracker].activityStatus;
+    },
   },
 });
 

package/src/tasks/LoopCharacteristics.js

@@ -120,6 +120,7 @@ function ParallelLoopCharacteristics(activity, characteristics) {
   this.characteristics = characteristics;
   this.running = 0;
   this.index = 0;
+  this.discarded = 0;
 }
 
 ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage) {
@@ -128,8 +129,10 @@ ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage)
 
   const isRedelivered = executeMessage.fields.redelivered;
   if (isRedelivered) {
-    if (!isNaN(executeMessage.content.index)) this.index = executeMessage.content.index;
-    if (!isNaN(executeMessage.content.running)) this.running = executeMessage.content.running;
+    const { index, running, discarded } = executeMessage.content;
+    if (!isNaN(index)) this.index = index;
+    if (!isNaN(running)) this.running = running;
+    if (!isNaN(discarded)) this.discarded = discarded;
   }
   chr.subscribe(this._onCompleteMessage.bind(this));
 
@@ -160,6 +163,7 @@ ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
     ...chr.getContent(),
     index: this.index,
     running: this.running,
+    discarded: this.discarded,
     output: chr.output,
     preventComplete: true,
   });
@@ -169,11 +173,15 @@ ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
   }
 };
 
-ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
+ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(routingKey, message) {
   const chr = this.characteristics;
   const {content} = message;
   if (content.output !== undefined) chr.output[content.index] = content.output;
 
+  if (routingKey === 'execute.discard') {
+    this.discarded++;
+  }
+
   this.running--;
 
   this.activity.broker.publish('execution', 'execute.iteration.completed', {
@@ -181,17 +189,18 @@ ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMe
     ...chr.getContent(),
     index: this.index,
     running: this.running,
+    discarded: this.discarded,
     output: chr.output,
     state: 'iteration.completed',
     preventComplete: true,
   });
 
   if (this.running <= 0 && !chr.next(this.index)) {
-    return chr.complete(content);
+    return chr.complete(content, this.discarded === this.index);
   }
 
   if (chr.isCompletionConditionMet(message)) {
-    return chr.complete(content);
+    return chr.complete(content, this.discarded === this.index);
   }
 
   if (this.running <= 0) {
@@ -299,10 +308,10 @@ Characteristics.prototype.isCompletionConditionMet = function isCompletionCondit
   return this.activity.environment.resolveExpression(this.completionCondition, cloneMessage(message, {loopOutput: this.output}));
 };
 
-Characteristics.prototype.complete = function complete(content) {
+Characteristics.prototype.complete = function complete(content, allDiscarded) {
   this.stop();
 
-  return this.broker.publish('execution', 'execute.completed', {
+  return this.broker.publish('execution', 'execute.' + (allDiscarded ? 'discard' : 'completed'), {
     ...content,
     ...this.getContent(),
     output: this.output,
@@ -315,7 +324,9 @@ Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMess
 
   function onComplete(routingKey, message, ...args) {
     if (!message.content.isMultiInstance) return;
+
     switch (routingKey) {
+      case 'execute.discard':
       case 'execute.cancel':
       case 'execute.completed':
         return onIterationCompleteMessage(routingKey, message, ...args);