bpmn-elements 12.0.0 → 13.1.0

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 Changelog
 =========
 
+# 13.1.0
+
+- introduce `disableTrackState` setting. Tracking of elements is done by counters, e.g. activity taken or discarded, sequence flow taken and discarded. Counters are saved when getting state. If you run really big flows the state will keep all elements just to be able to recover the number of times an element has been touched. Needless to say it the state will grow out of it's comfort zone. Setting `disableTrackState` to true will only return state for elements that are actually running
+
+## Breaking
+
+- `getState()` can return undefined
+
+# 13.0.0
+
+- export task-, events-, and gateway activity behaviors through `bpmn-elements/tasks`, `bpmn-elements/events`, and `bpmn-elements/gateways` respectively
+- refactor type definitions for three days to make the above type safe and VS-code happy. Why is it so freaking complicated? Ambient bla bla bla ts(4-digit-number)??? Looped through all 10.000 ts-typescript errors. Patches are inevitable and imminent
+- use `Object.defineProperties` when feasible and skip pointless enumerable option on property
+
 # 12.0.0
 
 Memory issues running sequential multi-instance sub-process (MISP). All MISP executions are put in a list to be able to save state.

package/dist/Environment.js

@@ -25,23 +25,23 @@ function Environment(options = {}) {
   this[kServices] = options.services || {};
   this[kVariables] = options.variables || {};
 }
