bpmn-elements 6.0.1 → 8.0.1

package/dist/src/Environment.js

@@ -13,122 +13,130 @@ var _Timers = require("./Timers");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const defaultOptions = ['extensions', 'output', 'services', 'scripts', 'settings', 'variables', 'Logger'];
+const kServices = Symbol.for('services');
+const kVariables = Symbol.for('variables');
+const defaultOptions = ['expressions', 'extensions', 'Logger', 'output', 'scripts', 'services', 'settings', 'timers', 'variables'];
 
 function Environment(options = {}) {
-  const initialOptions = validateOptions(options);
-  let variables = options.variables || {};
-  const settings = { ...options.settings
+  this.options = validateOptions(options);
+  this.expressions = options.expressions || (0, _Expressions.default)();
+  this.extensions = options.extensions;
+  this.output = options.output || {};
+  this.scripts = options.scripts || (0, _Scripts.Scripts)();
+  this.timers = options.timers || (0, _Timers.Timers)();
+  this.settings = { ...options.settings
   };
-  const output = options.output || {};
-  const services = options.services || {};
-  const scripts = options.scripts || (0, _Scripts.Scripts)();
-  const timers = options.timers || (0, _Timers.Timers)();
-  const expressions = options.expressions || (0, _Expressions.default)();
-  const Logger = options.Logger || DummyLogger;
-  const extensions = options.extensions;
-  const environmentApi = {
-    options: initialOptions,
-    expressions,
-    extensions,
-    output,
-    scripts,
-    services,
-    settings,
-    timers,
-
-    get variables() {
-      return variables;
-    },
+  this.Logger = options.Logger || DummyLogger;
+  this[kServices] = options.services || {};
+  this[kVariables] = options.variables || {};
+}
 
-    addService,
-    assignVariables,
-    clone,
-    getScript,
-    getServiceByName,
-    getState,
-    registerScript,
-    resolveExpression,
-    recover,
-    Logger
-  };
-  return environmentApi;
-
-  function getState() {
-    return {
-      settings: { ...settings
-      },
-      variables: { ...variables
-      },
-      output: { ...output
-      }
-    };
-  }
+const proto = Environment.prototype;
+Object.defineProperty(proto, 'variables', {
+  enumerable: true,
 
-  function recover(state) {
-    if (!state) return environmentApi;
-    const recoverOptions = validateOptions(state);
-    Object.assign(options, recoverOptions);
-    if (state.settings) Object.assign(settings, state.settings);
-    if (state.variables) Object.assign(variables, state.variables);
-    if (state.output) Object.assign(output, state.output);
-    return environmentApi;
+  get() {
+    return this[kVariables];
   }
 
-  function clone(overrideOptions = {}) {
-    const newOptions = {
-      settings: { ...settings
-      },
-      variables: { ...variables
-      },
-      output: { ...output
-      },
-      Logger,
-      extensions,
-      scripts,
-      timers,
-      expressions,
-      ...initialOptions,
-      ...overrideOptions,
-      services
-    };
-    if (overrideOptions.services) newOptions.services = { ...services,
-      ...overrideOptions.services
-    };
-    return Environment(newOptions);
-  }
+});
+Object.defineProperty(proto, 'services', {
+  enumerable: true,
 
-  function assignVariables(newVars) {
-    if (!newVars || typeof newVars !== 'object') return;
-    variables = { ...variables,
-      ...newVars
-    };
-  }
+  get() {
+    return this[kServices];
+  },
 
-  function getScript(...args) {
-    return scripts.getScript(...args);
-  }
+  set(value) {
+    const services = this[kServices];
 
-  function registerScript(...args) {
-    return scripts.register(...args);
-  }
+    for (const name in services) {
+      if (!(name in value)) delete services[name];
+    }
 
-  function getServiceByName(serviceName) {
-    return services[serviceName];
+    Object.assign(services, value);
   }
 
-  function resolveExpression(expression, message = {}, expressionFnContext) {
-    const from = {
-      environment: environmentApi,
-      ...message
-    };
-    return expressions.resolveExpression(expression, from, expressionFnContext);
-  }
+});
 
-  function addService(name, fn) {
-    services[name] = fn;
-  }
-}
+proto.getState = function getState() {
+  return {
+    settings: { ...this.settings
+    },
+    variables: { ...this[kVariables]
+    },
+    output: { ...this.output
+    }
+  };
+};
+
+proto.recover = function recover(state) {
+  if (!state) return this;
+  if (state.settings) Object.assign(this.settings, state.settings);
+  if (state.variables) Object.assign(this[kVariables], state.variables);
+  if (state.output) Object.assign(this.output, state.output);
+  return this;
+};
+
+proto.clone = function clone(overrideOptions = {}) {
+  const services = this[kServices];
+  const newOptions = {
+    settings: { ...this.settings
+    },
+    variables: { ...this[kVariables]
+    },
+    Logger: this.Logger,
+    extensions: this.extensions,
+    scripts: this.scripts,
+    timers: this.timers,
+    expressions: this.expressions,
+    ...this.options,
+    ...overrideOptions,
+    services
+  };
+  if (overrideOptions.services) newOptions.services = { ...services,
+    ...overrideOptions.services
+  };
+  return new this.constructor(newOptions);
+};
+
+proto.assignVariables = function assignVariables(newVars) {
+  if (!newVars || typeof newVars !== 'object') return;
+  this[kVariables] = { ...this.variables,
+    ...newVars
+  };
+};
+
+proto.assignSettings = function assignVariables(newSettings) {
+  if (!newSettings || typeof newSettings !== 'object') return;
+  this.settings = { ...this.settings,
+    ...newSettings
+  };
+};
+
+proto.getScript = function getScript(...args) {
+  return this.scripts.getScript(...args);
+};
+
+proto.registerScript = function registerScript(...args) {
+  return this.scripts.register(...args);
+};
+
+proto.getServiceByName = function getServiceByName(serviceName) {
+  return this[kServices][serviceName];
+};
+
+proto.resolveExpression = function resolveExpression(expression, message = {}, expressionFnContext) {
+  const from = {
+    environment: this,
+    ...message
+  };
+  return this.expressions.resolveExpression(expression, from, expressionFnContext);
+};
+
+proto.addService = function addService(name, fn) {
+  this[kServices][name] = fn;
+};
 
 function validateOptions(input) {
   const options = {};

package/dist/src/EventBroker.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ActivityBroker = ActivityBroker;
 exports.DefinitionBroker = DefinitionBroker;
+exports.EventBroker = EventBroker;
 exports.MessageFlowBroker = MessageFlowBroker;
 exports.ProcessBroker = ProcessBroker;
-exports.EventBroker = EventBroker;
 
 var _smqp = require("smqp");
 
@@ -27,7 +27,7 @@ function DefinitionBroker(owner, onBrokerReturn) {
 }
 
 function MessageFlowBroker(owner) {
-  const eventBroker = EventBroker(owner, {
+  const eventBroker = new EventBroker(owner, {
     prefix: 'messageflow',
     autoDelete: false,
     durable: false
@@ -46,7 +46,7 @@ function MessageFlowBroker(owner) {
 }
 
 function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
-  const eventBroker = EventBroker(brokerOwner, {
+  const eventBroker = new EventBroker(brokerOwner, {
     prefix,
     autoDelete: false,
     durable: false
@@ -84,104 +84,105 @@ function ExecutionBroker(brokerOwner, prefix, onBrokerReturn) {
 }
 
 function EventBroker(brokerOwner, options, onBrokerReturn) {
-  const broker = (0, _smqp.Broker)(brokerOwner);
-  const pfx = options.prefix;
+  this.options = options;
+  this.eventPrefix = options.prefix;
+  const broker = this.broker = (0, _smqp.Broker)(brokerOwner);
   broker.assertExchange('event', 'topic', options);
-  broker.on('return', onBrokerReturn || onBrokerReturnFn);
-  return {
-    eventPrefix: pfx,
-    broker,
-    on,
-    once,
-    waitFor,
-    emit,
-    emitFatal
-  };
-
-  function on(eventName, callback, eventOptions = {
-    once: false
-  }) {
-    const key = getEventRoutingKey(eventName);
-    if (eventOptions.once) return broker.subscribeOnce('event', key, eventCallback, eventOptions);
-    return broker.subscribeTmp('event', key, eventCallback, { ...eventOptions,
-      noAck: true
-    });
+  broker.on('return', onBrokerReturn ? onBrokerReturn.bind(brokerOwner) : this._onBrokerReturnFn.bind(this));
+  this.on = this.on.bind(this);
+  this.once = this.once.bind(this);
+  this.waitFor = this.waitFor.bind(this);
+  this.emit = this.emit.bind(this);
+  this.emitFatal = this.emitFatal.bind(this);
+}
 
-    function eventCallback(routingKey, message, owner) {
-      if (eventName === 'error') return callback((0, _Errors.makeErrorFromMessage)(message));
-      callback(owner.getApi(message));
-    }
-  }
+EventBroker.prototype.on = function on(eventName, callback, eventOptions = {
+  once: false
+}) {
+  const key = this._getEventRoutingKey(eventName);
+
+  if (eventOptions.once) return this.broker.subscribeOnce('event', key, eventCallback, eventOptions);
+  return this.broker.subscribeTmp('event', key, eventCallback, { ...eventOptions,
+    noAck: true
+  });
 
-  function once(eventName, callback, eventOptions = {}) {
-    return on(eventName, callback, { ...eventOptions,
-      once: true
-    });
+  function eventCallback(routingKey, message, owner) {
+    if (eventName === 'error') return callback((0, _Errors.makeErrorFromMessage)(message));
+    callback(owner.getApi(message));
   }
+};
 
-  function waitFor(eventName, onMessage) {
-    const key = getEventRoutingKey(eventName);
-    return new Promise((resolve, reject) => {
-      const consumers = [broker.subscribeTmp('event', key, eventCallback, {
-        noAck: true
-      }), broker.subscribeTmp('event', '*.error', errorCallback, {
-        noAck: true
-      })];
-
-      function eventCallback(routingKey, message, owner) {
-        if (onMessage && !onMessage(routingKey, message, owner)) return;
-        unsubscribe();
-        return resolve(owner.getApi(message));
-      }
+EventBroker.prototype.once = function once(eventName, callback, eventOptions = {}) {
+  return this.on(eventName, callback, { ...eventOptions,
+    once: true
+  });
+};
 
-      function errorCallback(routingKey, message, owner) {
-        if (!message.properties.mandatory) return;
-        unsubscribe();
-        return reject((0, _Errors.makeErrorFromMessage)(message, owner));
-      }
+EventBroker.prototype.waitFor = function waitFor(eventName, onMessage) {
+  const key = this._getEventRoutingKey(eventName);
 
-      function unsubscribe() {
-        consumers.forEach(consumer => consumer.cancel());
-      }
-    });
-  }
+  return new Promise((resolve, reject) => {
+    const consumers = [this.broker.subscribeTmp('event', key, eventCallback, {
+      noAck: true
+    }), this.broker.subscribeTmp('event', '*.error', errorCallback, {
+      noAck: true
+    })];
 
-  function onBrokerReturnFn(message) {
-    if (message.properties.type === 'error') {
-      const err = (0, _Errors.makeErrorFromMessage)(message);
-      throw err;
+    function eventCallback(routingKey, message, owner) {
+      if (onMessage && !onMessage(routingKey, message, owner)) return;
+      unsubscribe();
+      return resolve(owner.getApi(message));
     }
-  }
 
-  function getEventRoutingKey(eventName) {
-    if (eventName.indexOf('.') > -1) return eventName;
-
-    switch (eventName) {
-      case 'wait':
-        {
-          return `activity.${eventName}`;
-        }
+    function errorCallback(routingKey, message, owner) {
+      if (!message.properties.mandatory) return;
+      unsubscribe();
+      return reject((0, _Errors.makeErrorFromMessage)(message, owner));
+    }
 
-      default:
-        {
-          return `${pfx}.${eventName}`;
-        }
+    function unsubscribe() {
+      for (const consumer of consumers) {
+        consumer.cancel();
+      }
     }
-  }
+  });
+};
 
-  function emit(eventName, content = {}, props = {}) {
-    broker.publish('event', `${pfx}.${eventName}`, { ...content
-    }, {
-      type: eventName,
-      ...props
-    });
+EventBroker.prototype.emit = function emit(eventName, content, props) {
+  this.broker.publish('event', `${this.eventPrefix}.${eventName}`, { ...content
+  }, {
+    type: eventName,
+    ...props
+  });
+};
+
+EventBroker.prototype.emitFatal = function emitFatal(error, content) {
+  this.emit('error', { ...content,
+    error
+  }, {
+    mandatory: true
+  });
+};
+
+EventBroker.prototype._onBrokerReturnFn = function onBrokerReturnFn(message) {
+  if (message.properties.type === 'error') {
+    const err = (0, _Errors.makeErrorFromMessage)(message);
+    throw err;
   }
+};
+
+EventBroker.prototype._getEventRoutingKey = function getEventRoutingKey(eventName) {
+  if (eventName.indexOf('.') > -1) return eventName;
 
-  function emitFatal(error, content = {}) {
-    emit('error', { ...content,
-      error
-    }, {
-      mandatory: true
-    });
+  switch (eventName) {
+    case 'wait':
+      {
+        return `activity.${eventName}`;
+      }
+
+    default:
+      {
+        return `${this.eventPrefix}.${eventName}`;
+      }
   }
-}
+};

package/dist/src/ExtensionsMapper.js

@@ -28,11 +28,11 @@ function ExtensionsMapper(context) {
     }
 
     function activate(message) {
-      activityExtensions.forEach(extension => extension.activate(message));
+      for (const extension of activityExtensions) extension.activate(message);
     }
 
     function deactivate(message) {
-      activityExtensions.forEach(extension => extension.deactivate(message));
+      for (const extension of activityExtensions) extension.deactivate(message);
     }
   }