bpmn-elements 15.0.2 → 16.0.0

package/README.md

@@ -18,7 +18,7 @@ The following elements are tested and supported.
 - BoundaryEvent
 - [CallActivity](/docs/CallActivity.md)
 - CancelEventDefinition
-- ConditionalEventDefinition
+- [ConditionalEventDefinition](/docs/ConditionalEventDefinition.md)
 - CompensateEventDefinition
   - compensate by outbound Association
 - [DataObject](/docs/BpmnIO.md)

package/dist/activity/Activity.js

@@ -112,7 +112,7 @@ function Activity(Behaviour, activityDef, context) {
     onApiMessage: this._onApiMessage.bind(this),
     onExecutionMessage: this._onExecutionMessage.bind(this)
   };
-  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map(ed => new ed.Behaviour(this, ed, this.context));
+  this[kEventDefinitions] = eventDefinitions && eventDefinitions.map((ed, idx) => new ed.Behaviour(this, ed, context, idx));
   this[kExtensions] = context.loadExtensions(this);
   this[kConsuming] = false;
   this[kConsumingRunQ] = undefined;

package/dist/condition.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExpressionCondition = ExpressionCondition;
+exports.ScriptCondition = ScriptCondition;
+var _ExecutionScope = _interopRequireDefault(require("./activity/ExecutionScope.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Script condition
+ * @param {import('types').ElementBase} owner
+ * @param {any} script
+ * @param {string} language
+ */
+function ScriptCondition(owner, script, language) {
+  this.type = 'script';
+  this.language = language;
+  this._owner = owner;
+  this._script = script;
+}
+
+/**
+ * Execute
+ * @param {any} message
+ * @param {CallableFunction} callback
+ */
+ScriptCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    return this._script.execute((0, _ExecutionScope.default)(owner, message), callback);
+  } catch (err) {
+    if (!callback) throw err;
+    owner.logger.error(`<${owner.id}>`, err);
+    callback(err);
+  }
+};
+
+/**
+ * Expression condition
+ * @param {import('types').ElementBase} owner
+ * @param {string} expression
+ */
+function ExpressionCondition(owner, expression) {
+  this.type = 'expression';
+  this.expression = expression;
+  this._owner = owner;
+}
+
+/**
+ * Execute
+ * @param {any} message
+ * @param {CallableFunction} callback
+ */
+ExpressionCondition.prototype.execute = function execute(message, callback) {
+  const owner = this._owner;
+  try {
+    const result = owner.environment.resolveExpression(this.expression, message);
+    if (callback) return callback(null, result);
+    return result;
+  } catch (err) {
+    if (callback) return callback(err);
+    throw err;
+  }
+};

package/dist/eventDefinitions/ConditionalEventDefinition.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = ConditionalEventDefinition;
 var _messageHelper = require("../messageHelper.js");
 var _Errors = require("../error/Errors.js");
+var _condition = require("../condition.js");
 const kExecuteMessage = Symbol.for('executeMessage');