-Object.defineProperty(Environment.prototype, 'variables', {
-  enumerable: true,
-  get() {
-    return this[kVariables];
-  }
-});
-Object.defineProperty(Environment.prototype, 'services', {
-  enumerable: true,
-  get() {
-    return this[kServices];
+Object.defineProperties(Environment.prototype, {
+  variables: {
+    get() {
+      return this[kVariables];
+    }
   },
-  set(value) {
-    const services = this[kServices];
-    for (const name in services) {
-      if (!(name in value)) delete services[name];
+  services: {
+    get() {
+      return this[kServices];
+    },
+    set(value) {
+      const services = this[kServices];
+      for (const name in services) {
+        if (!(name in value)) delete services[name];
+      }
+      Object.assign(services, value);
     }
-    Object.assign(services, value);
   }
 });
 Environment.prototype.getState = function getState() {

package/dist/activity/Activity.js

@@ -114,147 +114,128 @@ function Activity(Behaviour, activityDef, context) {
   this[kEventDefinitions] = eventDefinitions && eventDefinitions.map(ed => new ed.Behaviour(this, ed, this.context));
   this[kExtensions] = context.loadExtensions(this);
 }
-Object.defineProperty(Activity.prototype, 'counters', {
-  enumerable: true,
-  get() {
-    return {
-      ...this[kCounters]
-    };
-  }
-});
-Object.defineProperty(Activity.prototype, 'execution', {
-  enumerable: true,
-  get() {
-    return this[kExec].execution;
-  }
-});
-Object.defineProperty(Activity.prototype, 'executionId', {
-  enumerable: true,
-  get() {
-    return this[kExec].executionId;
-  }
-});
-Object.defineProperty(Activity.prototype, 'extensions', {
-  enumerable: true,
-  get() {
-    return this[kExtensions];
-  }
-});
-Object.defineProperty(Activity.prototype, 'bpmnIo', {
-  enumerable: true,
-  get() {
-    const extensions = this[kExtensions];
-    return extensions && extensions.extensions.find(e => e.type === 'bpmnio');
-  }
-});
-Object.defineProperty(Activity.prototype, 'formatter', {
-  enumerable: true,
-  get() {
-    let formatter = this[kFormatter];
-    if (formatter) return formatter;
-    const broker = this.broker;
-    formatter = this[kFormatter] = new _MessageFormatter.Formatter({
-      id: this.id,
-      broker,
-      logger: this.logger
-    }, broker.getQueue('format-run-q'));
-    return formatter;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isRunning', {
-  enumerable: true,
-  get() {
-    if (!this[kConsuming]) return false;
-    return !!this.status;
-  }
-});
-Object.defineProperty(Activity.prototype, 'outbound', {
-  enumerable: true,
-  get() {
-    return this[kFlows].outboundSequenceFlows;
-  }
-});
-Object.defineProperty(Activity.prototype, 'inbound', {
-  enumerable: true,
-  get() {
-    return this[kFlows].inboundSequenceFlows;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isEnd', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isEnd;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isStart', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isStart;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isSubProcess', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isSubProcess;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isTransaction', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isTransaction;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isMultiInstance', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isMultiInstance;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isThrowing', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isThrowing;
-  }
-});
-Object.defineProperty(Activity.prototype, 'isForCompensation', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isForCompensation;
-  }
-});
-Object.defineProperty(Activity.prototype, 'triggeredByEvent', {
-  enumerable: true,
-  get() {
-    return this[kActivityDef].triggeredByEvent;
-  }
-});
-Object.defineProperty(Activity.prototype, 'attachedTo', {
-  enumerable: true,
-  get() {
-    const attachedToId = this[kFlags].attachedTo;
-    if (!attachedToId) return null;
-    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);
+Object.defineProperties(Activity.prototype, {
+  counters: {
+    get() {
+      return {
+        ...this[kCounters]
+      };
+    }
+  },
+  execution: {
+    get() {
+      return this[kExec].execution;
+    }
+  },
+  executionId: {
+    get() {
+      return this[kExec].executionId;
+    }
+  },
+  extensions: {
+    get() {
+      return this[kExtensions];
+    }
+  },
+  bpmnIo: {
+    get() {
+      const extensions = this[kExtensions];
+      return extensions && extensions.extensions.find(e => e.type === 'bpmnio');
+    }
+  },
+  formatter: {
+    get() {
+      let formatter = this[kFormatter];
+      if (formatter) return formatter;
+      const broker = this.broker;
+      formatter = this[kFormatter] = new _MessageFormatter.Formatter({
+        id: this.id,
+        broker,
+        logger: this.logger
+      }, broker.getQueue('format-run-q'));
+      return formatter;
+    }
+  },
+  isRunning: {
+    get() {
+      if (!this[kConsuming]) return false;
+      return !!this.status;
+    }
+  },
+  outbound: {
+    get() {
+      return this[kFlows].outboundSequenceFlows;
+    }
+  },
+  inbound: {
+    get() {
+      return this[kFlows].inboundSequenceFlows;
+    }
+  },
+  isEnd: {
+    get() {
+      return this[kFlags].isEnd;
+    }
+  },
+  isStart: {
+    get() {
+      return this[kFlags].isStart;
+    }
+  },
+  isSubProcess: {
+    get() {
+      return this[kFlags].isSubProcess;
+    }
+  },
+  isTransaction: {
+    get() {
+      return this[kFlags].isTransaction;
+    }
+  },
+  isMultiInstance: {
+    get() {
+      return this[kFlags].isMultiInstance;
+    }
+  },
+  isThrowing: {
+    get() {
+      return this[kFlags].isThrowing;
+    }
+  },
+  isForCompensation: {
+    get() {
+      return this[kFlags].isForCompensation;
+    }
+  },
+  triggeredByEvent: {
+    get() {
+      return this[kActivityDef].triggeredByEvent;
+    }
+  },
+  attachedTo: {
+    get() {
+      const attachedToId = this[kFlags].attachedTo;
+      if (!attachedToId) return null;
+      return this.getActivityById(attachedToId);
+    }
+  },
+  lane: {
+    get() {
+      const laneId = this[kFlags].lane;
+      if (!laneId) return undefined;
+      const parent = this.parentElement;
+      return parent.getLaneById && parent.getLaneById(laneId);
+    }
+  },
+  eventDefinitions: {
+    get() {
+      return this[kEventDefinitions];
+    }
+  },
+  parentElement: {
+    get() {
+      return this.context.getActivityParentById(this.id);
+    }
   }
 });
 Activity.prototype.activate = function activate() {
@@ -298,6 +279,8 @@ Activity.prototype.run = function run(runContent) {
 Activity.prototype.getState = function getState() {
   const status = this.status;
   const exec = this[kExec];
+  const brokerState = this.broker.getState(true);
+  if (!brokerState && this.environment.settings.disableTrackState) return;
   return {
     id: this.id,
     type: this.type,
@@ -307,7 +290,7 @@ Activity.prototype.getState = function getState() {
     executionId: exec.executionId,
     stopped: this.stopped,
     counters: this.counters,
-    broker: this.broker.getState(true),
+    broker: brokerState,
     execution: exec.execution && exec.execution.getState()
   };
 };

package/dist/activity/ActivityExecution.js

@@ -29,7 +29,6 @@ function ActivityExecution(activity, context) {
   };
 }
 Object.defineProperty(ActivityExecution.prototype, 'completed', {
-  enumerable: true,
   get() {
     return this[kCompleted];
   }

package/dist/definition/Definition.js

@@ -69,48 +69,44 @@ function Definition(context, options) {
   this.emitFatal = emitFatal;
   this.logger = environment.Logger(type.toLowerCase());
 }
-Object.defineProperty(Definition.prototype, 'counters', {
-  enumerable: true,
-  get() {
-    return {
-      ...this[kCounters]
-    };
-  }
-});
-Object.defineProperty(Definition.prototype, 'execution', {
-  enumerable: true,
-  get() {
-    return this[kExec].execution;
-  }
-});
-Object.defineProperty(Definition.prototype, 'executionId', {
-  enumerable: true,
-  get() {
-    return this[kExec].executionId;
-  }
-});
-Object.defineProperty(Definition.prototype, 'isRunning', {
-  enumerable: true,
-  get() {
-    if (!this[kConsuming]) return false;
-    return !!this.status;
-  }
-});
-Object.defineProperty(Definition.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
-  }
-});
-Object.defineProperty(Definition.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
-  }
-});
-Object.defineProperty(Definition.prototype, 'activityStatus', {
-  get() {
-    return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+Object.defineProperties(Definition.prototype, {
+  counters: {
+    get() {
+      return {
+        ...this[kCounters]
+      };
+    }
+  },
+  execution: {
+    get() {
+      return this[kExec].execution;
+    }
+  },
+  executionId: {
+    get() {
+      return this[kExec].executionId;
+    }
+  },
+  isRunning: {
+    get() {
+      if (!this[kConsuming]) return false;
+      return !!this.status;
+    }
+  },
+  status: {
+    get() {
+      return this[kStatus];
+    }
+  },
+  stopped: {
+    get() {
+      return this[kStopped];
+    }
+  },
+  activityStatus: {
+    get() {
+      return this[kExec].execution && this[kExec].execution.activityStatus || 'idle';
+    }
   }
 });
 Definition.prototype.run = function run(optionsOrCallback, optionalCallback) {

package/dist/definition/DefinitionExecution.js

@@ -62,61 +62,59 @@ function DefinitionExecution(definition, context) {
     onProcessMessage: this._onProcessMessage.bind(this)
   };
 }
-Object.defineProperty(DefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'processes', {
-  enumerable: true,
-  get() {
-    return this[kProcesses].running;
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'postponedCount', {
-  get() {
-    return this[kProcesses].postponed.length;
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
-  get() {
-    return this[kActivated];
-  }
-});
-Object.defineProperty(DefinitionExecution.prototype, 'activityStatus', {
-  get() {
-    let status = 'idle';
-    const running = this[kProcesses].running;
-    if (!running || !running.length) return status;
-    for (const bp of running) {
-      const bpStatus = bp.activityStatus;
-      switch (bp.activityStatus) {
-        case 'idle':
-          break;
-        case 'executing':
-          return bpStatus;
-        case 'timer':
-          status = bpStatus;
-          break;
-        case 'wait':
-          if (status === 'idle') status = bpStatus;
-          break;
+Object.defineProperties(DefinitionExecution.prototype, {
+  stopped: {
+    get() {
+      return this[kStopped];
+    }
+  },
+  completed: {
+    get() {
+      return this[kCompleted];
+    }
+  },
+  status: {
+    get() {
+      return this[kStatus];
+    }
+  },
+  processes: {
+    get() {
+      return this[kProcesses].running;
+    }
+  },
+  postponedCount: {
+    get() {
+      return this[kProcesses].postponed.length;
+    }
+  },
+  isRunning: {
+    get() {
+      return this[kActivated];
+    }
+  },
+  activityStatus: {
+    get() {
+      let status = 'idle';
+      const running = this[kProcesses].running;
+      if (!running || !running.length) return status;
+      for (const bp of running) {
+        const bpStatus = bp.activityStatus;
+        switch (bp.activityStatus) {
+          case 'idle':
+            break;
+          case 'executing':
+            return bpStatus;
+          case 'timer':
+            status = bpStatus;
+            break;
+          case 'wait':
+            if (status === 'idle') status = bpStatus;
+            break;
+        }
       }
+      return status;
     }
-    return status;
   }
 });
 DefinitionExecution.prototype.execute = function execute(executeMessage) {

package/dist/eventDefinitions/EventDefinitionExecution.js

@@ -18,16 +18,16 @@ function EventDefinitionExecution(activity, eventDefinitions, completedRoutingKe
   this[kStopped] = false;
   this[kExecuteMessage] = null;
 }
-Object.defineProperty(EventDefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
-  }
-});
-Object.defineProperty(EventDefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+Object.defineProperties(EventDefinitionExecution.prototype, {
+  completed: {
+    get() {
+      return this[kCompleted];
+    }
+  },
+  stopped: {
+    get() {
+      return this[kStopped];
+    }
   }
 });
 EventDefinitionExecution.prototype.execute = function execute(executeMessage) {

package/dist/eventDefinitions/TimerEventDefinition.js

@@ -27,22 +27,22 @@ function TimerEventDefinition(activity, eventDefinition) {
   this[kStopped] = false;
   this[kTimer] = null;
 }
-Object.defineProperty(TimerEventDefinition.prototype, 'executionId', {
-  get() {
-    const content = this[kTimerContent];
-    return content && content.executionId;
-  }
-});
-Object.defineProperty(TimerEventDefinition.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
-  }
-});
-Object.defineProperty(TimerEventDefinition.prototype, 'timer', {
-  enumerable: true,
-  get() {
-    return this[kTimer];
+Object.defineProperties(TimerEventDefinition.prototype, {
+  executionId: {
+    get() {
+      const content = this[kTimerContent];
+      return content && content.executionId;
+    }
+  },
+  stopped: {
+    get() {
+      return this[kStopped];
+    }
+  },
+  timer: {
+    get() {
+      return this[kTimer];
+    }
   }
 });
 TimerEventDefinition.prototype.execute = function execute(executeMessage) {

package/dist/events/BoundaryEvent.js

@@ -29,17 +29,18 @@ function BoundaryEventBehaviour(activity) {
   this[kShovels] = [];
   this[kAttachedTags] = [];
 }
-Object.defineProperty(BoundaryEventBehaviour.prototype, 'executionId', {
-  get() {
-    const message = this[kExecuteMessage];
-    return message && message.content.executionId;
-  }
-});
-Object.defineProperty(BoundaryEventBehaviour.prototype, 'cancelActivity', {
-  enumerable: true,
-  get() {
-    const behaviour = this.activity.behaviour || {};
-    return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+Object.defineProperties(BoundaryEventBehaviour.prototype, {
+  executionId: {
+    get() {
+      const message = this[kExecuteMessage];
+      return message && message.content.executionId;
+    }
+  },
+  cancelActivity: {
+    get() {
+      const behaviour = this.activity.behaviour || {};
+      return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+    }
   }
 });
 BoundaryEventBehaviour.prototype.execute = function execute(executeMessage) {