bpmn-elements 12.0.0 → 13.0.0

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 Changelog
 =========
 
+# 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() {

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) {