bpmn-js 16.1.0 → 16.3.0

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v16.1.0
+ * bpmn-js - bpmn-modeler v16.3.0
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2023-12-14
+ * Date: 2023-12-22
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -832,6 +832,58 @@
     return Object.assign(target, ...others);
   }
 
+  /**
+   * Sets a nested property of a given object to the specified value.
+   *
+   * This mutates the object and returns it.
+   *
+   * @template T
+   *
+   * @param {T} target The target of the set operation.
+   * @param {(string|number)[]} path The path to the nested value.
+   * @param {any} value The value to set.
+   *
+   * @return {T}
+   */
+  function set$2(target, path, value) {
+
+    let currentTarget = target;
+
+    forEach$1(path, function(key, idx) {
+
+      if (typeof key !== 'number' && typeof key !== 'string') {
+        throw new Error('illegal key type: ' + typeof key + '. Key should be of type number or string.');
+      }
+
+      if (key === 'constructor') {
+        throw new Error('illegal key: constructor');
+      }
+
+      if (key === '__proto__') {
+        throw new Error('illegal key: __proto__');
+      }
+
+      let nextKey = path[idx + 1];
+      let nextTarget = currentTarget[key];
+
+      if (isDefined(nextKey) && isNil(nextTarget)) {
+        nextTarget = currentTarget[key] = isNaN(+nextKey) ? {} : [];
+      }
+
+      if (isUndefined$2(nextKey)) {
+        if (isUndefined$2(value)) {
+          delete currentTarget[key];
+        } else {
+          currentTarget[key] = value;
+        }
+      } else {
+        currentTarget = nextTarget;
+      }
+    });
+
+    return target;
+  }
+
   /**
    * Pick properties from the given target.
    *
@@ -8770,6 +8822,17 @@
     this.idProperty = p;
   };
 
+  DescriptorBuilder.prototype.assertNotTrait = function(typeDescriptor) {
+
+    const _extends = typeDescriptor.extends || [];
+
+    if (_extends.length) {
+      throw new Error(
+        `cannot create <${ typeDescriptor.name }> extending <${ typeDescriptor.extends }>`
+      );
+    }
+  };
+
   DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
     var propertyName = p.name,
         definedProperty = this.propertiesByName[propertyName];
@@ -8788,6 +8851,10 @@
 
   DescriptorBuilder.prototype.addTrait = function(t, inherited) {
 
+    if (inherited) {
+      this.assertNotTrait(t);
+    }
+
     var typesByName = this.allTypesByName,
         types = this.allTypes;
 
@@ -8921,7 +8988,9 @@
     });
 
     forEach$1(type.extends, bind$2(function(extendsName) {
-      var extended = this.typeMap[extendsName];
+      var extendsNameNs = parseName(extendsName, ns.prefix);
+
+      var extended = this.typeMap[extendsNameNs.name];
 
       extended.traits = extended.traits || [];
       extended.traits.push(name);
@@ -8950,24 +9019,33 @@
 
     var self = this;
 
+    /**
+     * Traverse the selected super type or trait
+     *
+     * @param {String} cls
+     * @param {Boolean} [trait=false]
+     */
+    function traverse(cls, trait) {
+      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
+      self.mapTypes(parentNs, iterator, trait);
+    }
+
     /**
      * Traverse the selected trait.
      *
      * @param {String} cls
      */
     function traverseTrait(cls) {
-      return traverseSuper(cls, true);
+      return traverse(cls, true);
     }
 
     /**
-     * Traverse the selected super type or trait
+     * Traverse the selected super type
      *
      * @param {String} cls
-     * @param {Boolean} [trait=false]
      */
-    function traverseSuper(cls, trait) {
-      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
-      self.mapTypes(parentNs, iterator, trait);
+    function traverseSuper(cls) {
+      return traverse(cls, false);
     }
 
     if (!type) {
@@ -9050,7 +9128,7 @@
       throw new TypeError('property name must be a non-empty string');
     }
 
-    var property = this.model.getPropertyDescriptor(target, name);
+    var property = this.getProperty(target, name);
 
     var propertyName = property && property.name;
 
@@ -9061,7 +9139,7 @@
       if (property) {
         delete target[propertyName];
       } else {
-        delete target.$attrs[name];
+        delete target.$attrs[stripGlobal(name)];
       }
     } else {
 
@@ -9074,7 +9152,7 @@
           defineProperty(target, property, value);
         }
       } else {
-        target.$attrs[name] = value;
+        target.$attrs[stripGlobal(name)] = value;
       }
     }
   };
