bpmn-elements 8.2.0 → 8.2.2

package/dist/src/shared.js

@@ -9,19 +9,15 @@ exports.generateId = generateId;
 exports.getOptionsAndCallback = getOptionsAndCallback;
 exports.getUniqueId = getUniqueId;
 const safePattern = /[./\\#*:\s]/g;
-
 function generateId() {
   return Math.random().toString(16).substring(2, 12);
 }
-
 function brokerSafeId(id) {
   return id.replace(safePattern, '_');
 }
-
 function getUniqueId(prefix) {
   return `${brokerSafeId(prefix)}_${generateId()}`;
 }
-
 function filterUndefined(obj) {
   return Object.keys(obj).reduce((filtered, key) => {
     const objValue = obj[key];
@@ -29,15 +25,12 @@ function filterUndefined(obj) {
     return filtered;
   }, {});
 }
-
 function getOptionsAndCallback(optionsOrCallback, callback) {
   let options;
-
   if (typeof optionsOrCallback === 'function') {
     callback = optionsOrCallback;
   } else {
     options = optionsOrCallback;
   }
-
   return [options, callback];
 }

package/dist/src/tasks/CallActivity.js

@@ -5,19 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.CallActivityBehaviour = CallActivityBehaviour;
 exports.default = CallActivity;
-
 var _Activity = _interopRequireDefault(require("../activity/Activity"));
-
 var _Errors = require("../error/Errors");
-
 var _messageHelper = require("../messageHelper");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function CallActivity(activityDef, context) {
   return new _Activity.default(CallActivityBehaviour, activityDef, context);
 }
-
 function CallActivityBehaviour(activity) {
   const {
     id,
@@ -32,19 +26,14 @@ function CallActivityBehaviour(activity) {
   this.broker = activity.broker;
   this.environment = activity.environment;
 }
-
 const proto = CallActivityBehaviour.prototype;
-
 proto.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const loopCharacteristics = this.loopCharacteristics;
-
   if (loopCharacteristics && executeContent.isRootScope) {
     return loopCharacteristics.execute(executeMessage);
   }
-
   const broker = this.broker;
-
   try {
     var calledElement = this.environment.resolveExpression(this.calledElement); // eslint-disable-line no-var
   } catch (err) {
@@ -54,7 +43,6 @@ proto.execute = function execute(executeMessage) {
       mandatory: true
     }));
   }
-
   const executionId = executeContent.executionId;
   broker.subscribeTmp('api', `activity.#.${executionId}`, (...args) => {
     this._onApiMessage(calledElement, executeMessage, ...args);
@@ -74,7 +62,6 @@ proto.execute = function execute(executeMessage) {
     type: 'call'
   });
 };
-
 proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, executeMessage, routingKey, message) {
   if (!message.properties.delegate) return;
   const {
@@ -93,7 +80,8 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, exe
     correlationId
   } = message.properties;
   this.broker.publish('event', 'activity.consumed', (0, _messageHelper.cloneContent)(executeContent, {
-    message: { ...delegateContent.message
+    message: {
+      ...delegateContent.message
     }
   }), {
     correlationId,
@@ -101,18 +89,15 @@ proto._onDelegatedApiMessage = function onDelegatedApiMessage(calledElement, exe
   });
   return this._onApiMessage(calledElement, executeMessage, routingKey, message);
 };
-
 proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routingKey, message) {
   const {
     type: messageType,
     correlationId
   } = message.properties;
   const executeContent = executeMessage.content;
-
   switch (messageType) {
     case 'stop':
       return this._stop(executeContent.executionId);
-
     case 'cancel':
       {
         this.broker.publish('event', 'activity.call.cancel', (0, _messageHelper.cloneContent)(executeContent, {
@@ -122,27 +107,22 @@ proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routi
           type: 'cancel'
         });
       }
-
     case 'signal':
       this._stop(executeContent.executionId);
-
       return this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
         output: message.content.message,
         state: messageType
       }), {
         correlationId
       });
-
     case 'error':
       this._stop(executeContent.executionId);
-
       return this.broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
         error: new _Errors.ActivityError(message.content.message, executeMessage, message.content)
       }, {
         mandatory: true,
         correlationId
       }));
