bpmn-elements 9.2.0 → 10.1.0

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/src/process/Lane.js

@@ -0,0 +1,27 @@
+const kProcess = Symbol.for('process');
+
+export default 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];
+  },
+});

package/src/process/Process.js

@@ -10,6 +10,7 @@ const kCounters = Symbol.for('counters');
 const kExec = Symbol.for('execution');
 const kExecuteMessage = Symbol.for('executeMessage');
 const kExtensions = Symbol.for('extensions');
+const kLanes = Symbol.for('lanes');
 const kMessageHandlers = Symbol.for('messageHandlers');
 const kStateMessage = Symbol.for('stateMessage');
 const kStatus = Symbol.for('status');
@@ -53,6 +54,9 @@ export function Process(processDef, context) {
 
   this.logger = environment.Logger(type.toLowerCase());
 
+  if (behaviour.lanes) {
+    this[kLanes] = behaviour.lanes.map((lane) => new lane.Behaviour(this, lane));
+  }
   this[kExtensions] = context.loadExtensions(this);
 }
 
@@ -63,6 +67,14 @@ Object.defineProperty(Process.prototype, 'counters', {
   },
 });
 
+Object.defineProperty(Process.prototype, 'lanes', {
+  enumerable: true,
+  get() {
+    const lanes = this[kLanes];
+    return lanes && lanes.slice();
+  },
+});
+
 Object.defineProperty(Process.prototype, 'extensions', {
   enumerable: true,
   get() {
@@ -399,6 +411,12 @@ Process.prototype.getSequenceFlows = function getSequenceFlows() {
   return this.context.getSequenceFlows();
 };
 
+Process.prototype.getLaneById = function getLaneById(laneId) {
+  const lanes = this[kLanes];
+  if (!lanes) return;
+  return lanes.find((lane) => lane.id === laneId);
+};
+
 Process.prototype.getPostponed = function getPostponed(...args) {
   const execution = this.execution;
   if (!execution) return [];

package/src/tasks/SubProcess.js

@@ -135,7 +135,7 @@ SubProcessBehaviour.prototype.recover = function recover(state) {
   }
 
   const subEnvironment = this.environment.clone().recover(state.environment);
-  const subContext = this.context.clone(subEnvironment);
+  const subContext = this.context.clone(subEnvironment, this.activity);
 
   const execution = new ProcessExecution(this.activity, subContext).recover(state);
 
@@ -176,7 +176,7 @@ SubProcessBehaviour.prototype._upsertExecution = function upsertExecution(execut
   }
 
   const subEnvironment = this.environment.clone();
-  const subContext = this.context.clone(subEnvironment);
+  const subContext = this.context.clone(subEnvironment, this.activity);
 
   execution = new ProcessExecution(this.activity, subContext);
   this[kExecutions].push(execution);

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;
@@ -287,6 +288,8 @@ declare module 'bpmn-elements' {
     get sid(): string;
     get definitionContext(): SerializableContext;
     get environment(): Environment;
+    /** Context owner, Process or SubProcess activity */
+    get owner(): Process | Activity | undefined;
     getActivityById<T>(activityId: string): T;
     getSequenceFlowById(sequenceFlowId: string): SequenceFlow;
     getInboundSequenceFlows(activityId: string): SequenceFlow[];
@@ -428,6 +431,7 @@ declare module 'bpmn-elements' {
     constructor(processDef: SerializableElement, context: Context);
     get isExecutable(): boolean;
     get counters(): completedCounters;
+    get lanes(): Lane[] | undefined;
     get extensions(): IExtension;
     get stopped(): boolean;
     get isRunning(): boolean;
@@ -447,6 +451,7 @@ declare module 'bpmn-elements' {
     getActivities(): Activity[];
     getStartActivities(filterOptions?: startActivityFilterOptions): Activity[];
     getSequenceFlows(): SequenceFlow[];
+    getLaneById(laneId: string): Lane | undefined;
     getPostponed(filterFn: filterPostponed): Api<ElementBase>[];
   }
 
@@ -470,6 +475,24 @@ declare module 'bpmn-elements' {
     getApi(message?: ElementBrokerMessage): Api<ElementBase>;
   }
 
+  class Lane extends ElementBase {
+    constructor(process: Process, laneDefinition: SerializableElement);
+    /** Process broker */
+    get broker(): Broker;
+    get process(): Process;
+  }
+
+  interface ISequenceFlowCondition {
+    /** Condition type, e.g. script or expression */
+    get type(): string;
+    /**
+     * Execute sequence flow condition
+     * @param message Source element execution message
+     * @param callback Callback with truthy result if flow should be taken
+     */
+    execute(message: ElementBrokerMessage, callback: (err: Error, result: any) => void): void;
+  }
+
   class SequenceFlow extends Element<SequenceFlow> {
     get sourceId(): string;
     get targetId(): string;
@@ -479,7 +502,7 @@ declare module 'bpmn-elements' {
     take(content?: any): boolean;
     discard(content?: any): void;
     shake(message: any): number;
-    getCondition(): any;
+    getCondition(): ISequenceFlowCondition | null;
     createMessage(override?: any): object;
     /**
      * Evaluate flow
@@ -495,6 +518,7 @@ declare module 'bpmn-elements' {
     get id(): string;
     get processId(): string;
   }
+
   class MessageFlow extends Element<MessageFlow> {
     get source(): MessageFlowReference;
     get target(): MessageFlowReference;
@@ -521,15 +545,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 {
@@ -557,6 +619,8 @@ declare module 'bpmn-elements' {
     get triggeredByEvent(): boolean;
     get attachedTo(): Activity;
     get eventDefinitions(): EventDefinition[];
+    /** Parent element process or sub process reference */
+    get parentElement(): Process | Activity;
     activate(): void;
     deactivate(): void;
     init(initContent?: any): void;
@@ -602,7 +666,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;
@@ -641,6 +728,28 @@ 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;
 }
 
 /**