@@ -9089,10 +9167,10 @@
    */
   Properties.prototype.get = function(target, name) {
 
-    var property = this.model.getPropertyDescriptor(target, name);
+    var property = this.getProperty(target, name);
 
     if (!property) {
-      return target.$attrs[name];
+      return target.$attrs[stripGlobal(name)];
     }
 
     var propertyName = property.name;
@@ -9146,6 +9224,44 @@
     this.define(target, '$model', { value: model });
   };
 
+  /**
+   * Return property with the given name on the element.
+   *
+   * @param {any} target
+   * @param {string} name
+   *
+   * @return {object | null} property
+   */
+  Properties.prototype.getProperty = function(target, name) {
+
+    var model = this.model;
+
+    var property = model.getPropertyDescriptor(target, name);
+
+    if (property) {
+      return property;
+    }
+
+    if (name.includes(':')) {
+      return null;
+    }
+
+    const strict = model.config.strict;
+
+    if (typeof strict !== 'undefined') {
+      const error = new TypeError(`unknown property <${ name }> on <${ target.$type }>`);
+
+      if (strict) {
+        throw error;
+      } else {
+
+        // eslint-disable-next-line no-undef
+        typeof console !== 'undefined' && console.warn(error);
+      }
+    }
+
+    return null;
+  };
 
   function isUndefined(val) {
     return typeof val === 'undefined';
@@ -9160,6 +9276,10 @@
     });
   }
 
+  function stripGlobal(name) {
+    return name.replace(/^:/, '');
+  }
+
   // Moddle implementation /////////////////////////////////////////////////
 
   /**
@@ -9182,8 +9302,10 @@
    * var moddle = new Moddle([pkg]);
    *
    * @param {Array<Package>} packages the packages to contain
+   *
+   * @param { { strict?: boolean } } [config] moddle configuration
    */
-  function Moddle(packages) {
+  function Moddle(packages, config = {}) {
 
     this.properties = new Properties(this);
 
@@ -9191,6 +9313,8 @@
     this.registry = new Registry(packages, this.properties);
 
     this.typeCache = {};
+
+    this.config = config;
   }
 
 
@@ -9284,6 +9408,12 @@
       $type: name,
       $instanceOf: function(type) {
         return type === this.$type;
+      },
+      get: function(key) {
+        return this[key];
+      },
+      set: function(key, value) {
+        set$2(this, [ key ], value);
       }
     };
 
@@ -9299,6 +9429,8 @@
 
     this.properties.defineDescriptor(element, descriptor);
     this.properties.defineModel(element, this);
+    this.properties.define(element, 'get', { enumerable: false, writable: true });
+    this.properties.define(element, 'set', { enumerable: false, writable: true });
     this.properties.define(element, '$parent', { enumerable: false, writable: true });
     this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });
 
@@ -37182,6 +37314,216 @@
 
   e$2(BoundaryEventBehavior, CommandInterceptor);
 
