bpmn-elements 9.2.0 → 10.1.0

package/CHANGELOG.md

@@ -1,6 +1,19 @@
 Changelog
 =========
 
+# 10.1.0
+
+- introduce Lane behaviour
+- add process `lanes` property with Lane instances
+- add activity `lane` property containing a reference to the process lane instance
+- add activity `parentElement` property referencing parent process or sub process
+
+# 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

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/Context.js

@@ -9,11 +9,12 @@ var _Environment = _interopRequireDefault(require("./Environment.js"));
 var _ExtensionsMapper = _interopRequireDefault(require("./ExtensionsMapper.js"));
 var _shared = require("./shared.js");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const kOwner = Symbol.for('owner');
 function Context(definitionContext, environment) {
   environment = environment ? environment.clone() : new _Environment.default();
   return new ContextInstance(definitionContext, environment);
 }
-function ContextInstance(definitionContext, environment) {
+function ContextInstance(definitionContext, environment, owner) {
   const {
     id = 'Def',
     name,
@@ -38,7 +39,13 @@ function ContextInstance(definitionContext, environment) {
     sequenceFlowRefs: {},
     sequenceFlows: []
   };
+  this[kOwner] = owner;
 }
+Object.defineProperty(ContextInstance.prototype, 'owner', {
+  get() {
+    return this[kOwner];
+  }
+});
 ContextInstance.prototype.getActivityById = function getActivityById(activityId) {
   const activityInstance = this.refs.activityRefs[activityId];
   if (activityInstance) return activityInstance;
@@ -95,8 +102,8 @@ ContextInstance.prototype.upsertAssociation = function upsertAssociation(associa
   instance = refs[associationDefinition.id] = new associationDefinition.Behaviour(associationDefinition, this);
   return instance;
 };
-ContextInstance.prototype.clone = function clone(newEnvironment) {
-  return new ContextInstance(this.definitionContext, newEnvironment || this.environment);
+ContextInstance.prototype.clone = function clone(newEnvironment, newOwner) {
+  return new ContextInstance(this.definitionContext, newEnvironment || this.environment, newOwner);
 };
 ContextInstance.prototype.getProcessById = function getProcessById(processId) {
   const refs = this.refs.processRefs;
@@ -106,13 +113,16 @@ ContextInstance.prototype.getProcessById = function getProcessById(processId) {
   if (!processDefinition) return null;
   const bpContext = this.clone(this.environment.clone());
   bp = refs[processId] = new processDefinition.Behaviour(processDefinition, bpContext);
+  bpContext[kOwner] = bp;
   this.refs.processes.push(bp);
   return bp;
 };
 ContextInstance.prototype.getNewProcessById = function getNewProcessById(processId) {
   if (!this.getProcessById(processId)) return null;
   const bpDef = this.definitionContext.getProcessById(processId);
-  const bp = new bpDef.Behaviour(bpDef, this.clone(this.environment.clone()));
+  const bpContext = this.clone(this.environment.clone());
+  const bp = new bpDef.Behaviour(bpDef, bpContext);
+  bpContext[kOwner] = bp;
   return bp;
 };
 ContextInstance.prototype.getProcesses = function getProcesses() {
@@ -175,4 +185,11 @@ ContextInstance.prototype.loadExtensions = function loadExtensions(activity) {
   if (io.hasIo) extensions.extensions.push(io);
   if (!extensions.extensions.length) return;
   return extensions;
+};
+ContextInstance.prototype.getActivityParentById = function getActivityParentById(activityId) {
+  const owner = this[kOwner];
+  if (owner) return owner;
+  const activity = this.getActivityById(activityId);
+  const parentId = activity.parent.id;
+  return this.getProcessById(parentId) || this.getActivityById(parentId);
 };

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

@@ -102,7 +102,8 @@ function Activity(Behaviour, activityDef, context) {
     attachedTo,
     isTransaction: activityDef.isTransaction,
     isParallelJoin,
-    isThrowing: activityDef.isThrowing
+    isThrowing: activityDef.isThrowing,
+    lane: activityDef.lane && activityDef.lane.id
   };
   this[kExec] = {};
   this[kMessageHandlers] = {
@@ -236,12 +237,27 @@ Object.defineProperty(Activity.prototype, 'attachedTo', {
     return this.getActivityById(attachedToId);
   }
 });
+Object.defineProperty(Activity.prototype, 'lane', {
+  enumerable: true,
+  get() {
+    const laneId = this[kFlags].lane;
+    if (!laneId) return undefined;
+    const parent = this.parentElement;
+    return parent.getLaneById && parent.getLaneById(laneId);
+  }
+});
 Object.defineProperty(Activity.prototype, 'eventDefinitions', {
   enumerable: true,
   get() {
     return this[kEventDefinitions];
   }
 });
+Object.defineProperty(Activity.prototype, 'parentElement', {
+  enumerable: true,
+  get() {
+    return this.context.getActivityParentById(this.id);
+  }
+});
 Activity.prototype.activate = function activate() {
   this[kActivated] = true;
   this.addInboundListeners();

package/dist/definition/DefinitionExecution.js

@@ -294,31 +294,36 @@ DefinitionExecution.prototype._activate = function activate(processList) {
 };
 DefinitionExecution.prototype._activateProcess = function activateProcess(bp) {
   const handlers = this[kMessageHandlers];
-  bp.broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
+  const broker = bp.broker;
+  broker.subscribeTmp('message', 'message.outbound', handlers.onMessageOutbound, {
     noAck: true,
     consumerTag: '_definition-outbound-message-consumer'
   });
-  bp.broker.subscribeTmp('event', 'activity.signal', handlers.onDelegateMessage, {
+  const delegateEventQ = broker.assertQueue('_delegate-event-q', {
+    autoDelete: false,
+    durable: false
+  });
+  delegateEventQ.consume(handlers.onDelegateMessage, {
     noAck: true,
-    consumerTag: '_definition-signal-consumer',
+    consumerTag: '_definition-signal-consumer'
+  });
+  broker.bindQueue('_delegate-event-q', 'event', 'activity.signal', {
     priority: 200
   });
-  bp.broker.subscribeTmp('event', 'activity.message', handlers.onDelegateMessage, {
-    noAck: true,
-    consumerTag: '_definition-message-consumer',
+  broker.bindQueue('_delegate-event-q', 'event', 'activity.message', {
     priority: 200
   });
-  bp.broker.subscribeTmp('event', 'activity.call', handlers.onCallActivity, {
+  broker.subscribeTmp('event', 'activity.call', handlers.onCallActivity, {
     noAck: true,
     consumerTag: '_definition-call-consumer',
     priority: 200
   });
-  bp.broker.subscribeTmp('event', 'activity.call.cancel', handlers.onCancelCallActivity, {
+  broker.subscribeTmp('event', 'activity.call.cancel', handlers.onCancelCallActivity, {
     noAck: true,
     consumerTag: '_definition-call-cancel-consumer',
     priority: 200
   });
-  bp.broker.subscribeTmp('event', '#', handlers.onChildEvent, {
+  broker.subscribeTmp('event', '#', handlers.onChildEvent, {
     noAck: true,
     consumerTag: '_definition-activity-consumer',
     priority: 100
@@ -351,7 +356,6 @@ DefinitionExecution.prototype._deactivateProcess = function deactivateProcess(bp
   bp.broker.cancel('_definition-outbound-message-consumer');
   bp.broker.cancel('_definition-activity-consumer');
   bp.broker.cancel('_definition-signal-consumer');
-  bp.broker.cancel('_definition-message-consumer');
   bp.broker.cancel('_definition-call-consumer');
   bp.broker.cancel('_definition-call-cancel-consumer');
 };

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/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 () {
@@ -171,6 +172,12 @@ Object.defineProperty(exports, "IntermediateThrowEvent", {
     return _IntermediateThrowEvent.default;
   }
 });
+Object.defineProperty(exports, "Lane", {
+  enumerable: true,
+  get: function () {
+    return _Lane.default;
+  }
+});
 Object.defineProperty(exports, "LinkEventDefinition", {
   enumerable: true,
   get: function () {
@@ -321,6 +328,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 () {
@@ -358,6 +371,7 @@ var _InclusiveGateway = _interopRequireDefault(require("./gateways/InclusiveGate
 var _InputOutputSpecification = _interopRequireDefault(require("./io/InputOutputSpecification.js"));
 var _IntermediateCatchEvent = _interopRequireDefault(require("./events/IntermediateCatchEvent.js"));
 var _IntermediateThrowEvent = _interopRequireDefault(require("./events/IntermediateThrowEvent.js"));
+var _Lane = _interopRequireDefault(require("./process/Lane.js"));
 var _LinkEventDefinition = _interopRequireDefault(require("./eventDefinitions/LinkEventDefinition.js"));
 var _LoopCharacteristics = _interopRequireDefault(require("./tasks/LoopCharacteristics.js"));
 var _Message = _interopRequireDefault(require("./activity/Message.js"));
@@ -381,4 +395,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/dist/process/Lane.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Lane;
+const kProcess = Symbol.for('process');
+function Lane(process, laneDefinition) {
+  const {
+    broker,
+    environment
+  } = process;
+  const {
+    id,
+    type,
+    behaviour
+  } = laneDefinition;
+  this[kProcess] = process;
+  this.id = id;
+  this.type = type;
+  this.name = behaviour.name;
+  this.parent = {
+    id: process.id,
+    type: process.type
+  };
+  this.behaviour = {
+    ...behaviour
+  };
+  this.environment = environment;
+  this.broker = broker;
+  this.context = process.context;
+  this.logger = environment.Logger(type.toLowerCase());
+}
+Object.defineProperty(Lane.prototype, 'process', {
+  get() {
+    return this[kProcess];
+  }
+});