bpmn-elements 17.2.2 → 18.0.0

package/dist/flows/SequenceFlow.js

@@ -3,14 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.SequenceFlow = SequenceFlow;
 var _messageHelper = require("../messageHelper.js");
 var _shared = require("../shared.js");
 var _EventBroker = require("../EventBroker.js");
 var _Api = require("../Api.js");
 var _condition = require("../condition.js");
-const kCounters = Symbol.for('counters');
-var _default = exports.default = SequenceFlow;
+var _constants = require("../constants.js");
+/**
+ * Sequence flow connecting two activities. Owns its broker and publishes take/discard/looped
+ * events; activities subscribe to drive their inbound queue.
+ * @param {import('moddle-context-serializer').SequenceFlow} flowDef
+ * @param {import('#types').ContextInstance} context
+ */
 function SequenceFlow(flowDef, {
   environment
 }) {
@@ -28,6 +33,7 @@ function SequenceFlow(flowDef, {
   this.type = type;
   this.name = name;
   this.parent = (0, _messageHelper.cloneParent)(parent);
+  /** @type {Record<string, any>} */
   this.behaviour = behaviour;
   this.sourceId = sourceId;
   this.targetId = targetId;
@@ -35,7 +41,7 @@ function SequenceFlow(flowDef, {
   this.isSequenceFlow = true;
   this.environment = environment;
   const logger = this.logger = environment.Logger(type.toLowerCase());
-  this[kCounters] = {
+  this[_constants.K_COUNTERS] = {
     looped: 0,
     take: 0,
     discard: 0
@@ -60,32 +66,51 @@ function SequenceFlow(flowDef, {
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
 }
 Object.defineProperty(SequenceFlow.prototype, 'counters', {
+  /** @returns {{ take: number, discard: number, looped: number }} */
   get() {
     return {
-      ...this[kCounters]
+      ...this[_constants.K_COUNTERS]
     };
   }
 });
+
+/**
+ * Take the flow and publish flow.take.
+ * @param {Record<string, any>} [content]
+ */
 SequenceFlow.prototype.take = function take(content) {
   const sequenceId = content?.sequenceId;
   this.logger.debug(`<${sequenceId} (${this.id})> take, target <${this.targetId}>`);
-  ++this[kCounters].take;
+  ++this[_constants.K_COUNTERS].take;
   this._publishEvent('take', content);
   return true;
 };
+
+/**
+ * Discard the flow and publish flow.discard.
+ *
+ * @deprecated The execution runtime no longer discards sequence flows, so this is a no-op during a run. It will be removed in a future version.
+ * @param {Record<string, any>} [content]
+ */
 SequenceFlow.prototype.discard = function discard(content = {}) {
   const sequenceId = content?.sequenceId ?? (0, _shared.getUniqueId)(this.id);
-  const discardSequence = content.discardSequence = (content.discardSequence || []).slice();
+  const discardSequence = content.discardSequence = content.discardSequence?.slice() || [];
   if (discardSequence.indexOf(this.targetId) > -1) {
-    ++this[kCounters].looped;
+    ++this[_constants.K_COUNTERS].looped;
     this.logger.debug(`<${this.id}> discard loop detected <${this.sourceId}> -> <${this.targetId}>. Stop.`);
     return this._publishEvent('looped', content);
   }
   discardSequence.push(this.sourceId);
   this.logger.debug(`<${sequenceId} (${this.id})> discard, target <${this.targetId}>`);
-  ++this[kCounters].discard;
+  ++this[_constants.K_COUNTERS].discard;
   this._publishEvent('discard', content);
 };
+
+/**
+ * Snapshot flow state. Returns undefined when the broker has no state and `disableTrackState`
+ * is set.
+ * @returns {import('#types').SequenceFlowState | undefined}
+ */
 SequenceFlow.prototype.getState = function getState() {
   const brokerState = this.broker.getState(true);
   if (!brokerState && this.environment.settings.disableTrackState) return;
@@ -96,42 +121,74 @@ SequenceFlow.prototype.getState = function getState() {
     broker: brokerState
   };
 };
+
+/**
+ * Restore flow state captured by getState.
+ * @param {import('#types').SequenceFlowState} state
+ */
 SequenceFlow.prototype.recover = function recover(state) {
-  Object.assign(this[kCounters], state.counters);
+  Object.assign(this[_constants.K_COUNTERS], state.counters);
   this.broker.recover(state.broker);
 };
+
+/**
+ * Resolve a Flow Api wrapper.
+ * @param {import('#types').ElementBrokerMessage} [message]
+ * @returns {import('#types').IApi<this>}
+ */
 SequenceFlow.prototype.getApi = function getApi(message) {
   return (0, _Api.FlowApi)(this.broker, message || {
     content: this.createMessage()
   });
 };
+
+/**
+ * Stop the flow's broker.
+ */
 SequenceFlow.prototype.stop = function stop() {
   this.broker.stop();
 };
+
+/**
+ * Walk the flow as part of a process shake. Detects loops and publishes flow.shake.loop
+ * when the target was already visited, otherwise flow.shake.
+ * @param {import('#types').ElementBrokerMessage} message
+ */
 SequenceFlow.prototype.shake = function shake(message) {
   const content = (0, _messageHelper.cloneContent)(message.content);
   content.sequence = content.sequence || [];
-  content.sequence.push({
+  const info = {
     id: this.id,
     type: this.type,
     isSequenceFlow: true,
+    sourceId: this.sourceId,
     targetId: this.targetId
-  });
-  if (content.id === this.targetId) return this.broker.publish('event', 'flow.shake.loop', content, {
-    persistent: false,
-    type: 'shake'
-  });
-  for (const s of message.content.sequence || []) {
-    if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {
+  };
+  if (content.id === this.targetId) {
+    content.sequence.push(info);
+    return this.broker.publish('event', 'flow.shake.loop', content, {
+      persistent: false,
+      type: 'shake'
+    });
+  } else if (content.sequence?.find(f => f.id === this.id)) {
+    return this.broker.publish('event', 'flow.shake.loop', content, {
+      persistent: false,
+      type: 'shake'
+    });
+  } else {
+    content.sequence.push(info);
+    this.broker.publish('event', 'flow.shake', content, {
       persistent: false,
       type: 'shake'
     });
   }
-  this.broker.publish('event', 'flow.shake', content, {
-    persistent: false,
-    type: 'shake'
-  });
 };
+
+/**
+ * Resolve the flow's condition (script or expression). Returns null when no condition is set.
+ * Emits a fatal error when the script language is missing or unsupported.
+ * @returns {import('#types').ICondition | null}
+ */
 SequenceFlow.prototype.getCondition = function getCondition() {
   const conditionExpression = this.behaviour.conditionExpression;
   if (!conditionExpression) return null;
@@ -148,6 +205,12 @@ SequenceFlow.prototype.getCondition = function getCondition() {
   }
   return new _condition.ExpressionCondition(this, conditionExpression.body);
 };
+
+/**
+ * Build a flow event message body, optionally merging override content.
+ * @param {Record<string, any>} [override]
+ * @returns {import('#types').ElementMessageContent}
+ */
 SequenceFlow.prototype.createMessage = function createMessage(override) {
   return {
     ...override,
@@ -161,6 +224,12 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
     parent: (0, _messageHelper.cloneParent)(this.parent)
   };
 };
+
+/**
+ * Evaluate the flow's condition for the source activity message. Default flows are always taken.
+ * @param {import('#types').ElementBrokerMessage} fromMessage Source activity message
+ * @param {(err: Error | null, result?: boolean | unknown) => void} callback Callback with truthy result if flow should be taken
+ */
 SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
   if (this.isDefault) {
     return callback(null, true);
@@ -171,6 +240,8 @@ SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
   }
   flowCondition.execute(fromMessage, callback);
 };
+
+/** @internal */
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/dist/flows/index.js

@@ -6,22 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 Object.defineProperty(exports, "Association", {
   enumerable: true,
   get: function () {
-    return _Association.default;
+    return _Association.Association;
   }
 });
 Object.defineProperty(exports, "MessageFlow", {
   enumerable: true,
   get: function () {
-    return _MessageFlow.default;
+    return _MessageFlow.MessageFlow;
   }
 });
 Object.defineProperty(exports, "SequenceFlow", {
   enumerable: true,
   get: function () {
-    return _SequenceFlow.default;
+    return _SequenceFlow.SequenceFlow;
   }
 });
-var _Association = _interopRequireDefault(require("./Association.js"));
-var _MessageFlow = _interopRequireDefault(require("./MessageFlow.js"));
-var _SequenceFlow = _interopRequireDefault(require("./SequenceFlow.js"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _Association = require("./Association.js");
+var _MessageFlow = require("./MessageFlow.js");
+var _SequenceFlow = require("./SequenceFlow.js");

package/dist/gateways/EventBasedGateway.js

@@ -3,24 +3,38 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.EventBasedGateway = EventBasedGateway;
 exports.EventBasedGatewayBehaviour = EventBasedGatewayBehaviour;
-exports.default = EventBasedGateway;
-var _Activity = _interopRequireDefault(require("../activity/Activity.js"));
+var _Activity = require("../activity/Activity.js");
 var _messageHelper = require("../messageHelper.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const kCompleted = Symbol.for('completed');
-const kTargets = Symbol.for('targets');
+var _constants = require("../constants.js");
+/**
+ * Event based gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
 function EventBasedGateway(activityDef, context) {
-  return new _Activity.default(EventBasedGatewayBehaviour, activityDef, context);
+  return new _Activity.Activity(EventBasedGatewayBehaviour, activityDef, context);
 }
+
+/**
+ * Event based gateway behaviour
+ * @param {import('#types').Activity} activity
+ * @param {import('#types').ContextInstance} context
+ */
 function EventBasedGatewayBehaviour(activity, context) {
   this.id = activity.id;
   this.type = activity.type;
   this.activity = activity;
   this.broker = activity.broker;
   this.context = context;
-  this[kTargets] = new Set(activity.outbound.map(flow => context.getActivityById(flow.targetId)));
+  this[_constants.K_TARGETS] = new Set(activity.outbound.map(flow => context.getActivityById(flow.targetId)));
 }
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage) {
   const executeContent = executeMessage.content;
   const {
@@ -28,8 +42,8 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
     outbound = [],
     outboundTaken
   } = executeContent;
-  const targets = this[kTargets];
-  this[kCompleted] = false;
+  const targets = this[_constants.K_TARGETS];
+  this[_constants.K_COMPLETED] = false;
   if (!targets.size) return this._complete(executeContent);
   for (const flow of this.activity.outbound) {
     outbound.push({
@@ -37,10 +51,10 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
       action: 'take'
     });
   }
-  if (!this[kCompleted] && outboundTaken) return;
+  if (!this[_constants.K_COMPLETED] && outboundTaken) return;
   const targetConsumerTag = `_gateway-listener-${this.id}`;
   const onTargetCompleted = this._onTargetCompleted.bind(this, executeMessage);
-  for (const target of this[kTargets]) {
+  for (const target of this[_constants.K_TARGETS]) {
     target.broker.subscribeOnce('event', 'activity.end', onTargetCompleted, {
       consumerTag: targetConsumerTag
     });
@@ -49,7 +63,7 @@ EventBasedGatewayBehaviour.prototype.execute = function execute(executeMessage)
   broker.subscribeOnce('api', `activity.stop.${executionId}`, () => this._stop(), {
     consumerTag: '_api-stop-execution'
   });
-  this[kCompleted] = false;
+  this[_constants.K_COMPLETED] = false;
   if (!executeMessage.fields.redelivered) {
     return broker.publish('execution', 'execute.outbound.take', (0, _messageHelper.cloneContent)(executeContent, {
       outboundTaken: true
@@ -65,7 +79,7 @@ EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompl
   const executionId = executeContent.executionId;
   this.activity.logger.debug(`<${executionId} (${this.id})> <${targetExecutionId}> completed run, discarding the rest`);
   this._stop();
-  for (const target of this[kTargets]) {
+  for (const target of this[_constants.K_TARGETS]) {
     if (target === owner) continue;
     target.discard();
   }
@@ -79,11 +93,11 @@ EventBasedGatewayBehaviour.prototype._onTargetCompleted = function onTargetCompl
   this._complete(completedContent);
 };
 EventBasedGatewayBehaviour.prototype._complete = function complete(completedContent) {
-  this[kCompleted] = true;
+  this[_constants.K_COMPLETED] = true;
   this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(completedContent));
 };
 EventBasedGatewayBehaviour.prototype._stop = function stop() {
   const targetConsumerTag = `_gateway-listener-${this.id}`;
-  for (const target of this[kTargets]) target.broker.cancel(targetConsumerTag);
+  for (const target of this[_constants.K_TARGETS]) target.broker.cancel(targetConsumerTag);
   this.broker.cancel('_api-stop-execution');
 };

package/dist/gateways/ExclusiveGateway.js

@@ -3,14 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.ExclusiveGateway = ExclusiveGateway;
 exports.ExclusiveGatewayBehaviour = ExclusiveGatewayBehaviour;
-exports.default = ExclusiveGateway;
-var _Activity = _interopRequireDefault(require("../activity/Activity.js"));
+var _Activity = require("../activity/Activity.js");
 var _messageHelper = require("../messageHelper.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Exclusive gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
 function ExclusiveGateway(activityDef, context) {
-  return new _Activity.default(ExclusiveGatewayBehaviour, activityDef, context);
+  return new _Activity.Activity(ExclusiveGatewayBehaviour, activityDef, context);
 }
+
+/**
+ * Exclusive gateway behaviour
+ * @param {import('#types').Activity} activity
+ */
 function ExclusiveGatewayBehaviour(activity) {
   const {
     id,
@@ -21,10 +30,16 @@ function ExclusiveGatewayBehaviour(activity) {
   this.type = type;
   this.broker = broker;
 }
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 ExclusiveGatewayBehaviour.prototype.execute = function execute({
   content
 }) {
   this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
-    outboundTakeOne: true
+    outboundTakeOne: true,
+    requireOutbound: true
   }));
 };

package/dist/gateways/InclusiveGateway.js

@@ -3,14 +3,23 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.InclusiveGateway = InclusiveGateway;
 exports.InclusiveGatewayBehaviour = InclusiveGatewayBehaviour;
-exports.default = InclusiveGateway;
-var _Activity = _interopRequireDefault(require("../activity/Activity.js"));
+var _Activity = require("../activity/Activity.js");
 var _messageHelper = require("../messageHelper.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Inclusive gateway
+ * @param {import('moddle-context-serializer').Activity} activityDef
+ * @param {import('#types').ContextInstance} context
+ */
 function InclusiveGateway(activityDef, context) {
-  return new _Activity.default(InclusiveGatewayBehaviour, activityDef, context);
+  return new _Activity.Activity(InclusiveGatewayBehaviour, activityDef, context);
 }
+
+/**
+ * Inclusive gateway behaviour
+ * @param {import('#types').Activity} activity
+ */
 function InclusiveGatewayBehaviour(activity) {
   const {
     id,
@@ -21,8 +30,15 @@ function InclusiveGatewayBehaviour(activity) {
   this.type = type;
   this.broker = broker;
 }
+
+/**
+ * @param {import('#types').ElementBrokerMessage} executeMessage
+ * @returns {void}
+ */
 InclusiveGatewayBehaviour.prototype.execute = function execute({
   content
 }) {
-  this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content));
+  this.broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(content, {
+    requireOutbound: true
+  }));
 };