-
     case 'discard':
       return this.broker.publish('event', 'activity.call.cancel', (0, _messageHelper.cloneContent)(executeContent, {
         state: 'discard',
@@ -152,7 +132,6 @@ proto._onApiMessage = function onApiMessage(calledElement, executeMessage, routi
       });
   }
 };
-
 proto._stop = function stop(executionId) {
   const broker = this.broker;
   broker.cancel(`_api-${executionId}`);

package/dist/src/tasks/LoopCharacteristics.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = LoopCharacteristics;
-
 var _Errors = require("../error/Errors");
-
 var _messageHelper = require("../messageHelper");
-
 function LoopCharacteristics(activity, loopCharacteristics) {
   this.activity = activity;
   this.loopCharacteristics = loopCharacteristics;
@@ -26,24 +23,19 @@ function LoopCharacteristics(activity, loopCharacteristics) {
   let completionCondition, startCondition, loopCardinality;
   if ('loopCardinality' in behaviour) loopCardinality = behaviour.loopCardinality;else if ('loopMaximum' in behaviour) loopCardinality = behaviour.loopMaximum;
   this.loopCardinality = loopCardinality;
-
   if (behaviour.loopCondition) {
     if (behaviour.testBefore) startCondition = behaviour.loopCondition;else completionCondition = behaviour.loopCondition;
   }
-
   if (behaviour.completionCondition) {
     completionCondition = behaviour.completionCondition;
   }
-
   if (collection) {
     this.loopType = 'collection';
     this.elementVariable = behaviour.elementVariable || 'item';
   } else if (completionCondition) this.loopType = 'complete condition';else if (startCondition) this.loopType = 'start condition';else if (loopCardinality) this.loopType = 'cardinality';
-
   this.characteristics = null;
   this.execution = null;
 }
-
 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);
@@ -51,61 +43,53 @@ LoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const execution = this.isSequential ? new SequentialLoopCharacteristics(this.activity, chr) : new ParallelLoopCharacteristics(this.activity, chr);
   return execution.execute(executeMessage);
 };
-
 function SequentialLoopCharacteristics(activity, characteristics) {
   this.activity = activity;
   this.id = activity.id;
   this.characteristics = characteristics;
 }
-
 SequentialLoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const {
     routingKey: executeRoutingKey,
     redelivered: isRedelivered
   } = executeMessage.fields || {};
   const chr = this.characteristics;
-
   if (!chr.cardinality && !chr.startCondition && !chr.completionCondition) {
     throw new _Errors.RunError(`<${this.id}> cardinality, collection, or condition is required in sequential loops`, executeMessage);
   }
-
   let startIndex = 0;
-
   if (isRedelivered && executeRoutingKey === 'execute.iteration.next') {
     startIndex = executeMessage.content.index;
   }
-
   chr.subscribe(this._onCompleteMessage.bind(this));
   return this._startNext(startIndex, isRedelivered);
 };
