bpmn-elements 6.0.1 → 8.0.1

package/dist/src/Api.js

@@ -4,106 +4,107 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ActivityApi = ActivityApi;
+exports.Api = Api;
 exports.DefinitionApi = DefinitionApi;
-exports.ProcessApi = ProcessApi;
 exports.FlowApi = FlowApi;
-exports.Api = Api;
+exports.ProcessApi = ProcessApi;
 
 var _messageHelper = require("./messageHelper");
 
 var _shared = require("./shared");
 
 function ActivityApi(broker, apiMessage, environment) {
-  return Api('activity', broker, apiMessage, environment);
+  return new Api('activity', broker, apiMessage, environment);
 }
 
 function DefinitionApi(broker, apiMessage, environment) {
-  return Api('definition', broker, apiMessage, environment);
+  return new Api('definition', broker, apiMessage, environment);
 }
 
 function ProcessApi(broker, apiMessage, environment) {
-  return Api('process', broker, apiMessage, environment);
+  return new Api('process', broker, apiMessage, environment);
 }
 
 function FlowApi(broker, apiMessage, environment) {
-  return Api('flow', broker, apiMessage, environment);
+  return new Api('flow', broker, apiMessage, environment);
 }
 
 function Api(pfx, broker, sourceMessage, environment) {
   if (!sourceMessage) throw new Error('Api requires message');
   const apiMessage = (0, _messageHelper.cloneMessage)(sourceMessage);
-  const apiContent = apiMessage.content;
   const {
-    id,
-    type,
-    name
-  } = apiContent;
-  const executionId = apiContent.executionId;
-  const owner = broker.owner;
-  environment = environment || broker.owner.environment;
-  return {
     id,
     type,
     name,
-    executionId,
-    environment,
-    fields: apiMessage.fields,
-    content: apiContent,
-    messageProperties: apiMessage.properties,
-
-    get owner() {
-      return owner;
-    },
-
-    cancel(message, options) {
-      sendApiMessage('cancel', {
-        message
-      }, options);
-    },
-
-    discard() {
-      sendApiMessage('discard');
-    },
-
-    signal(message, options) {
-      sendApiMessage('signal', {
-        message
-      }, options);
-    },
-
-    stop() {
-      sendApiMessage('stop');
-    },
-
-    resolveExpression(expression) {
-      return environment.resolveExpression(expression, apiMessage, broker.owner);
-    },
-
-    sendApiMessage,
-    createMessage,
-    getPostponed
-  };
+    executionId
+  } = apiMessage.content;
+  this.id = id;
+  this.type = type;
+  this.name = name;
+  this.executionId = executionId;
+  this.environment = environment || broker.owner.environment;
+  this.content = apiMessage.content;
+  this.fields = apiMessage.fields;
+  this.messageProperties = apiMessage.properties;
+  this.broker = broker;
+  this.owner = broker.owner;
+  this.messagePrefix = pfx;
+}
 