-function ConditionalEventDefinition(activity, eventDefinition) {
+function ConditionalEventDefinition(activity, eventDefinition, _context, index) {
   const {
     id,
     broker,
-    environment,
-    attachedTo
+    environment
   } = activity;
   const {
     type = 'ConditionalEventDefinition',
@@ -20,12 +20,12 @@ function ConditionalEventDefinition(activity, eventDefinition) {
   } = eventDefinition;
   this.id = id;
   this.type = type;
-  this.isWaiting = !attachedTo;
-  this.condition = behaviour.expression;
+  this.behaviour = behaviour;
   this.activity = activity;
   this.environment = environment;
   this.broker = broker;
   this.logger = environment.Logger(type.toLowerCase());
+  this.condition = this.getCondition(index);
 }
 Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
   get() {
@@ -35,141 +35,137 @@ Object.defineProperty(ConditionalEventDefinition.prototype, 'executionId', {
 });
 ConditionalEventDefinition.prototype.execute = function execute(executeMessage) {
   this[kExecuteMessage] = executeMessage;
-  return this.isWaiting ? this.executeWait(executeMessage) : this.executeCatch(executeMessage);
+  if (!this.condition) return this._setup(executeMessage);
+  this.evaluate(executeMessage, (err, result) => {
+    this.evaluateCallback(err, result);
+    if (!err && !result) {
+      this._setup(executeMessage);
+    }
+  });
 };
-ConditionalEventDefinition.prototype.executeWait = function executeWait(executeMessage) {
+ConditionalEventDefinition.prototype._setup = function setup(executeMessage) {
+  const broker = this.broker;
   const executeContent = executeMessage.content;
   const {
     executionId,
     parent
   } = executeContent;
   const parentExecutionId = parent.executionId;
-  if (this._evaluateWait(executeMessage)) return;
-  const broker = this.broker;
-  const onApiMessage = this._onWaitApiMessage.bind(this);
+  const onApiMessage = this._onApiMessage.bind(this);
   broker.subscribeTmp('api', `activity.#.${executionId}`, onApiMessage, {
     noAck: true,
     consumerTag: `_api-${executionId}`
   });
-  broker.subscribeTmp('api', `activity.signal.${parentExecutionId}`, onApiMessage, {
+  broker.subscribeTmp('api', `activity.#.${parentExecutionId}`, onApiMessage, {
     noAck: true,
     consumerTag: `_parent-signal-${executionId}`
   });
-  const waitContent = (0, _messageHelper.cloneContent)(executeContent, {
-    executionId: parentExecutionId,
-    condition: this.condition
-  });
-  waitContent.parent = (0, _messageHelper.shiftParent)(parent);
-  broker.publish('event', 'activity.wait', waitContent);
-};
-ConditionalEventDefinition.prototype.executeCatch = function executeCatch(executeMessage) {
-  const executeContent = executeMessage.content;
-  const {
-    executionId,
-    index,
-    parent
-  } = executeContent;
-  const parentExecutionId = parent.executionId;
-  const broker = this.broker;
-  broker.subscribeTmp('api', `activity.#.${executionId}`, this._onCatchApiMessage.bind(this), {
+  broker.subscribeTmp('api', '#.signal.*', this._onDelegateApiMessage.bind(this), {
     noAck: true,
-    consumerTag: `_api-${executionId}_${index}`
-  });
-  const {
-    id: attachedToId,
-    broker: attachedToBroker
-  } = this.activity.attachedTo;
-  this._debug(`listen for execute completed from <${attachedToId}>`);
-  attachedToBroker.subscribeOnce('execution', 'execute.completed', this._onAttachedCompleted.bind(this), {
-    priority: 300,
-    consumerTag: `_onend-${executionId}_${index}`
+    consumerTag: `_api-delegated-${executionId}`
   });
   const waitContent = (0, _messageHelper.cloneContent)(executeContent, {
     executionId: parentExecutionId,
-    condition: this.condition
+    ...(this.condition && {
+      condition: this.condition.type
+    })
   });
   waitContent.parent = (0, _messageHelper.shiftParent)(parent);
   broker.publish('event', 'activity.wait', waitContent);
 };
-ConditionalEventDefinition.prototype._onWaitApiMessage = function onWaitApiMessage(routingKey, message) {
-  const messageType = message.properties.type;
-  switch (messageType) {
-    case 'signal':
-      {
-        return this._evaluateWait(message);
-      }
-    case 'discard':
-      {
-        this._stopWait();
-        return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
-          state: 'discard'
-        }));
-      }
-    case 'stop':
-      {
-        return this._stopWait();
-      }
+
+/**
+ * Evaluate condition
+ * @param {import('types').ElementBrokerMessage} message
+ * @param {CallableFunction} callback
+ */
+ConditionalEventDefinition.prototype.evaluate = function evaluate(message, callback) {
+  const condition = this.condition;
+  if (!condition) {
+    this._debug(`condition is empty <${condition}>`);
+    return callback();
   }
+  condition.execute(message, callback);
 };
-ConditionalEventDefinition.prototype._evaluateWait = function evaluate(message) {
+
+/**
+ * Handle evaluate result or error
+ * @param {Error|null} err Condition evaluation error
+ * @param {any} result Result from evaluated condition, completes execution if truthy
+ */
+ConditionalEventDefinition.prototype.evaluateCallback = function evaluateCallback(err, result) {
+  const broker = this.broker;
   const executeMessage = this[kExecuteMessage];
-  const broker = this.broker,
-    executeContent = executeMessage.content;
-  try {
-    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
-  } catch (err) {
+  const executeContent = executeMessage.content;
+  if (err) {
     return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
       error: new _Errors.ActivityError(err.message, executeMessage, err)
     }, {
       mandatory: true
     }));
   }
-  this._debug(`condition evaluated to ${!!output}`);
-  broker.publish('event', 'activity.condition', (0, _messageHelper.cloneContent)(executeContent, {
-    conditionResult: output
+  this._debug(`condition evaluated to ${!!result}`);
+  this.broker.publish('event', 'activity.condition', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
+    conditionResult: result
   }));
-  if (!output) return;
-  this._stopWait();
+  if (!result) return;
+  this._stop();
   return broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
-    output
+    output: result
   }));
 };
-ConditionalEventDefinition.prototype._stopWait = function stopWait() {
-  const broker = this.broker,
-    executionId = this.executionId;
-  broker.cancel(`_api-${executionId}`);
-  broker.cancel(`_parent-signal-${executionId}`);
-};
-ConditionalEventDefinition.prototype._onAttachedCompleted = function onAttachedCompleted(routingKey, message) {
-  this._stopCatch();
-  const executeMessage = this[kExecuteMessage];
-  const broker = this.broker,
-    executeContent = executeMessage.content;
-  try {
-    var output = this.environment.resolveExpression(this.condition, message); // eslint-disable-line no-var
-  } catch (err) {
-    return broker.publish('execution', 'execute.error', (0, _messageHelper.cloneContent)(executeContent, {
-      error: new _Errors.ActivityError(err.message, executeMessage, err)
-    }, {
-      mandatory: true
-    }));
+
+/**
+ * Get condition
+ * @param {number} index Eventdefinition sequence number, used to name registered script
+ * @returns {ExpressionCondition|ScriptCondition|null}
+ */
+ConditionalEventDefinition.prototype.getCondition = function getCondition(index) {
+  const behaviour = this.behaviour;
+  if (behaviour.script) {
+    const {
+      language,
+      body,
+      resource
+    } = behaviour.script;
+    const scriptId = `${this.id}/${index}`;
+    const script = this.environment.scripts.register({
+      id: scriptId,
+      type: this.type,
+      environment: this.environment,
+      behaviour: {
+        scriptFormat: language,
+        ...(body && {
+          script: body
+        }),
+        ...(resource && {
+          resource
+        })
+      }
+    });
+    if (script) {
+      return new _condition.ScriptCondition(this, script, language);
+    }
+  } else if (behaviour.expression) {
+    return new _condition.ExpressionCondition(this, behaviour.expression);
   }
-  this._debug(`condition from <${message.content.executionId}> evaluated to ${!!output}`);
-  broker.publish('event', 'activity.condition', (0, _messageHelper.cloneContent)(executeContent, {
-    conditionResult: output
-  }));
-  if (output) {
-    broker.publish('execution', 'execute.completed', (0, _messageHelper.cloneContent)(executeContent, {
-      output
-    }));
+};
+ConditionalEventDefinition.prototype._onDelegateApiMessage = function onDelegateApiMessage(routingKey, message) {
+  if (message.content.message && message.content.message.id === this.id) {
+    this._onApiMessage(routingKey, message);
   }
 };
-ConditionalEventDefinition.prototype._onCatchApiMessage = function onCatchApiMessage(routingKey, message) {
+ConditionalEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey, message) {
   const messageType = message.properties.type;
   switch (messageType) {
+    case 'signal':
+      {
+        if (!this.condition) break;
+        return this.evaluate(message, (err, result) => this.evaluateCallback(err, result));
+      }
     case 'discard':
       {
-        this._stopCatch();
+        this._stop();
         this._debug('discarded');
         return this.broker.publish('execution', 'execute.discard', (0, _messageHelper.cloneContent)(this[kExecuteMessage].content, {
           state: 'discard'
@@ -177,18 +173,17 @@ ConditionalEventDefinition.prototype._onCatchApiMessage = function onCatchApiMes
       }
     case 'stop':
       {
-        this._stopCatch();
+        this._stop();
         return this._debug('stopped');
       }
   }
 };
-ConditionalEventDefinition.prototype._stopCatch = function stopCatch() {
-  const {
-    executionId,
-    index
-  } = this[kExecuteMessage].content;
-  this.activity.attachedTo.broker.cancel(`_onend-${executionId}_${index}`);
-  this.broker.cancel(`_api-${executionId}_${index}`);
+ConditionalEventDefinition.prototype._stop = function stop() {
+  const executionId = this.executionId;
+  const broker = this.broker;
+  broker.cancel(`_api-${executionId}`);
+  broker.cancel(`_parent-signal-${executionId}`);
+  broker.cancel(`_api-delegated-${executionId}`);
 };
 ConditionalEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);

package/dist/eventDefinitions/ErrorEventDefinition.js

@@ -189,8 +189,8 @@ ErrorEventDefinition.prototype._onApiMessage = function onApiMessage(routingKey,
   }
 };
 ErrorEventDefinition.prototype._stop = function stop() {
-  const broker = this.broker,
-    executionId = this.executionId;
+  const broker = this.broker;
+  const executionId = this.executionId;
   broker.cancel(`_onthrow-${executionId}`);
   broker.cancel(`_onerror-${executionId}`);
   broker.cancel(`_api-${executionId}`);

package/dist/eventDefinitions/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "CancelEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _CancelEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "CompensateEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _CompensateEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "ConditionalEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _ConditionalEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "ErrorEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _ErrorEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "EscalationEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _EscalationEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "LinkEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _LinkEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "MessageEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _MessageEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "SignalEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _SignalEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "TerminateEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _TerminateEventDefinition.default;
+  }
+});
+Object.defineProperty(exports, "TimerEventDefinition", {
+  enumerable: true,
+  get: function () {
+    return _TimerEventDefinition.default;
+  }
+});
+var _CancelEventDefinition = _interopRequireDefault(require("./CancelEventDefinition.js"));
+var _CompensateEventDefinition = _interopRequireDefault(require("./CompensateEventDefinition.js"));
+var _ConditionalEventDefinition = _interopRequireDefault(require("./ConditionalEventDefinition.js"));
+var _ErrorEventDefinition = _interopRequireDefault(require("./ErrorEventDefinition.js"));
+var _EscalationEventDefinition = _interopRequireDefault(require("./EscalationEventDefinition.js"));
+var _LinkEventDefinition = _interopRequireDefault(require("./LinkEventDefinition.js"));
+var _MessageEventDefinition = _interopRequireDefault(require("./MessageEventDefinition.js"));
+var _SignalEventDefinition = _interopRequireDefault(require("./SignalEventDefinition.js"));
+var _TerminateEventDefinition = _interopRequireDefault(require("./TerminateEventDefinition.js"));
+var _TimerEventDefinition = _interopRequireDefault(require("./TimerEventDefinition.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/events/index.js

@@ -3,58 +3,70 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _BoundaryEvent = require("./BoundaryEvent.js");
-Object.keys(_BoundaryEvent).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _BoundaryEvent[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _BoundaryEvent[key];
-    }
-  });
-});
-var _EndEvent = require("./EndEvent.js");
-Object.keys(_EndEvent).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _EndEvent[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _EndEvent[key];
-    }
-  });
-});
-var _IntermediateCatchEvent = require("./IntermediateCatchEvent.js");
-Object.keys(_IntermediateCatchEvent).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _IntermediateCatchEvent[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _IntermediateCatchEvent[key];
-    }
-  });
-});
-var _IntermediateThrowEvent = require("./IntermediateThrowEvent.js");
-Object.keys(_IntermediateThrowEvent).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _IntermediateThrowEvent[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _IntermediateThrowEvent[key];
-    }
-  });
-});
-var _StartEvent = require("./StartEvent.js");
-Object.keys(_StartEvent).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _StartEvent[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _StartEvent[key];
-    }
-  });
-});
+Object.defineProperty(exports, "BoundaryEvent", {
+  enumerable: true,
+  get: function () {
+    return _BoundaryEvent.default;
+  }
+});
+Object.defineProperty(exports, "BoundaryEventBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _BoundaryEvent.BoundaryEventBehaviour;
+  }
+});
+Object.defineProperty(exports, "EndEvent", {
+  enumerable: true,
+  get: function () {
+    return _EndEvent.default;
+  }
+});
+Object.defineProperty(exports, "EndEventBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _EndEvent.EndEventBehaviour;
+  }
+});
+Object.defineProperty(exports, "IntermediateCatchEvent", {
+  enumerable: true,
+  get: function () {
+    return _IntermediateCatchEvent.default;
+  }
+});
+Object.defineProperty(exports, "IntermediateCatchEventBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _IntermediateCatchEvent.IntermediateCatchEventBehaviour;
+  }
+});
+Object.defineProperty(exports, "IntermediateThrowEvent", {
+  enumerable: true,
+  get: function () {
+    return _IntermediateThrowEvent.default;
+  }
+});
+Object.defineProperty(exports, "IntermediateThrowEventBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _IntermediateThrowEvent.IntermediateThrowEventBehaviour;
+  }
+});
+Object.defineProperty(exports, "StartEvent", {
+  enumerable: true,
+  get: function () {
+    return _StartEvent.default;
+  }
+});
+Object.defineProperty(exports, "StartEventBehaviour", {
+  enumerable: true,
+  get: function () {
+    return _StartEvent.StartEventBehaviour;
+  }
+});
+var _BoundaryEvent = _interopRequireWildcard(require("./BoundaryEvent.js"));
+var _EndEvent = _interopRequireWildcard(require("./EndEvent.js"));
+var _IntermediateCatchEvent = _interopRequireWildcard(require("./IntermediateCatchEvent.js"));
+var _IntermediateThrowEvent = _interopRequireWildcard(require("./IntermediateThrowEvent.js"));
+var _StartEvent = _interopRequireWildcard(require("./StartEvent.js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/dist/flows/SequenceFlow.js

@@ -4,12 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _ExecutionScope = _interopRequireDefault(require("../activity/ExecutionScope.js"));
 var _messageHelper = require("../messageHelper.js");
 var _shared = require("../shared.js");
 var _EventBroker = require("../EventBroker.js");
 var _Api = require("../Api.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _condition = require("../condition.js");
 const kCounters = Symbol.for('counters');
 var _default = exports.default = SequenceFlow;
 function SequenceFlow(flowDef, {
@@ -41,7 +40,6 @@ function SequenceFlow(flowDef, {
     take: 0,
     discard: 0
   };
-  environment.registerScript(this);
   const {
     broker,
     on,
@@ -58,6 +56,7 @@ function SequenceFlow(flowDef, {
   this.once = once;
   this.waitFor = waitFor;
   this.emitFatal = emitFatal;
+  environment.registerScript(this);
   logger.debug(`<${id}> init, <${sourceId}> -> <${targetId}>`);
 }
 Object.defineProperty(SequenceFlow.prototype, 'counters', {
@@ -145,13 +144,13 @@ SequenceFlow.prototype.getCondition = function getCondition() {
   } = conditionExpression;
   const script = this.environment.getScript(language, this);
   if (script) {
-    return new ScriptCondition(this, script, language);
+    return new _condition.ScriptCondition(this, script, language);
   }
   if (!conditionExpression.body) {
     const msg = language ? `Condition expression script ${language} is unsupported or was not registered` : 'Condition expression without body is unsupported';
     return this.emitFatal(new Error(msg), this.createMessage());
   }
-  return new ExpressionCondition(this, conditionExpression.body);
+  return new _condition.ExpressionCondition(this, conditionExpression.body);
 };
 SequenceFlow.prototype.createMessage = function createMessage(override) {
   return {
@@ -184,36 +183,4 @@ SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   this.broker.publish('event', `flow.${action}`, eventContent, {
     type: action
   });
-};
-function ScriptCondition(owner, script, language) {
-  this.type = 'script';
-  this.language = language;
-  this._owner = owner;
-  this._script = script;
-}
-ScriptCondition.prototype.execute = function execute(message, callback) {
-  const owner = this._owner;
-  try {
-    return this._script.execute((0, _ExecutionScope.default)(owner, message), callback);
-  } catch (err) {
-    if (!callback) throw err;
-    owner.logger.error(`<${owner.id}>`, err);
-    callback(err);
-  }
-};
-function ExpressionCondition(owner, expression) {
-  this.type = 'expression';
-  this.expression = expression;
-  this._owner = owner;
-}
-ExpressionCondition.prototype.execute = function execute(message, callback) {
-  const owner = this._owner;
-  try {
-    const result = owner.environment.resolveExpression(this.expression, owner.createMessage(message));
-    if (callback) return callback(null, result);
-    return result;
-  } catch (err) {
-    if (callback) return callback(err);
-    throw err;
-  }
 };