bpmn-elements 9.1.3 → 10.0.0

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 Changelog
 =========
 
+# 10.0.0
+
+- drop iso8601-duration dependency and copy source (with licence). Export as `ISODuration`. Extend with repeat pattern parsing, e.g. `R3/PT1H` that corresponds to three repetitions every one hour
+- expose `TimerEventDefinition.parse(timerType, value)` function for extension purposes
+- prototype and export built-in `Timers`
+
+# 9.2.0
+
+- move outbound sequence flow evaluation logic from activity to sequence flow, where it belongs
+- spread sequence flow evaluation result, if object, to sequence flow take message
+
 # 9.1.3
 
 - type declare execution scope

package/README.md

@@ -77,3 +77,7 @@ The following elements are tested and supported.
 - Transaction
 
 All activities share the same [base](/docs/Activity.md) and and [api](/docs/SharedApi.md).
+
+# Acknowledgments
+
+ISO 8601 duration parser [iso8601-duration](https://www.npmjs.com/package/iso8601-duration) source is copied and extended with repeat pattern. License [MIT @ tolu](https://tolu.mit-license.org/)

package/dist/Environment.js

@@ -17,7 +17,7 @@ function Environment(options = {}) {
   this.extensions = options.extensions;
   this.output = options.output || {};
   this.scripts = options.scripts || (0, _Scripts.Scripts)();
-  this.timers = options.timers || (0, _Timers.Timers)();
+  this.timers = options.timers || new _Timers.Timers();
   this.settings = {
     ...options.settings
   };

package/dist/Timers.js

@@ -4,57 +4,77 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Timers = Timers;
+const kExecuting = Symbol.for('executing');
+const kTimerApi = Symbol.for('timers api');
+const MAX_DELAY = 2147483647;
 function Timers(options) {
-  let count = 0;
-  const executing = [];
-  options = {
+  this.count = 0;
+  this.options = {
     setTimeout,
     clearTimeout,
     ...options
   };
-  const timersApi = {
-    get executing() {
-      return executing.slice();
-    },
-    register,
-    setTimeout: wrappedSetTimeout,
-    clearTimeout: wrappedClearTimeout
-  };
-  return timersApi;
-  function register(owner) {
-    return {
-      setTimeout: registerTimeout(owner),
-      clearTimeout: timersApi.clearTimeout
-    };
+  this[kExecuting] = [];
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
+Object.defineProperty(Timers.prototype, 'executing', {
+  get() {
+    return this[kExecuting].slice();
   }
-  function registerTimeout(owner) {
-    return function registeredSetTimeout(...args) {
-      return timersApi.setTimeout.call(owner, ...args);
-    };
+});
+Timers.prototype.register = function register(owner) {
+  return new RegisteredTimers(this, owner);
+};
+Timers.prototype.setTimeout = function wrappedSetTimeout(callback, delay, ...args) {
+  return this._setTimeout(null, callback, delay, ...args);
+};
+Timers.prototype.clearTimeout = function wrappedClearTimeout(ref) {
+  const executing = this[kExecuting];
+  const idx = executing.indexOf(ref);
+  if (idx > -1) {
+    executing.splice(idx, 1);
+    ref.timerRef = this.options.clearTimeout(ref.timerRef);
+    return;
   }
-  function wrappedSetTimeout(callback, delay, ...args) {
-    const ref = {
-      timerId: `timer_${count++}`,
-      callback,
-      delay,
-      args,
-      owner: this
-    };
-    executing.push(ref);
-    ref.timerRef = options.setTimeout.call(null, onTimeout, delay, ...args);
-    return ref;
-    function onTimeout(...rargs) {
-      const idx = executing.indexOf(ref);
-      if (idx > -1) executing.splice(idx, 1);
-      return callback(...rargs);
-    }
+  return this.options.clearTimeout(ref);
+};
+Timers.prototype._setTimeout = function setTimeout(owner, callback, delay, ...args) {
+  const executing = this[kExecuting];
+  const ref = this._getReference(owner, callback, delay, args);
+  executing.push(ref);
+  if (delay < MAX_DELAY) {
+    ref.timerRef = this.options.setTimeout(onTimeout, ref.delay, ...ref.args);
   }
-  function wrappedClearTimeout(ref) {
+  return ref;
+  function onTimeout(...rargs) {
     const idx = executing.indexOf(ref);
-    if (idx > -1) {
-      executing.splice(idx, 1);
-      return options.clearTimeout.call(null, ref.timerRef);
-    }
-    return options.clearTimeout.call(null, ref);
+    if (idx > -1) executing.splice(idx, 1);
+    return callback(...rargs);
   }
+};
+Timers.prototype._getReference = function getReference(owner, callback, delay, args) {
+  return new Timer(owner, `timer_${this.count++}`, callback, delay, args);
+};
+function RegisteredTimers(timersApi, owner) {
+  this[kTimerApi] = timersApi;
+  this.owner = owner;
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
+RegisteredTimers.prototype.setTimeout = function registeredSetTimeout(callback, delay, ...args) {
+  const timersApi = this[kTimerApi];
+  return timersApi._setTimeout(this.owner, callback, delay, ...args);
+};
+RegisteredTimers.prototype.clearTimeout = function registeredClearTimeout(ref) {
+  this[kTimerApi].clearTimeout(ref);
+};
+function Timer(owner, timerId, callback, delay, args) {
+  this.callback = callback;
+  this.delay = delay;
+  this.args = args;
+  this.owner = owner;
+  this.timerId = timerId;
+  this.expireAt = new Date(Date.now() + delay);
+  this.timerRef = null;
 }

package/dist/activity/Activity.js

@@ -837,10 +837,12 @@ Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content
   for (const outboundFlow of outboundList) {
     const {
       id: flowId,
-      action
+      action,
+      result
     } = outboundFlow;
     this.broker.publish('run', 'run.outbound.' + action, (0, _messageHelper.cloneContent)(content, {
       flow: {
+        ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: (0, _shared.getUniqueId)(`${flowId}_${action}`),
         ...(discardSequence && {
@@ -1027,26 +1029,11 @@ OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, messa
 };
 OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
   const broker = this.broker;
-  if (flow.isDefault) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {
-      action: 'take'
-    }), {
-      persistent: false
-    });
-  }
-  const flowCondition = flow.getCondition();
-  if (!flowCondition) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {
-      action: 'take'
-    }), {
-      persistent: false
-    });
-  }
   const {
     fromMessage,
     evaluationId
   } = this.evaluateArgs;
-  flowCondition.execute((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
+  flow.evaluate((0, _messageHelper.cloneMessage)(fromMessage), (err, result) => {
     if (err) return this.completed(err);
     const action = result ? 'take' : 'discard';
     return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {

package/dist/eventDefinitions/TimerEventDefinition.js

@@ -5,13 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = TimerEventDefinition;
 var _messageHelper = require("../messageHelper.js");
-var _iso8601Duration = require("iso8601-duration");
+var _isoDuration = require("../iso-duration.js");
 const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
-const repeatPattern = /^\s*R(\d+)\//;
 function TimerEventDefinition(activity, eventDefinition) {
-  const type = this.type = eventDefinition.type || 'TimerEventDefinition.js';
+  const type = this.type = eventDefinition.type || 'TimerEventDefinition';
   this.activity = activity;
   const environment = this.environment = activity.environment;
   this.eventDefinition = eventDefinition;
@@ -85,12 +84,14 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
   if (timerContent.timeout === undefined) return this._debug(`waiting for ${timerContent.timerType || 'signal'}`);
   if (timerContent.timeout <= 0) return this._completed();
   const timers = this.environment.timers.register(timerContent);
-  this[kTimer] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
+  const delay = timerContent.timeout;
+  this[kTimer] = timers.setTimeout(this._completed.bind(this), delay, {
     id: content.id,
     type: this.type,
     executionId,
     state: 'timeout'
   });
+  this._debug(`set timeout with delay ${delay}`);
 };
 TimerEventDefinition.prototype.stop = function stopTimer() {
   const timer = this[kTimer];
@@ -188,75 +189,84 @@ TimerEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_api-${this.executionId}`);
   broker.cancel(`_api-delegated-${this.executionId}`);
 };
+TimerEventDefinition.prototype.parse = function parse(timerType, value) {
+  let repeat, delay, expireAt;
+  switch (timerType) {
+    case 'timeCycle':
+    case 'timeDuration':
+      {
+        const parsed = (0, _isoDuration.parse)(value);
+        if (parsed.repeat) repeat = parsed.repeat;
+        delay = (0, _isoDuration.toSeconds)(parsed) * 1000;
+        expireAt = new Date(Date.now() + delay);
+        break;
+      }
+    case 'timeDate':
+      {
+        const ms = Date.parse(value);
+        if (!isNaN(ms)) {
+          expireAt = new Date(ms);
+          delay = Date.now() - expireAt;
+        } else {
+          throw new TypeError(`invalid timeDate >${value}<`);
+        }
+        break;
+      }
+  }
+  return {
+    expireAt,
+    repeat,
+    delay
+  };
+};
 TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   const content = executeMessage.content;
-  const now = Date.now();
   const result = {
     ...('expireAt' in content && {
       expireAt: new Date(content.expireAt)
     })
   };
+  let parseErr;
   for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
     if (t in content) result[t] = content[t];else if (t in this) result[t] = this.environment.resolveExpression(this[t], executeMessage);else continue;
     let expireAtDate, repeat;
     const timerStr = result[t];
     if (timerStr) {
-      switch (t) {
-        case 'timeCycle':
-          {
-            const mRepeat = timerStr.match(repeatPattern);
-            if (mRepeat && mRepeat.length) repeat = parseInt(mRepeat[1]);
-          }
-        case 'timeDuration':
-          {
-            const delay = this._getDurationInMilliseconds(timerStr);
-            if (delay !== undefined) expireAtDate = new Date(now + delay);
-            break;
-          }
-        case 'timeDate':
-          {
-            const dateStr = result[t];
-            const ms = Date.parse(dateStr);
-            if (!isNaN(ms)) {
-              expireAtDate = new Date(ms);
-            } else {
-              this._warn(`invalid timeDate >${dateStr}<`);
-            }
-            break;
-          }
+      try {
+        const {
+          repeat: parsedRepeat,
+          expireAt: parsedExpireAt
+        } = this.parse(t, timerStr);
+        repeat = parsedRepeat;
+        expireAtDate = parsedExpireAt;
+      } catch (err) {
+        parseErr = err;
       }
     } else {
-      expireAtDate = new Date(now);
+      expireAtDate = new Date();
     }
     if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
       result.timerType = t;
       result.expireAt = expireAtDate;
-      if (repeat) result.repeat = repeat;
+      result.repeat = repeat;
     }
   }
   if ('expireAt' in result) {
-    result.timeout = result.expireAt - now;
+    result.timeout = result.expireAt - Date.now();
   } else if ('timeout' in content) {
     result.timeout = content.timeout;
   } else if (!Object.keys(result).length) {
     result.timeout = 0;
   }
+  if (!('timeout' in result) && parseErr) {
+    this.logger.warn(`<${this.activity.id}> failed to parse timer: ${parseErr.message}`);
+  }
   if (content.inbound && 'repeat' in content.inbound[0]) {
     result.repeat = content.inbound[0].repeat;
   }
   return result;
 };
-TimerEventDefinition.prototype._getDurationInMilliseconds = function getDurationInMilliseconds(duration) {
-  try {
-    return (0, _iso8601Duration.toSeconds)((0, _iso8601Duration.parse)(duration)) * 1000;
-  } catch (err) {
-    this._warn(`failed to parse ${this.timerType} >${duration}<: ${err.message}`);
-  }
-};
 TimerEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
-};
-TimerEventDefinition.prototype._warn = function debug(msg) {
-  this.logger.warn(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };

package/dist/flows/SequenceFlow.js

@@ -124,7 +124,7 @@ SequenceFlow.prototype.shake = function shake(message) {
     persistent: false,
     type: 'shake'
   });
-  for (const s of message.content.sequence) {
+  for (const s of message.content.sequence || []) {
     if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {
       persistent: false,
       type: 'shake'
@@ -164,6 +164,16 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
     parent: (0, _messageHelper.cloneParent)(this.parent)
   };
 };
+SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
+  if (this.isDefault) {
+    return callback(null, true);
+  }
+  const flowCondition = this.getCondition();
+  if (!flowCondition) {
+    return callback(null, true);
+  }
+  flowCondition.execute(fromMessage, callback);
+};
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/dist/index.js

@@ -147,6 +147,7 @@ Object.defineProperty(exports, "Group", {
     return _Dummy.default;
   }
 });
+exports.ISODuration = void 0;
 Object.defineProperty(exports, "InclusiveGateway", {
   enumerable: true,
   get: function () {
@@ -321,6 +322,12 @@ Object.defineProperty(exports, "TimerEventDefinition", {
     return _TimerEventDefinition.default;
   }
 });
+Object.defineProperty(exports, "Timers", {
+  enumerable: true,
+  get: function () {
+    return _Timers.Timers;
+  }
+});
 Object.defineProperty(exports, "Transaction", {
   enumerable: true,
   get: function () {
@@ -381,4 +388,9 @@ var _Task = _interopRequireDefault(require("./tasks/Task.js"));
 var _TerminateEventDefinition = _interopRequireDefault(require("./eventDefinitions/TerminateEventDefinition.js"));
 var _TimerEventDefinition = _interopRequireDefault(require("./eventDefinitions/TimerEventDefinition.js"));
 var _Transaction = _interopRequireDefault(require("./tasks/Transaction.js"));
+var _Timers = require("./Timers.js");
+var ISODuration = _interopRequireWildcard(require("./iso-duration.js"));
+exports.ISODuration = ISODuration;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/iso-duration.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.end = end;
+exports.parse = parse;
+exports.toSeconds = toSeconds;
+// License MIT @ https://tolu.mit-license.org/
+
+const numbers = '\\d+';
+const fractionalNumbers = ''.concat(numbers, '(?:[\\.,]').concat(numbers, ')?');
+const datePattern = '('.concat(numbers, 'Y)?(').concat(numbers, 'M)?(').concat(numbers, 'W)?(').concat(fractionalNumbers, 'D)?');
+const timePattern = 'T('.concat(fractionalNumbers, 'H)?(').concat(fractionalNumbers, 'M)?(').concat(fractionalNumbers, 'S)?');
+const rPattern = '(?:R('.concat(numbers).concat(')/)?');
+const iso8601 = rPattern.concat('P(?:').concat(datePattern, '(?:').concat(timePattern, ')?)');
+const objMap = ['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds'];
+const defaultDuration = Object.freeze({
+  years: 0,
+  months: 0,
+  weeks: 0,
+  days: 0,
+  hours: 0,
+  minutes: 0,
+  seconds: 0
+});
+
+/**
+ * The ISO8601 regex for matching / testing durations
+ */
+const pattern = new RegExp(iso8601);
+
+/** Parse PnYnMnDTnHnMnS format to object */
+function parse(durationString) {
+  const matches = durationString.replace(/,/g, '.').match(pattern);
+  if (!matches) {
+    throw new RangeError('invalid duration: ' + durationString);
+  }
+
+  // Slice away repeat and first entry in match-array (the input string)
+  const slicedMatches = matches.slice(2);
+  if (slicedMatches.filter(Boolean).length === 0) {
+    throw new RangeError('invalid duration: ' + durationString);
+  }
+  // Check only one fraction is used
+  if (slicedMatches.filter(v => {
+    return /\./.test(v || '');
+  }).length > 1) {
+    throw new RangeError('Fractions are allowed on the smallest unit in the string, e.g. P0.5D or PT1.0001S but not PT0.5M0.1S: ' + durationString);
+  }
+  const result = {};
+  if (matches[1]) result.repeat = Number(matches[1]);
+  return slicedMatches.reduce((prev, next, idx) => {
+    prev[objMap[idx]] = parseFloat(next || '0') || 0;
+    return prev;
+  }, result);
+}
+
+/** Convert ISO8601 duration object to an end Date. */
+function end(durationInput, startDate) {
+  const duration = Object.assign({}, defaultDuration, durationInput);
+  // Create two equal timestamps, add duration to 'then' and return time difference
+  const timestamp = startDate.getTime();
+  const then = new Date(timestamp);
+  then.setFullYear(then.getFullYear() + duration.years);
+  then.setMonth(then.getMonth() + duration.months);
+  then.setDate(then.getDate() + duration.days);
+  // set time as milliseconds to get fractions working for minutes/hours
+  const hoursInMs = duration.hours * 3600 * 1000;
+  const minutesInMs = duration.minutes * 60 * 1000;
+  then.setMilliseconds(then.getMilliseconds() + duration.seconds * 1000 + hoursInMs + minutesInMs);
+  // Special case weeks
+  then.setDate(then.getDate() + duration.weeks * 7);
+  return then;
+}
+
+/** Convert ISO8601 duration object to seconds */
+function toSeconds(durationInput, startDate) {
+  if (startDate === void 0) {
+    startDate = new Date();
+  }
+  const duration = Object.assign({}, defaultDuration, durationInput);
+  const timestamp = startDate.getTime();
+  const now = new Date(timestamp);
+  const then = end(duration, now);
+  const seconds = (then.getTime() - now.getTime()) / 1000;
+  return seconds;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-elements",
-  "version": "9.1.3",
+  "version": "10.0.0",
   "description": "Executable workflow elements based on BPMN 2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -45,9 +45,9 @@
   ],
   "devDependencies": {
     "@aircall/expression-parser": "^1.0.4",
-    "@babel/cli": "^7.21.0",
-    "@babel/core": "^7.21.4",
-    "@babel/preset-env": "^7.21.4",
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.21.8",
+    "@babel/preset-env": "^7.21.5",
     "@babel/register": "^7.21.0",
     "bpmn-moddle": "^8.0.1",
     "c8": "^7.13.0",
@@ -55,16 +55,15 @@
     "chai": "^4.3.7",
     "chronokinesis": "^5.0.2",
     "debug": "^4.3.4",
-    "eslint": "^8.38.0",
+    "eslint": "^8.41.0",
     "eslint-plugin-import": "^2.27.5",
     "got": "^12.6.0",
     "mocha": "^10.1.0",
     "mocha-cakes-2": "^3.3.0",
     "moddle-context-serializer": "^3.2.2",
-    "nock": "^13.2.8"
+    "nock": "^13.3.1"
   },
   "dependencies": {
-    "iso8601-duration": "^2.1.1",
     "smqp": "^7.1.4"
   }
 }

package/src/Environment.js

@@ -24,7 +24,7 @@ export default function Environment(options = {}) {
   this.extensions = options.extensions;
   this.output = options.output || {};
   this.scripts = options.scripts || IScripts();
-  this.timers = options.timers || Timers();
+  this.timers = options.timers || new Timers();
   this.settings = {...options.settings};
   this.Logger = options.Logger || DummyLogger;
   this[kServices] = options.services || {};

package/src/Timers.js

@@ -1,56 +1,87 @@
-export function Timers(options) {
-  let count = 0;
-  const executing = [];
+const kExecuting = Symbol.for('executing');
+const kTimerApi = Symbol.for('timers api');
+
+const MAX_DELAY = 2147483647;
 
-  options = {
+export function Timers(options) {
+  this.count = 0;
+  this.options = {
     setTimeout,
     clearTimeout,
     ...options,
   };
+  this[kExecuting] = [];
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
 
-  const timersApi = {
-    get executing() {
-      return executing.slice();
-    },
-    register,
-    setTimeout: wrappedSetTimeout,
-    clearTimeout: wrappedClearTimeout,
-  };
+Object.defineProperty(Timers.prototype, 'executing', {
+  get() {
+    return this[kExecuting].slice();
+  },
+});
 
-  return timersApi;
+Timers.prototype.register = function register(owner) {
+  return new RegisteredTimers(this, owner);
+};
 
-  function register(owner) {
-    return {
-      setTimeout: registerTimeout(owner),
-      clearTimeout: timersApi.clearTimeout,
-    };
-  }
+Timers.prototype.setTimeout = function wrappedSetTimeout(callback, delay, ...args) {
+  return this._setTimeout(null, callback, delay, ...args);
+};
 
-  function registerTimeout(owner) {
-    return function registeredSetTimeout(...args) {
-      return timersApi.setTimeout.call(owner, ...args);
-    };
+Timers.prototype.clearTimeout = function wrappedClearTimeout(ref) {
+  const executing = this[kExecuting];
+  const idx = executing.indexOf(ref);
+  if (idx > -1) {
+    executing.splice(idx, 1);
+    ref.timerRef = this.options.clearTimeout(ref.timerRef);
+    return;
   }
+  return this.options.clearTimeout(ref);
+};
 
-  function wrappedSetTimeout(callback, delay, ...args) {
-    const ref = {timerId: `timer_${count++}`, callback, delay, args, owner: this};
-    executing.push(ref);
-    ref.timerRef = options.setTimeout.call(null, onTimeout, delay, ...args);
-    return ref;
-
-    function onTimeout(...rargs) {
-      const idx = executing.indexOf(ref);
-      if (idx > -1) executing.splice(idx, 1);
-      return callback(...rargs);
-    }
+Timers.prototype._setTimeout = function setTimeout(owner, callback, delay, ...args) {
+  const executing = this[kExecuting];
+  const ref = this._getReference(owner, callback, delay, args);
+  executing.push(ref);
+  if (delay < MAX_DELAY) {
+    ref.timerRef = this.options.setTimeout(onTimeout, ref.delay, ...ref.args);
   }
+  return ref;
 
-  function wrappedClearTimeout(ref) {
+  function onTimeout(...rargs) {
     const idx = executing.indexOf(ref);
-    if (idx > -1) {
-      executing.splice(idx, 1);
-      return options.clearTimeout.call(null, ref.timerRef);
-    }
-    return options.clearTimeout.call(null, ref);
+    if (idx > -1) executing.splice(idx, 1);
+    return callback(...rargs);
   }
+};
+
+Timers.prototype._getReference = function getReference(owner, callback, delay, args) {
+  return new Timer(owner, `timer_${this.count++}`, callback, delay, args);
+};
+
+function RegisteredTimers(timersApi, owner) {
+  this[kTimerApi] = timersApi;
+  this.owner = owner;
+  this.setTimeout = this.setTimeout.bind(this);
+  this.clearTimeout = this.clearTimeout.bind(this);
+}
+
+RegisteredTimers.prototype.setTimeout = function registeredSetTimeout(callback, delay, ...args) {
+  const timersApi = this[kTimerApi];
+  return timersApi._setTimeout(this.owner, callback, delay, ...args);
+};
+
+RegisteredTimers.prototype.clearTimeout = function registeredClearTimeout(ref) {
+  this[kTimerApi].clearTimeout(ref);
+};
+
+function Timer(owner, timerId, callback, delay, args) {
+  this.callback = callback;
+  this.delay = delay;
+  this.args = args;
+  this.owner = owner;
+  this.timerId = timerId;
+  this.expireAt = new Date(Date.now() + delay);
+  this.timerRef = null;
 }

package/src/activity/Activity.js

@@ -807,9 +807,10 @@ Activity.prototype._doOutbound = function doOutbound(fromMessage, isDiscarded, c
 
 Activity.prototype._doRunOutbound = function doRunOutbound(outboundList, content, discardSequence) {
   for (const outboundFlow of outboundList) {
-    const {id: flowId, action} = outboundFlow;
+    const {id: flowId, action, result} = outboundFlow;
     this.broker.publish('run', 'run.outbound.' + action, cloneContent(content, {
       flow: {
+        ...(result && typeof result === 'object' && result),
         ...outboundFlow,
         sequenceId: getUniqueId(`${flowId}_${action}`),
         ...(discardSequence && {discardSequence: discardSequence.slice()}),
@@ -1000,17 +1001,8 @@ OutboundEvaluator.prototype.onEvaluated = function onEvaluated(routingKey, messa
 
 OutboundEvaluator.prototype.evaluateFlow = function evaluateFlow(flow) {
   const broker = this.broker;
-  if (flow.isDefault) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-  }
-
-  const flowCondition = flow.getCondition();
-  if (!flowCondition) {
-    return broker.publish('execution', 'evaluate.flow.take', formatFlowAction(flow, {action: 'take'}), {persistent: false});
-  }
-
   const {fromMessage, evaluationId} = this.evaluateArgs;
-  flowCondition.execute(cloneMessage(fromMessage), (err, result) => {
+  flow.evaluate(cloneMessage(fromMessage), (err, result) => {
     if (err) return this.completed(err);
     const action = result ? 'take' : 'discard';
     return broker.publish('execution', 'evaluate.flow.' + action, formatFlowAction(flow, {

package/src/eventDefinitions/TimerEventDefinition.js

@@ -1,13 +1,12 @@
 import {cloneContent} from '../messageHelper.js';
-import {toSeconds, parse} from 'iso8601-duration';
+import {toSeconds, parse as parseIsoDuration} from '../iso-duration.js';
 
 const kStopped = Symbol.for('stopped');
 const kTimerContent = Symbol.for('timerContent');
 const kTimer = Symbol.for('timer');
-const repeatPattern = /^\s*R(\d+)\//;
 
 export default function TimerEventDefinition(activity, eventDefinition) {
-  const type = this.type = eventDefinition.type || 'TimerEventDefinition.js';
+  const type = this.type = eventDefinition.type || 'TimerEventDefinition';
   this.activity = activity;
   const environment = this.environment = activity.environment;
   this.eventDefinition = eventDefinition;
@@ -85,12 +84,14 @@ TimerEventDefinition.prototype.execute = function execute(executeMessage) {
   if (timerContent.timeout <= 0) return this._completed();
 
   const timers = this.environment.timers.register(timerContent);
-  this[kTimer] = timers.setTimeout(this._completed.bind(this), timerContent.timeout, {
+  const delay = timerContent.timeout;
+  this[kTimer] = timers.setTimeout(this._completed.bind(this), delay, {
     id: content.id,
     type: this.type,
     executionId,
     state: 'timeout',
   });
+  this._debug(`set timeout with delay ${delay}`);
 };
 
 TimerEventDefinition.prototype.stop = function stopTimer() {
@@ -175,14 +176,44 @@ TimerEventDefinition.prototype._stop = function stop() {
   broker.cancel(`_api-delegated-${this.executionId}`);
 };
 
+TimerEventDefinition.prototype.parse = function parse(timerType, value) {
+  let repeat, delay, expireAt;
+  switch (timerType) {
+    case 'timeCycle':
+    case 'timeDuration': {
+      const parsed = parseIsoDuration(value);
+      if (parsed.repeat) repeat = parsed.repeat;
+      delay = toSeconds(parsed) * 1000;
+      expireAt = new Date(Date.now() + delay);
+      break;
+    }
+    case 'timeDate': {
+      const ms = Date.parse(value);
+      if (!isNaN(ms)) {
+        expireAt = new Date(ms);
+        delay = Date.now() - expireAt;
+      } else {
+        throw new TypeError(`invalid timeDate >${value}<`);
+      }
+      break;
+    }
+  }
+
+  return {
+    expireAt,
+    repeat,
+    delay,
+  };
+};
+
 TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   const content = executeMessage.content;
 
-  const now = Date.now();
   const result = {
     ...('expireAt' in content && {expireAt: new Date(content.expireAt)}),
   };
 
+  let parseErr;
   for (const t of ['timeDuration', 'timeDate', 'timeCycle']) {
     if (t in content) result[t] = content[t];
     else if (t in this) result[t] = this.environment.resolveExpression(this[t], executeMessage);
@@ -191,47 +222,37 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
     let expireAtDate, repeat;
     const timerStr = result[t];
     if (timerStr) {
-      switch (t) {
-        case 'timeCycle': {
-          const mRepeat = timerStr.match(repeatPattern);
-          if (mRepeat && mRepeat.length) repeat = parseInt(mRepeat[1]);
-        }
-        case 'timeDuration': {
-          const delay = this._getDurationInMilliseconds(timerStr);
-          if (delay !== undefined) expireAtDate = new Date(now + delay);
-          break;
-        }
-        case 'timeDate': {
-          const dateStr = result[t];
-          const ms = Date.parse(dateStr);
-          if (!isNaN(ms)) {
-            expireAtDate = new Date(ms);
-          } else {
-            this._warn(`invalid timeDate >${dateStr}<`);
-          }
-          break;
-        }
+      try {
+        const {repeat: parsedRepeat, expireAt: parsedExpireAt} = this.parse(t, timerStr);
+        repeat = parsedRepeat;
+        expireAtDate = parsedExpireAt;
+      } catch (err) {
+        parseErr = err;
       }
     } else {
-      expireAtDate = new Date(now);
+      expireAtDate = new Date();
     }
 
     if (!expireAtDate) continue;
     if (!('expireAt' in result) || result.expireAt > expireAtDate) {
       result.timerType = t;
       result.expireAt = expireAtDate;
-      if (repeat) result.repeat = repeat;
+      result.repeat = repeat;
     }
   }
 
   if ('expireAt' in result) {
-    result.timeout = result.expireAt - now;
+    result.timeout = result.expireAt - Date.now();
   } else if ('timeout' in content) {
     result.timeout = content.timeout;
   } else if (!Object.keys(result).length) {
     result.timeout = 0;
   }
 
+  if (!('timeout' in result) && parseErr) {
+    this.logger.warn(`<${this.activity.id}> failed to parse timer: ${parseErr.message}`);
+  }
+
   if (content.inbound && 'repeat' in content.inbound[0]) {
     result.repeat = content.inbound[0].repeat;
   }
@@ -239,18 +260,6 @@ TimerEventDefinition.prototype._getTimers = function getTimers(executeMessage) {
   return result;
 };
 
-TimerEventDefinition.prototype._getDurationInMilliseconds = function getDurationInMilliseconds(duration) {
-  try {
-    return toSeconds(parse(duration)) * 1000;
-  } catch (err) {
-    this._warn(`failed to parse ${this.timerType} >${duration}<: ${err.message}`);
-  }
-};
-
 TimerEventDefinition.prototype._debug = function debug(msg) {
   this.logger.debug(`<${this.executionId} (${this.activity.id})> ${msg}`);
 };
-
-TimerEventDefinition.prototype._warn = function debug(msg) {
-  this.logger.warn(`<${this.executionId} (${this.activity.id})> ${msg}`);
-};

package/src/flows/SequenceFlow.js

@@ -101,7 +101,7 @@ SequenceFlow.prototype.shake = function shake(message) {
 
   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) {
+  for (const s of message.content.sequence || []) {
     if (s.id === this.id) return this.broker.publish('event', 'flow.shake.loop', content, {persistent: false, type: 'shake'});
   }
 
@@ -140,6 +140,19 @@ SequenceFlow.prototype.createMessage = function createMessage(override) {
   };
 };
 
+SequenceFlow.prototype.evaluate = function evaluate(fromMessage, callback) {
+  if (this.isDefault) {
+    return callback(null, true);
+  }
+
+  const flowCondition = this.getCondition();
+  if (!flowCondition) {
+    return callback(null, true);
+  }
+
+  flowCondition.execute(fromMessage, callback);
+};
+
 SequenceFlow.prototype._publishEvent = function publishEvent(action, content) {
   const eventContent = this.createMessage({
     action,

package/src/index.js

@@ -46,6 +46,8 @@ import Task from './tasks/Task.js';
 import TerminateEventDefinition from './eventDefinitions/TerminateEventDefinition.js';
 import TimerEventDefinition from './eventDefinitions/TimerEventDefinition.js';
 import Transaction from './tasks/Transaction.js';
+import {Timers} from './Timers.js';
+import * as ISODuration from './iso-duration.js';
 
 export {
   Association,
@@ -103,4 +105,6 @@ export {
   TerminateEventDefinition,
   TimerEventDefinition,
   Transaction,
+  Timers,
+  ISODuration,
 };

package/src/iso-duration.js

@@ -0,0 +1,91 @@
+// License MIT @ https://tolu.mit-license.org/
+
+const numbers = '\\d+';
+const fractionalNumbers = ''.concat(numbers, '(?:[\\.,]').concat(numbers, ')?');
+const datePattern = '('.concat(numbers, 'Y)?(').concat(numbers, 'M)?(').concat(numbers, 'W)?(').concat(fractionalNumbers, 'D)?');
+const timePattern = 'T('.concat(fractionalNumbers, 'H)?(').concat(fractionalNumbers, 'M)?(').concat(fractionalNumbers, 'S)?');
+
+const rPattern = '(?:R('.concat(numbers).concat(')/)?');
+const iso8601 = rPattern.concat('P(?:').concat(datePattern, '(?:').concat(timePattern, ')?)');
+const objMap = [
+  'years',
+  'months',
+  'weeks',
+  'days',
+  'hours',
+  'minutes',
+  'seconds',
+];
+const defaultDuration = Object.freeze({
+  years: 0,
+  months: 0,
+  weeks: 0,
+  days: 0,
+  hours: 0,
+  minutes: 0,
+  seconds: 0,
+});
+
+/**
+ * The ISO8601 regex for matching / testing durations
+ */
+const pattern = new RegExp(iso8601);
+
+/** Parse PnYnMnDTnHnMnS format to object */
+export function parse(durationString) {
+  const matches = durationString.replace(/,/g, '.').match(pattern);
+  if (!matches) {
+    throw new RangeError('invalid duration: ' + durationString);
+  }
+
+  // Slice away repeat and first entry in match-array (the input string)
+  const slicedMatches = matches.slice(2);
+  if (slicedMatches.filter(Boolean).length === 0) {
+    throw new RangeError('invalid duration: ' + durationString);
+  }
+  // Check only one fraction is used
+  if (slicedMatches.filter((v) => {
+    return /\./.test(v || '');
+  }).length > 1) {
+    throw new RangeError('Fractions are allowed on the smallest unit in the string, e.g. P0.5D or PT1.0001S but not PT0.5M0.1S: ' + durationString);
+  }
+
+  const result = {};
+  if (matches[1]) result.repeat = Number(matches[1]);
+
+  return slicedMatches.reduce((prev, next, idx) => {
+    prev[objMap[idx]] = parseFloat(next || '0') || 0;
+    return prev;
+  }, result);
+}
+
+/** Convert ISO8601 duration object to an end Date. */
+export function end(durationInput, startDate) {
+  const duration = Object.assign({}, defaultDuration, durationInput);
+  // Create two equal timestamps, add duration to 'then' and return time difference
+  const timestamp = startDate.getTime();
+  const then = new Date(timestamp);
+  then.setFullYear(then.getFullYear() + duration.years);
+  then.setMonth(then.getMonth() + duration.months);
+  then.setDate(then.getDate() + duration.days);
+  // set time as milliseconds to get fractions working for minutes/hours
+  const hoursInMs = duration.hours * 3600 * 1000;
+  const minutesInMs = duration.minutes * 60 * 1000;
+  then.setMilliseconds(then.getMilliseconds() + duration.seconds * 1000 + hoursInMs + minutesInMs);
+  // Special case weeks
+  then.setDate(then.getDate() + duration.weeks * 7);
+  return then;
+}
+
+/** Convert ISO8601 duration object to seconds */
+export function toSeconds(durationInput, startDate) {
+  if (startDate === void 0) {
+    startDate = new Date();
+  }
+  const duration = Object.assign({}, defaultDuration, durationInput);
+  const timestamp = startDate.getTime();
+  const now = new Date(timestamp);
+  const then = end(duration, now);
+  const seconds = (then.getTime() - now.getTime()) / 1000;
+  return seconds;
+}

package/types/index.d.ts

@@ -37,7 +37,8 @@ declare module 'bpmn-elements' {
     content: ElementMessageContent,
   }
 
-  interface EventDefinition {
+  class EventDefinition {
+    constructor(activity: Activity, eventDefinitionElement: SerializableElement)
     get id(): string;
     get type(): string;
     get executionId(): string;
@@ -481,6 +482,13 @@ declare module 'bpmn-elements' {
     shake(message: any): number;
     getCondition(): any;
     createMessage(override?: any): object;
+    /**
+     * Evaluate flow
+     * Executes condition if any, default flow is
+     * @param fromMessage Activity message
+     * @param {evaluateCallback} callback Callback with evaluation result, if truthy flow should be taken
+     */
+    evaluate(fromMessage: ElementBrokerMessage, callback: (err: Error, result: any) => void): void;
   }
 
   interface MessageFlowReference {
@@ -514,15 +522,53 @@ declare module 'bpmn-elements' {
     [x: string]: any,
   }
 
-  type wrappedSetTimeout = (handler: CallableFunction, timeout: number, ...args: unknown[]) => any;
-  type wrappedClearTimeout = (id?: any) => void;
+  type wrappedSetTimeout = (handler: TimerHandler, delay: number, ...args: any[]) => Timer;
+  type wrappedClearTimeout = (ref: any) => void;
+
+  interface Timer {
+    /** The function to call when the timer elapses */
+    readonly callback: TimerHandler;
+    /** The number of milliseconds to wait before calling the callback */
+    readonly delay: number;
+    /** Optional arguments to pass when the callback is called */
+    readonly args?: any[];
+    /** Timer owner if any */
+    readonly owner?: any;
+    /** Timer Id */
+    readonly timerId: string;
+    /** Timeout, return from setTimeout */
+    readonly timerRef: any;
+    [x: string]: any;
+  }
+
+  interface RegisteredTimer {
+    owner?: any;
+    get setTimeout(): wrappedSetTimeout;
+    get clearTimeout(): wrappedClearTimeout;
+  }
 
   interface ITimers {
-    get executing(): any[];
     get setTimeout(): wrappedSetTimeout;
     get clearTimeout(): wrappedClearTimeout;
-    register(owner?: any): { setTimeout: wrappedSetTimeout, clearTimeout: wrappedClearTimeout };
-    [x: string]: any,
+    register(owner?: any): RegisteredTimer;
+    [x: string]: any;
+  }
+
+  interface TimersOptions {
+    /** Defaults to builtin setTimeout */
+    setTimeout?: typeof setTimeout;
+    /** Defaults to builtin clearTimeout */
+    clearTimeout?: typeof clearTimeout;
+    [x: string]: any;
+  }
+
+  class Timers implements ITimers {
+    options: TimersOptions;
+    constructor(options?: TimersOptions);
+    get executing(): Timer[];
+    get setTimeout(): wrappedSetTimeout;
+    get clearTimeout(): wrappedClearTimeout;
+    register(owner?: any): RegisteredTimer;
   }
 
   interface IScripts {
@@ -595,7 +641,30 @@ declare module 'bpmn-elements' {
   var MessageEventDefinition: EventDefinition;
   var SignalEventDefinition: EventDefinition;
   var TerminateEventDefinition: EventDefinition;
-  var TimerEventDefinition: EventDefinition;
+
+  const enum TimerType {
+    TimeCycle = 'timeCycle',
+    TimeDuration = 'timeDuration',
+    TimeDate = 'timeDate',
+  }
+
+  type parsedTimer = {
+    /** Expires at date time */
+    expireAt?: Date,
+    /** Repeat number of times */
+    repeat?: number,
+    /** Delay in milliseconds */
+    delay?: number,
+  };
+
+  class TimerEventDefinition extends EventDefinition {
+    /**
+     * Parse timer type
+     * @param timerType type of timer
+     * @param timerValue resolved expression timer string
+     */
+    parse(timerType: TimerType, timerValue: string): parsedTimer;
+  }
 
   class BpmnError {
     get id(): string;
@@ -634,4 +703,33 @@ declare module 'bpmn-elements' {
     code?: string;
     constructor(description: string, sourceMessage: MessageMessage, inner?: Error);
   }
+
+  interface Duration {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    repeat?: number;
+  }
+
+  type ISODurationApi = {
+    /** Parse PnYnMnDTnHnMnS format to object */
+    parse: (durationString: string) => Duration,
+    /** Convert ISO8601 duration object to an end Date. */
+    end: (durationInput: Duration, startDate?: Date) => Date,
+    /** Convert ISO8601 duration object to seconds */
+    toSeconds: (durationInput: Duration, startDate?: Date) => number,
+  }
+
+  const ISODuration: ISODurationApi;
 }
+
+/**
+ * Evaluate flow callback
+ * @callback evaluateCallback
+ * @param {Error} err Evaluation error
+ * @param {boolean|object} evaluationResult If thruthy flow should be taken
+ */