bpmn-elements 12.0.0 → 13.0.0

package/src/activity/Activity.js

@@ -102,161 +102,126 @@ function Activity(Behaviour, activityDef, context) {
   this[kExtensions] = context.loadExtensions(this);
 }
 
-Object.defineProperty(Activity.prototype, 'counters', {
-  enumerable: true,
-  get() {
-    return {...this[kCounters]};
+Object.defineProperties(Activity.prototype, {
+  counters: {
+    get() {
+      return {...this[kCounters]};
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'execution', {
-  enumerable: true,
-  get() {
-    return this[kExec].execution;
+  execution: {
+    get() {
+      return this[kExec].execution;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'executionId', {
-  enumerable: true,
-  get() {
-    return this[kExec].executionId;
+  executionId: {
+    get() {
+      return this[kExec].executionId;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'extensions', {
-  enumerable: true,
-  get() {
-    return this[kExtensions];
+  extensions: {
+    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');
+  bpmnIo: {
+    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 Formatter({
-      id: this.id,
-      broker,
-      logger: this.logger,
-    }, broker.getQueue('format-run-q'));
-    return formatter;
+  formatter: {
+    get() {
+      let formatter = this[kFormatter];
+      if (formatter) return formatter;
+
+      const broker = this.broker;
+      formatter = this[kFormatter] = new 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;
+  isRunning: {
+    get() {
+      if (!this[kConsuming]) return false;
+      return !!this.status;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'outbound', {
-  enumerable: true,
-  get() {
-    return this[kFlows].outboundSequenceFlows;
+  outbound: {
+    get() {
+      return this[kFlows].outboundSequenceFlows;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'inbound', {
-  enumerable: true,
-  get() {
-    return this[kFlows].inboundSequenceFlows;
+  inbound: {
+    get() {
+      return this[kFlows].inboundSequenceFlows;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'isEnd', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isEnd;
+  isEnd: {
+    get() {
+      return this[kFlags].isEnd;
+    },
   },
-});
-Object.defineProperty(Activity.prototype, 'isStart', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isStart;
+  isStart: {
+    get() {
+      return this[kFlags].isStart;
+    },
   },
-});
-Object.defineProperty(Activity.prototype, 'isSubProcess', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isSubProcess;
+  isSubProcess: {
+    get() {
+      return this[kFlags].isSubProcess;
+    },
   },
-});
-Object.defineProperty(Activity.prototype, 'isTransaction', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isTransaction;
+  isTransaction: {
+    get() {
+      return this[kFlags].isTransaction;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'isMultiInstance', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isMultiInstance;
+  isMultiInstance: {
+    get() {
+      return this[kFlags].isMultiInstance;
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'isThrowing', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isThrowing;
+  isThrowing: {
+    get() {
+      return this[kFlags].isThrowing;
+    },
   },
-});
-Object.defineProperty(Activity.prototype, 'isForCompensation', {
-  enumerable: true,
-  get() {
-    return this[kFlags].isForCompensation;
+  isForCompensation: {
+    get() {
+      return this[kFlags].isForCompensation;
+    },
   },
-});
-Object.defineProperty(Activity.prototype, 'triggeredByEvent', {
-  enumerable: true,
-  get() {
-    return this[kActivityDef].triggeredByEvent;
+  triggeredByEvent: {
+    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);
+  attachedTo: {
+    get() {
+      const attachedToId = this[kFlags].attachedTo;
+      if (!attachedToId) return null;
+      return this.getActivityById(attachedToId);
+    },
   },
-});
-
-Object.defineProperty(Activity.prototype, 'lane', {
-  enumerable: true,
-  get() {
+  lane: { 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);
+  eventDefinitions: {
+    get() {
+      return this[kEventDefinitions];
+    },
+  },
+  parentElement: {
+    get() {
+      return this.context.getActivityParentById(this.id);
+    },
   },
 });
 

package/src/activity/ActivityExecution.js

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

package/src/definition/Definition.js

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

package/src/definition/DefinitionExecution.js

@@ -61,69 +61,61 @@ export default function DefinitionExecution(definition, context) {
   };
 }
 
-Object.defineProperty(DefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+Object.defineProperties(DefinitionExecution.prototype, {
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
+  completed: {
+    get() {
+      return this[kCompleted];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'status', {
-  enumerable: true,
-  get() {
-    return this[kStatus];
+  status: {
+    get() {
+      return this[kStatus];
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'processes', {
-  enumerable: true,
-  get() {
-    return this[kProcesses].running;
+  processes: {
+    get() {
+      return this[kProcesses].running;
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'postponedCount', {
-  get() {
-    return this[kProcesses].postponed.length;
+  postponedCount: {
+    get() {
+      return this[kProcesses].postponed.length;
+    },
   },
-});
-
-Object.defineProperty(DefinitionExecution.prototype, 'isRunning', {
-  get() {
-    return this[kActivated];
+  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;
+  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;
+    },
   },
 });
 

package/src/eventDefinitions/EventDefinitionExecution.js

@@ -15,17 +15,16 @@ export default function EventDefinitionExecution(activity, eventDefinitions, com
   this[kExecuteMessage] = null;
 }
 
-Object.defineProperty(EventDefinitionExecution.prototype, 'completed', {
-  enumerable: true,
-  get() {
-    return this[kCompleted];
+Object.defineProperties(EventDefinitionExecution.prototype, {
+  completed: {
+    get() {
+      return this[kCompleted];
+    },
   },
-});
-
-Object.defineProperty(EventDefinitionExecution.prototype, 'stopped', {
-  enumerable: true,
-  get() {
-    return this[kStopped];
+  stopped: {
+    get() {
+      return this[kStopped];
+    },
   },
 });
 

package/src/eventDefinitions/TimerEventDefinition.js

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

package/src/events/BoundaryEvent.js

@@ -25,18 +25,18 @@ export function BoundaryEventBehaviour(activity) {
   this[kAttachedTags] = [];
 }
 
-Object.defineProperty(BoundaryEventBehaviour.prototype, 'executionId', {
-  get() {
-    const message = this[kExecuteMessage];
-    return message && message.content.executionId;
+Object.defineProperties(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;
+  cancelActivity: {
+    get() {
+      const behaviour = this.activity.behaviour || {};
+      return 'cancelActivity' in behaviour ? behaviour.cancelActivity : true;
+    },
   },
 });
 

package/src/events/index.js

@@ -0,0 +1,5 @@
+export * from './BoundaryEvent.js';
+export * from './EndEvent.js';
+export * from './IntermediateCatchEvent.js';
+export * from './IntermediateThrowEvent.js';
+export * from './StartEvent.js';

package/src/flows/Association.js

@@ -34,7 +34,6 @@ export default function Association(associationDef, {environment}) {
 }
 
 Object.defineProperty(Association.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/flows/MessageFlow.js

@@ -35,7 +35,6 @@ export default function MessageFlow(flowDef, context) {
 }
 
 Object.defineProperty(MessageFlow.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/flows/SequenceFlow.js

@@ -41,7 +41,6 @@ function SequenceFlow(flowDef, {environment}) {
 }
 
 Object.defineProperty(SequenceFlow.prototype, 'counters', {
-  enumerable: true,
   get() {
     return {...this[kCounters]};
   },

package/src/gateways/index.js

@@ -0,0 +1,4 @@
+export * from './EventBasedGateway.js';
+export * from './ExclusiveGateway.js';
+export * from './InclusiveGateway.js';
+export * from './ParallelGateway.js';