-  function sendApiMessage(action, content, options = {}) {
-    if (!options.correlationId) options = { ...options,
-      correlationId: (0, _shared.getUniqueId)(`${id || pfx}_signal`)
-    };
-    let key = `${pfx}.${action}`;
-    if (executionId) key += `.${executionId}`;
-    broker.publish('api', key, createMessage(content), { ...options,
-      type: action
-    });
-  }
-
-  function getPostponed(...args) {
-    if (owner.getPostponed) return owner.getPostponed(...args);
-    if (owner.isSubProcess && owner.execution) return owner.execution.getPostponed(...args);
-    return [];
-  }
-
-  function createMessage(content = {}) {
-    return { ...apiContent,
-      ...content
-    };
-  }
-}
+const proto = Api.prototype;
+
+proto.cancel = function cancel(message, options) {
+  this.sendApiMessage('cancel', {
+    message
+  }, options);
+};
+
+proto.discard = function discard() {
+  this.sendApiMessage('discard');
+};
+
+proto.fail = function fail(error) {
+  this.sendApiMessage('error', {
+    error
+  });
+};
+
+proto.signal = function signal(message, options) {
+  this.sendApiMessage('signal', {
+    message
+  }, options);
+};
+
+proto.stop = function stop() {
+  this.sendApiMessage('stop');
+};
+
+proto.resolveExpression = function resolveExpression(expression) {
+  return this.environment.resolveExpression(expression, {
+    fields: this.fields,
+    content: this.content,
+    properties: this.messageProperties
+  }, this.owner);
+};
+
+proto.sendApiMessage = function sendApiMessage(action, content, options) {
+  const correlationId = options && options.correlationId || (0, _shared.getUniqueId)(`${this.id || this.messagePrefix}_signal`);
+  let key = `${this.messagePrefix}.${action}`;
+  if (this.executionId) key += `.${this.executionId}`;
+  this.broker.publish('api', key, this.createMessage(content), { ...options,
+    correlationId,
+    type: action
+  });
+};
+
+proto.getPostponed = function getPostponed(...args) {
+  if (this.owner.getPostponed) return this.owner.getPostponed(...args);
+  if (this.owner.isSubProcess && this.owner.execution) return this.owner.execution.getPostponed(...args);
+  return [];
+};
+
+proto.createMessage = function createMessage(content) {
+  return { ...this.content,
+    ...content
+  };
+};

package/dist/src/Context.js