+  /**
+   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+   * @typedef {import('../lib/features/modeling/Modeling').default} Modeling
+   */
+
+  /**
+   *
+   *
+   * @param {import('diagram-js/lib/core/EventBus').default} eventBus
+   * @param {import('../Modeling').default} modeling
+   * @param {import('../../rules/BpmnRules').default} bpmnRules
+   */
+  function CompensateBoundaryEventBehavior(eventBus, modeling, bpmnRules) {
+
+    CommandInterceptor.call(this, eventBus);
+
+    this.preExecute('shape.replace', handleReplacement, true);
+    this.postExecuted('shape.replace', handleReplacementPostExecuted, true);
+    this.preExecute('connection.create', handleNewConnection, true);
+    this.postExecuted('connection.delete', handleConnectionRemoval, true);
+    this.postExecuted('connection.reconnect', handleReconnection, true);
+    this.postExecuted('element.updateProperties', handlePropertiesUpdate, true);
+
+    /**
+     * Given a connection from boundary event is removed, remove the forCompensation property.
+     */
+    function handleConnectionRemoval(context) {
+      const source = context.source,
+            target = context.target;
+
+      if (isCompensationBoundaryEvent(source) && isForCompensation$1(target)) {
+        removeIsForCompensationProperty(target);
+      }
+    }
+
+    /**
+     * Add forCompensation property and make sure only a single compensation activity is connected.
+     */
+    function handleNewConnection(context) {
+      const source = context.source,
+            target = context.target;
+
+      if (isCompensationBoundaryEvent(source) && canBeForCompensation(target)) {
+        addIsForCompensationProperty(target);
+        removeExistingAssociation(source);
+      }
+    }
+
+    function handleReconnection(context) {
+      const newTarget = context.newTarget,
+            oldSource = context.oldSource,
+            oldTarget = context.oldTarget;
+
+      // target changes
+      if (oldTarget !== newTarget) {
+        const source = oldSource;
+
+        // oldTarget perspective
+        if (isForCompensation$1(oldTarget)) {
+          removeIsForCompensationProperty(oldTarget);
+        }
+
+        // newTarget perspective
+        if (isCompensationBoundaryEvent(source) && canBeForCompensation(newTarget)) {
+          addIsForCompensationProperty(newTarget);
+        }
+      }
+    }
+
+    function handlePropertiesUpdate(context) {
+      const { element } = context;
+
+      if (isForCompensation$1(element)) {
+        removeIllegalConnections(element);
+        removeAttachments(element);
+      } else if (canBeForCompensation(element)) {
+        removeIncomingCompensationAssociations(element);
+      }
+    }
+
+    /**
+     * When replacing a boundary event, make sure the compensation activity is connected,
+     * and remove the potential candidates for connection replacement to have a single compensation activity.
+     */
+    function handleReplacement(context) {
+      const { targetElement } = context.hints || {},
+            { oldShape } = context;
+
+      // from compensate boundary event
+      if (isCompensationBoundaryEvent(context.oldShape) &&
+        targetElement.eventDefinitionType !== 'bpmn:CompensateEventDefinition' ||
+        targetElement.type !== 'bpmn:BoundaryEvent'
+      ) {
+        const targetConnection = oldShape.outgoing.find(
+          ({ target }) => isForCompensation$1(target)
+        );
+
+        if (targetConnection && targetConnection.target) {
+          context._connectionTarget = targetConnection.target;
+        }
+      }
+
+      // to compensate boundary event
+      else if (
+        !isCompensationBoundaryEvent(context.oldShape) &&
+        targetElement.eventDefinitionType === 'bpmn:CompensateEventDefinition' &&
+        targetElement.type === 'bpmn:BoundaryEvent'
+      ) {
+        const targetConnection = oldShape.outgoing.find(
+          ({ target }) => canBeForCompensation(target)
+        );
+
+        if (targetConnection && targetConnection.target) {
+          context._connectionTarget = targetConnection.target;
+        }
+
+        removeOutgoingSequenceFlows(oldShape);
+      }
+    }
+
+    function handleReplacementPostExecuted(context) {
+      const { _connectionTarget: target, newShape } = context;
+
+      if (target) {
+        modeling.connect(newShape, target);
+      }
+    }
+
+    function addIsForCompensationProperty(target) {
+      modeling.updateProperties(target, { isForCompensation: true });
+    }
+
+    function removeIsForCompensationProperty(target) {
+      modeling.updateProperties(target, { isForCompensation: undefined });
+    }
+
+    function removeIllegalConnections(element) {
+
+      for (const connection of element.incoming) {
+        if (!bpmnRules.canConnect(connection.source, element)) {
+          modeling.removeConnection(connection);
+        }
+      }
+
+      for (const connection of element.outgoing) {
+        if (!bpmnRules.canConnect(element, connection.target)) {
+          modeling.removeConnection(connection);
+        }
+      }
+    }
+
+    function removeExistingAssociation(boundaryEvent) {
+      const associations = boundaryEvent.outgoing.filter(connection => is$1(connection, 'bpmn:Association'));
+      const associationsToRemove = associations.filter(association => isForCompensation$1(association.target));
+
+      // remove existing associations
+      associationsToRemove.forEach(association => modeling.removeConnection(association));
+    }
+
+    function removeAttachments(element) {
+      const attachments = element.attachers.slice();
+
+      if (!attachments.length) {
+        return;
+      }
+
+      modeling.removeElements(attachments);
+    }
+
+    function removeIncomingCompensationAssociations(element) {
+      const compensationAssociations = element.incoming.filter(
+        connection => isCompensationBoundaryEvent(connection.source)
+      );
+
+      modeling.removeElements(compensationAssociations);
+    }
+
+    function removeOutgoingSequenceFlows(element) {
+      const sequenceFlows = element.outgoing.filter(
+        connection => is$1(connection, 'bpmn:SequenceFlow')
+      );
+
+      modeling.removeElements(sequenceFlows);
+    }
+  }
+
+  e$2(CompensateBoundaryEventBehavior, CommandInterceptor);
+
+  CompensateBoundaryEventBehavior.$inject = [
+    'eventBus',
+    'modeling',
+    'bpmnRules'
+  ];
+
+  // helpers //////////
+
+  function isForCompensation$1(element) {
+    const bo = getBusinessObject(element);
+    return bo && bo.get('isForCompensation');
+  }
+
+  function isCompensationBoundaryEvent(element) {
+    return element && is$1(element, 'bpmn:BoundaryEvent') &&
+      hasEventDefinition$2(element, 'bpmn:CompensateEventDefinition');
+  }
+
+  function canBeForCompensation(element) {
+    return element && is$1(element, 'bpmn:Activity') && !isEventSubProcess(element);
+  }
+
   /**
    * @typedef {import('didi').Injector} Injector
    */