-
 SequentialLoopCharacteristics.prototype._startNext = function startNext(index, ignoreIfExecuting) {
   const chr = this.characteristics;
   const content = chr.next(index);
   if (!content) return;
-
   if (chr.isStartConditionMet({
     content
   })) {
     chr.debug('start condition met');
     return;
   }
-
   chr.debug(`${ignoreIfExecuting ? 'resume' : 'start'} sequential iteration index ${content.index}`);
   const broker = this.activity.broker;
-  broker.publish('execution', 'execute.iteration.next', { ...content,
+  broker.publish('execution', 'execute.iteration.next', {
+    ...content,
     ...chr.getContent(),
     index,
     preventComplete: true,
     output: chr.output.slice(),
     state: 'iteration.next'
   });
-  broker.publish('execution', 'execute.start', { ...content,
+  broker.publish('execution', 'execute.start', {
+    ...content,
     ignoreIfExecuting
   });
   return content;
 };
-
 SequentialLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
   const {
     content
@@ -113,21 +97,19 @@ SequentialLoopCharacteristics.prototype._onCompleteMessage = function onComplete
   const chr = this.characteristics;
   const loopOutput = chr.output;
   if (content.output !== undefined) loopOutput[content.index] = content.output;
-  this.activity.broker.publish('execution', 'execute.iteration.completed', { ...message.content,
+  this.activity.broker.publish('execution', 'execute.iteration.completed', {
+    ...message.content,
     ...chr.getContent(),
     preventComplete: true,
     output: loopOutput.slice(),
     state: 'iteration.completed'
   });
-
   if (chr.isCompletionConditionMet(message, loopOutput)) {
     chr.debug('complete condition met');
   } else if (this._startNext(content.index + 1)) return;
-
   chr.debug('sequential loop completed');
   return chr.complete(content);
 };
-
 function ParallelLoopCharacteristics(activity, characteristics) {
   this.activity = activity;
   this.id = activity.id;
@@ -135,52 +117,44 @@ function ParallelLoopCharacteristics(activity, characteristics) {
   this.running = 0;
   this.index = 0;
 }
-
 ParallelLoopCharacteristics.prototype.execute = function execute(executeMessage) {
   const chr = this.characteristics;
   if (!chr.cardinality) throw new _Errors.RunError(`<${this.id}> cardinality or collection is required in parallel loops`, 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;
   }
-
   chr.subscribe(this._onCompleteMessage.bind(this));
   if (isRedelivered) return;
   return this._startBatch();
 };
-
 ParallelLoopCharacteristics.prototype._startBatch = function startBatch() {
   const chr = this.characteristics;
   const cardinality = chr.cardinality;
   const batch = [];
   let startContent = chr.next(this.index);
-
   do {
     chr.debug(`start parallel iteration index ${this.index}`);
     batch.push(startContent);
     this.running++;
     this.index++;
-
     if (this.index >= cardinality || this.running >= chr.batchSize) {
       break;
     }
   } while (startContent = chr.next(this.index));
-
   const broker = this.activity.broker;
-  broker.publish('execution', 'execute.iteration.batch', { ...chr.getContent(),
+  broker.publish('execution', 'execute.iteration.batch', {
+    ...chr.getContent(),
     index: this.index,
     running: this.running,
     output: chr.output,
     preventComplete: true
   });
-
   for (const content of batch) {
     broker.publish('execution', 'execute.start', content);
   }
 };
-
 ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMessage(_, message) {
   const chr = this.characteristics;
   const {
@@ -188,7 +162,8 @@ ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMe
   } = message;
   if (content.output !== undefined) chr.output[content.index] = content.output;
   this.running--;
-  this.activity.broker.publish('execution', 'execute.iteration.completed', { ...content,
+  this.activity.broker.publish('execution', 'execute.iteration.completed', {
+    ...content,
     ...chr.getContent(),
     index: this.index,
     running: this.running,
@@ -196,22 +171,17 @@ ParallelLoopCharacteristics.prototype._onCompleteMessage = function onCompleteMe
     state: 'iteration.completed',
     preventComplete: true
   });
-
   if (this.running <= 0 && !chr.next(this.index)) {
     return chr.complete(content);
   }
-
   if (chr.isCompletionConditionMet(message)) {
     return chr.complete(content);
   }
-
   if (this.running <= 0) {
     this.running = 0;
-
     this._startBatch();
   }
 };
-
 function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.activity = activity;
   const behaviour = this.behaviour = loopCharacteristics.behaviour || {};
@@ -224,99 +194,83 @@ function Characteristics(activity, loopCharacteristics, executeMessage) {
   this.output = executeMessage.content.output || [];
   this.parent = (0, _messageHelper.unshiftParent)(executeMessage.content.parent, executeMessage.content);
   if ('loopCardinality' in behaviour) this.loopCardinality = behaviour.loopCardinality;else if ('loopMaximum' in behaviour) this.loopCardinality = behaviour.loopMaximum;
-
   if (behaviour.loopCondition) {
     if (behaviour.testBefore) this.startCondition = behaviour.loopCondition;else this.completionCondition = behaviour.loopCondition;
   }
-
   if (behaviour.completionCondition) {
     this.completionCondition = behaviour.completionCondition;
   }
-
   const collection = this.collection = this.getCollection();
-
   if (collection) {
     this.elementVariable = behaviour.elementVariable || 'item';
   }
-
   this.cardinality = this.getCardinality(collection);
   this.onApiMessage = this.onApiMessage.bind(this);
   const environment = activity.environment;
   this.logger = environment.Logger(type.toLowerCase());
   this.batchSize = environment.settings.batchSize || 50;
 }
-
 Characteristics.prototype.getContent = function getContent() {
-  return { ...(0, _messageHelper.cloneContent)(this.message.content),
+  return {
+    ...(0, _messageHelper.cloneContent)(this.message.content),
     loopCardinality: this.cardinality,
     isSequential: this.isSequential,
     output: undefined
   };
 };
-
 Characteristics.prototype.next = function next(index) {
   const cardinality = this.cardinality;
   if (cardinality > 0 && index >= cardinality) return;
   const collection = this.collection;
   if (collection && index >= collection.length) return;
-  const content = { ...this.getContent(),
+  const content = {
+    ...this.getContent(),
     isRootScope: undefined,
     executionId: `${this.parentExecutionId}_${index}`,
     isMultiInstance: true,
     parent: (0, _messageHelper.cloneParent)(this.parent),
     index
   };
-
   if (collection) {
     content[this.elementVariable] = collection[index];
   }
-
   return content;
 };
-
 Characteristics.prototype.getCardinality = function getCardinality(collection) {
   const collectionLen = this.collection && Array.isArray(collection) ? collection.length : undefined;
-
   if (!this.loopCardinality) {
     return collectionLen;
   }
-
   const value = this.activity.environment.resolveExpression(this.loopCardinality, this.message);
-
   if (value !== undefined && isNaN(value) || value < 0) {
     throw new _Errors.RunError(`<${this.id}> invalid loop cardinality >${value}<`, this.message);
   }
-
   if (value === undefined) return collectionLen;
   return Number(value);
 };
-
 Characteristics.prototype.getCollection = function getCollection() {
   const collectionExpression = this.behaviour.collection;
   if (!collectionExpression) return;
   return this.activity.environment.resolveExpression(collectionExpression, this.message);
 };
-
 Characteristics.prototype.isStartConditionMet = function isStartConditionMet(message) {
   if (!this.startCondition) return false;
   return this.activity.environment.resolveExpression(this.startCondition, (0, _messageHelper.cloneMessage)(message));
 };
-
 Characteristics.prototype.isCompletionConditionMet = function isCompletionConditionMet(message) {
   if (!this.completionCondition) return false;
   return this.activity.environment.resolveExpression(this.completionCondition, (0, _messageHelper.cloneMessage)(message, {
     loopOutput: this.output
   }));
 };
-
 Characteristics.prototype.complete = function complete(content) {
   this.stop();
-  return this.broker.publish('execution', 'execute.completed', { ...content,
+  return this.broker.publish('execution', 'execute.completed', {
+    ...content,
     ...this.getContent(),
     output: this.output
   });
 };
-
 Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMessage) {
   this.broker.subscribeTmp('api', `activity.*.${this.parentExecutionId}`, this.onApiMessage, {
     noAck: true,
@@ -329,10 +283,8 @@ Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMess
     consumerTag: '_execute-q-multi-instance-tag',
     priority: 300
   });
-
   function onComplete(routingKey, message, ...args) {
     if (!message.content.isMultiInstance) return;
-
     switch (routingKey) {
       case 'execute.cancel':
       case 'execute.completed':
@@ -340,7 +292,6 @@ Characteristics.prototype.subscribe = function subscribe(onIterationCompleteMess
     }
   }
 };
-
 Characteristics.prototype.onApiMessage = function onApiMessage(_, message) {
   switch (message.properties.type) {
     case 'stop':
@@ -349,12 +300,10 @@ Characteristics.prototype.onApiMessage = function onApiMessage(_, message) {
       break;
   }
 };
-
 Characteristics.prototype.stop = function stop() {
   this.broker.cancel('_execute-q-multi-instance-tag');
   this.broker.cancel('_api-multi-instance-tag');
 };
-
 Characteristics.prototype.debug = function debug(msg) {
   this.logger.debug(`<${this.parentExecutionId} (${this.id})> ${msg}`);
 };