@@ -14,8 +14,8 @@ var _shared = require("./shared");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function Context(definitionContext, environment) {
-  environment = environment ? environment.clone() : (0, _Environment.default)();
-  return ContextInstance(definitionContext, environment);
+  environment = environment ? environment.clone() : new _Environment.default();
+  return new ContextInstance(definitionContext, environment);
 }
 
 function ContextInstance(definitionContext, environment) {
@@ -25,180 +25,184 @@ function ContextInstance(definitionContext, environment) {
     type = 'context'
   } = definitionContext;
   const sid = (0, _shared.getUniqueId)(id);
-  const activityRefs = {},
-        dataObjectRefs = {},
-        dataStoreRefs = {},
-        messageFlows = [],
-        processes = [],
-        processRefs = {},
-        sequenceFlowRefs = {},
-        sequenceFlows = [],
-        associationRefs = [];
-  const context = {
-    id,
-    name,
-    type,
-    sid,
-    definitionContext,
-    environment,
-    clone,
-    getActivities,
-    getActivityById,
-    getAssociations,
-    getExecutableProcesses,
-    getDataObjectById,
-    getDataStoreById,
-    getInboundAssociations,
-    getInboundSequenceFlows,
-    getMessageFlows,
-    getOutboundSequenceFlows,
-    getOutboundAssociations,
-    getProcessById,
-    getProcesses,
-    getSequenceFlowById,
-    getSequenceFlows,
-    getStartActivities,
-    loadExtensions
+  this.id = id;
+  this.name = name;
+  this.type = type;
+  this.sid = sid;
+  this.definitionContext = definitionContext;
+  this.environment = environment;
+  this.extensionsMapper = (0, _ExtensionsMapper.default)(this);
+  this.refs = {
+    activityRefs: {},
+    associationRefs: [],
+    dataObjectRefs: {},
+    dataStoreRefs: {},
+    messageFlows: [],
+    processes: [],
+    processRefs: {},
+    sequenceFlowRefs: {},
+    sequenceFlows: []
   };
-  const extensionsMapper = (0, _ExtensionsMapper.default)(context);
-  return context;
-
-  function getActivityById(activityId) {
-    const activityInstance = activityRefs[activityId];
-    if (activityInstance) return activityInstance;
-    const activity = definitionContext.getActivityById(activityId);
-    if (!activity) return null;
-    return upsertActivity(activity);
-  }
-
-  function upsertActivity(activityDef) {
-    let activityInstance = activityRefs[activityDef.id];
-    if (activityInstance) return activityInstance;
-    activityInstance = activityRefs[activityDef.id] = activityDef.Behaviour(activityDef, context);
-    return activityInstance;
-  }
-
-  function getSequenceFlowById(sequenceFlowId) {
-    const flowInstance = sequenceFlowRefs[sequenceFlowId];
-    if (flowInstance) return flowInstance;
-    const flowDef = definitionContext.getSequenceFlowById(sequenceFlowId);
-    if (!flowDef) return null;
-    return upsertSequenceFlow(flowDef);
-  }
-
-  function getInboundSequenceFlows(activityId) {
-    return (definitionContext.getInboundSequenceFlows(activityId) || []).map(flow => upsertSequenceFlow(flow));
-  }
-
-  function getOutboundSequenceFlows(activityId) {
-    return (definitionContext.getOutboundSequenceFlows(activityId) || []).map(flow => upsertSequenceFlow(flow));
-  }
-
-  function getInboundAssociations(activityId) {
-    return (definitionContext.getInboundAssociations(activityId) || []).map(association => upsertAssociation(association));
-  }
-
-  function getOutboundAssociations(activityId) {
-    return (definitionContext.getOutboundAssociations(activityId) || []).map(association => upsertAssociation(association));
-  }
-
-  function getActivities(scopeId) {
-    return (definitionContext.getActivities(scopeId) || []).map(activityDef => upsertActivity(activityDef));
-  }
-
-  function getSequenceFlows(scopeId) {
-    return (definitionContext.getSequenceFlows(scopeId) || []).map(flow => upsertSequenceFlow(flow));
-  }
-
-  function upsertSequenceFlow(flowDefinition) {
-    let flowInstance = sequenceFlowRefs[flowDefinition.id];
-    if (flowInstance) return flowInstance;
-    flowInstance = sequenceFlowRefs[flowDefinition.id] = flowDefinition.Behaviour(flowDefinition, context);
-    sequenceFlows.push(flowInstance);
-    return flowInstance;
-  }
-
-  function getAssociations(scopeId) {
-    return (definitionContext.getAssociations(scopeId) || []).map(association => upsertAssociation(association));
-  }
-
-  function upsertAssociation(associationDefinition) {
-    let instance = associationRefs[associationDefinition.id];
-    if (instance) return instance;
-    instance = associationRefs[associationDefinition.id] = associationDefinition.Behaviour(associationDefinition, context);
-    return instance;
-  }
-
-  function clone(newEnvironment) {
-    return ContextInstance(definitionContext, newEnvironment || environment);
-  }
-
-  function getProcessById(processId) {
-    let processInstance = processRefs[processId];
-    if (processInstance) return processInstance;
-    const processDefinition = definitionContext.getProcessById(processId);
-    if (!processDefinition) return null;
-    processInstance = processRefs[processId] = processDefinition.Behaviour(processDefinition, context);
-    processes.push(processInstance);
-    return processInstance;
-  }
-
-  function getProcesses() {
-    return definitionContext.getProcesses().map(({
-      id: processId
-    }) => getProcessById(processId));
-  }
-
-  function getExecutableProcesses() {
-    return definitionContext.getExecutableProcesses().map(({
-      id: processId
-    }) => getProcessById(processId));
-  }
+}
 
-  function getMessageFlows(sourceId) {
-    if (!messageFlows.length) {
-      const flows = definitionContext.getMessageFlows() || [];
-      messageFlows.push(...flows.map(flow => flow.Behaviour(flow, context)));
+const proto = ContextInstance.prototype;
+
+proto.getActivityById = function getActivityById(activityId) {
+  const activityInstance = this.refs.activityRefs[activityId];
+  if (activityInstance) return activityInstance;
+  const activity = this.definitionContext.getActivityById(activityId);
+  if (!activity) return null;
+  return this.upsertActivity(activity);
+};
+
+proto.upsertActivity = function upsertActivity(activityDef) {
+  let activityInstance = this.refs.activityRefs[activityDef.id];
+  if (activityInstance) return activityInstance;
+  activityInstance = this.refs.activityRefs[activityDef.id] = new activityDef.Behaviour(activityDef, this);
+  return activityInstance;
+};
+
+proto.getSequenceFlowById = function getSequenceFlowById(sequenceFlowId) {
+  const flowInstance = this.refs.sequenceFlowRefs[sequenceFlowId];
+  if (flowInstance) return flowInstance;
+  const flowDef = this.definitionContext.getSequenceFlowById(sequenceFlowId);
+  if (!flowDef) return null;
+  return this.upsertSequenceFlow(flowDef);
+};
+
+proto.getInboundSequenceFlows = function getInboundSequenceFlows(activityId) {
+  return (this.definitionContext.getInboundSequenceFlows(activityId) || []).map(flow => this.upsertSequenceFlow(flow));
+};
+
+proto.getOutboundSequenceFlows = function getOutboundSequenceFlows(activityId) {
+  return (this.definitionContext.getOutboundSequenceFlows(activityId) || []).map(flow => this.upsertSequenceFlow(flow));
+};
+
+proto.getInboundAssociations = function getInboundAssociations(activityId) {
+  return (this.definitionContext.getInboundAssociations(activityId) || []).map(association => this.upsertAssociation(association));
+};
+
+proto.getOutboundAssociations = function getOutboundAssociations(activityId) {
+  return (this.definitionContext.getOutboundAssociations(activityId) || []).map(association => this.upsertAssociation(association));
+};
+
+proto.getActivities = function getActivities(scopeId) {
+  return (this.definitionContext.getActivities(scopeId) || []).map(activityDef => this.upsertActivity(activityDef));
+};
+
+proto.getSequenceFlows = function getSequenceFlows(scopeId) {
+  return (this.definitionContext.getSequenceFlows(scopeId) || []).map(flow => this.upsertSequenceFlow(flow));
+};
+
+proto.upsertSequenceFlow = function upsertSequenceFlow(flowDefinition) {
+  const refs = this.refs.sequenceFlowRefs;
+  let flowInstance = refs[flowDefinition.id];
+  if (flowInstance) return flowInstance;
+  flowInstance = refs[flowDefinition.id] = new flowDefinition.Behaviour(flowDefinition, this);
+  this.refs.sequenceFlows.push(flowInstance);
+  return flowInstance;
+};
+
+proto.getAssociations = function getAssociations(scopeId) {
+  return (this.definitionContext.getAssociations(scopeId) || []).map(association => this.upsertAssociation(association));
+};
+
+proto.upsertAssociation = function upsertAssociation(associationDefinition) {
+  const refs = this.refs.associationRefs;
+  let instance = refs[associationDefinition.id];
+  if (instance) return instance;
+  instance = refs[associationDefinition.id] = new associationDefinition.Behaviour(associationDefinition, this);
+  return instance;
+};
+
+proto.clone = function clone(newEnvironment) {
+  return new ContextInstance(this.definitionContext, newEnvironment || this.environment);
+};
+
+proto.getProcessById = function getProcessById(processId) {
+  const refs = this.refs.processRefs;
+  let bp = this.refs.processRefs[processId];
+  if (bp) return bp;
+  const processDefinition = this.definitionContext.getProcessById(processId);
+  if (!processDefinition) return null;
+  const bpContext = this.clone(this.environment.clone());
+  bp = refs[processId] = new processDefinition.Behaviour(processDefinition, bpContext);
+  this.refs.processes.push(bp);
+  return bp;
+};
+
+proto.getNewProcessById = function getNewProcessById(processId) {
+  if (!this.getProcessById(processId)) return null;
+  const bpDef = this.definitionContext.getProcessById(processId);
+  const bp = new bpDef.Behaviour(bpDef, this.clone(this.environment.clone()));
+  return bp;
+};
+
+proto.getProcesses = function getProcesses() {
+  return this.definitionContext.getProcesses().map(({
+    id: processId
+  }) => this.getProcessById(processId));
+};
+
+proto.getExecutableProcesses = function getExecutableProcesses() {
+  return this.definitionContext.getExecutableProcesses().map(({
+    id: processId
+  }) => this.getProcessById(processId));
+};
+
+proto.getMessageFlows = function getMessageFlows(sourceId) {
+  if (!this.refs.messageFlows.length) {
+    const flows = this.definitionContext.getMessageFlows() || [];
+    this.refs.messageFlows.push(...flows.map(flow => new flow.Behaviour(flow, this)));
+  }
+
+  return this.refs.messageFlows.filter(flow => flow.source.processId === sourceId);
+};
+
+proto.getDataObjectById = function getDataObjectById(referenceId) {
+  let dataObject;
+  if (dataObject = this.refs.dataObjectRefs[referenceId]) return dataObject;
+  const dataObjectDef = this.definitionContext.getDataObjectById(referenceId);
+  if (!dataObjectDef) return;
+  dataObject = this.refs.dataObjectRefs[dataObjectDef.id] = new dataObjectDef.Behaviour(dataObjectDef, this);
+  return dataObject;
+};
+
+proto.getDataStoreById = function getDataStoreById(referenceId) {
+  let dataStore;
+  if (dataStore = this.refs.dataStoreRefs[referenceId]) return dataStore;
+  const dataStoreDef = this.definitionContext.getDataStoreById(referenceId) || this.definitionContext.getDataStoreReferenceById(referenceId);
+  if (!dataStoreDef) return;
+  dataStore = this.refs.dataStoreRefs[dataStoreDef.id] = new dataStoreDef.Behaviour(dataStoreDef, this);
+  return dataStore;
+};
+
+proto.getStartActivities = function getStartActivities(filterOptions, scopeId) {
+  const {
+    referenceId,
+    referenceType = 'unknown'
+  } = filterOptions || {};
+  const result = [];
+
+  for (const activity of this.getActivities()) {
+    if (!activity.isStart) continue;
+    if (scopeId && activity.parent.id !== scopeId) continue;
+
+    if (!filterOptions) {
+      result.push(activity);
+      continue;
     }
 
-    return messageFlows.filter(flow => flow.source.processId === sourceId);
-  }
-
-  function getDataObjectById(referenceId) {
-    let dataObject;
-    if (dataObject = dataObjectRefs[referenceId]) return dataObject;
-    const dataObjectDef = definitionContext.getDataObjectById(referenceId);
-    if (!dataObjectDef) return;
-    dataObject = dataObjectRefs[dataObjectDef.id] = dataObjectDef.Behaviour(dataObjectDef, context);
-    return dataObject;
-  }
-
-  function getDataStoreById(referenceId) {
-    let dataStore;
-    if (dataStore = dataStoreRefs[referenceId]) return dataStore;
-    const dataStoreDef = definitionContext.getDataStoreById(referenceId) || definitionContext.getDataStoreReferenceById(referenceId);
-    if (!dataStoreDef) return;
-    dataStore = dataStoreRefs[dataStoreDef.id] = dataStoreDef.Behaviour(dataStoreDef, context);
-    return dataStore;
-  }
-
-  function getStartActivities(filterOptions, scopeId) {
-    const {
-      referenceId,
-      referenceType = 'unknown'
-    } = filterOptions || {};
-    return getActivities().filter(activity => {
-      if (!activity.isStart) return false;
-      if (scopeId && activity.parent.id !== scopeId) return false;
-      if (!filterOptions) return true;
-      if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) return false;
-      return activity.eventDefinitions.some(ed => {
-        return ed.reference && ed.reference.id === referenceId && ed.reference.referenceType === referenceType;
-      });
+    if (!activity.behaviour.eventDefinitions && !activity.behaviour.eventDefinitions) continue;
+    const ref = activity.eventDefinitions.some(ed => {
+      return ed.reference && ed.reference.id === referenceId && ed.reference.referenceType === referenceType;
     });
+    if (ref) result.push(activity);
   }
 
-  function loadExtensions(activity) {
-    return extensionsMapper.get(activity);
-  }
-}
+  return result;
+};
+
+proto.loadExtensions = function loadExtensions(activity) {
+  return this.extensionsMapper.get(activity);
+};