@@ -41048,11 +41390,6 @@
         }
       }
 
-      if (is$1(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {
-        remove = true;
-      }
-
-
       // remove invalid connection,
       // unless it has been removed already
       if (remove) {
@@ -41086,11 +41423,14 @@
 
       replacement = modeling.connect(source, target, {
         type: allowed.type,
+        associationDirection: allowed.associationDirection,
         waypoints: connection.waypoints.slice()
       });
 
-      // remove old connection
-      modeling.removeConnection(connection);
+      // remove old connection unless it's already removed
+      if (connection.parent) {
+        modeling.removeConnection(connection);
+      }
 
       // replace connection in context to reconnect end/start
       context.connection = replacement;
@@ -42982,6 +43322,7 @@
       'associationBehavior',
       'attachEventBehavior',
       'boundaryEventBehavior',
+      'compensateBoundaryEventBehaviour',
       'createBehavior',
       'createDataObjectBehavior',
       'createParticipantBehavior',
@@ -43021,6 +43362,7 @@
     associationBehavior: [ 'type', AssociationBehavior ],
     attachEventBehavior: [ 'type', AttachEventBehavior ],
     boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
+    compensateBoundaryEventBehaviour: [ 'type', CompensateBoundaryEventBehavior ],
     createBehavior: [ 'type', CreateBehavior ],
     createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
     createParticipantBehavior: [ 'type', CreateParticipantBehavior ],
@@ -43091,7 +43433,7 @@
    * @typedef {import('diagram-js/lib/util/Types').Rect} Rect
    *
    * @typedef { {
-   *   associationDirection?: string;
+   *   associationDirection?: 'None' | 'One' | 'Both';
    *   type: string;
    * } | boolean | null } CanConnectResult
    *
@@ -43245,6 +43587,8 @@
 
   BpmnRules.prototype.canConnectAssociation = canConnectAssociation;
 
+  BpmnRules.prototype.canConnectCompensationAssociation = canConnectCompensationAssociation;
+
   BpmnRules.prototype.canMove = canMove;
 
   BpmnRules.prototype.canAttach = canAttach;
@@ -43591,7 +43935,7 @@
       return connectDataAssociation;
     }
 
-    if (isCompensationBoundary(source) && isForCompensation(target)) {
+    if (canConnectCompensationAssociation(source, target)) {
       return {
         type: 'bpmn:Association',
         associationDirection: 'One'
@@ -43599,9 +43943,9 @@
     }
 
     if (canConnectAssociation(source, target)) {
-
       return {
-        type: 'bpmn:Association'
+        type: 'bpmn:Association',
+        associationDirection: 'None'
       };
     }
 
@@ -44068,11 +44412,6 @@
    */
   function canConnectAssociation(source, target) {
 
-    // compensation boundary events are exception
-    if (isCompensationBoundary(source) && isForCompensation(target)) {
-      return true;
-    }
-
     // don't connect parent <-> child
     if (isParent(target, source) || isParent(source, target)) {
       return false;
@@ -44088,6 +44427,22 @@
     return !!canConnectDataAssociation(source, target);
   }
 
+  /**
+   * @param {Element} source
+   * @param {Element} target
+   *
+   * @return {boolean}
+   */
+  function canConnectCompensationAssociation(source, target) {
+    return (
+      isSameScope(source, target) &&
+      isCompensationBoundary(source) &&
+      is$1(target, 'bpmn:Activity') &&
+      !isHostOfElement(target, source) &&
+      !isEventSubProcess(target)
+    );
+  }
+
   /**
    * @param {Element} source
    * @param {Element} target
@@ -44214,6 +44569,10 @@
     return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
   }
 
+  function isHostOfElement(potentialHost, element) {
+    return potentialHost.attachers.includes(element);
+  }
+
   var RulesModule = {
     __depends__: [
       RulesModule$1
@@ -46488,6 +46847,10 @@
           return false;
         }
 
+        if (propertyName === 'isForCompensation') {
+          return !isEventSubProcess(newBusinessObject);
+        }
+
         return true;
       });