bpmn-js 16.2.0 → 16.3.1

package/dist/bpmn-modeler.development.js

@@ -1,5 +1,5 @@
 /*!
- * bpmn-js - bpmn-modeler v16.2.0
+ * bpmn-js - bpmn-modeler v16.3.1
  *
  * Copyright (c) 2014-present, camunda Services GmbH
  *
@@ -8,7 +8,7 @@
  *
  * Source Code: https://github.com/bpmn-io/bpmn-js
  *
- * Date: 2023-12-20
+ * Date: 2024-01-05
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
@@ -37314,6 +37314,220 @@
 
   e$2(BoundaryEventBehavior, CommandInterceptor);
 
+  /**
+   * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+   * @typedef {import('../lib/features/modeling/Modeling').default} Modeling
+   */
+
+  /**
+   * Behavior ensuring that only a single compensation activity is connected to a
+   * compensation boundary event when connecting, reconnecting or replacing shapes.
+   *
+   * @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 `isForCompensation` property.
+     */
+    function handleConnectionRemoval(context) {
+      const source = context.source,
+            target = context.target;
+
+      if (isCompensationBoundaryEvent(source) && isForCompensation$1(target)) {
+        removeIsForCompensationProperty(target);
+      }
+    }
+
+    /**
+     * Add `isForCompensation` property and make sure only a single compensation activity is connected.
+     */
+    function handleNewConnection(context) {
+      const connection = context.connection,
+            source = context.source,
+            target = context.target;
+
+      if (isCompensationBoundaryEvent(source) && isForCompensationAllowed(target)) {
+        addIsForCompensationProperty(target);
+        removeExistingAssociations(source, [ connection ]);
+      }
+    }
+
+    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) && isForCompensationAllowed(newTarget)) {
+          addIsForCompensationProperty(newTarget);
+        }
+      }
+    }
+
+    function handlePropertiesUpdate(context) {
+      const { element } = context;
+
+      if (isForCompensation$1(element)) {
+        removeDisallowedConnections(element);
+        removeAttachments(element);
+      } else if (isForCompensationAllowed(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 }) => isForCompensationAllowed(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 removeDisallowedConnections(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 removeExistingAssociations(boundaryEvent, ignoredAssociations) {
+      const associations = boundaryEvent.outgoing.filter(connection => is$1(connection, 'bpmn:Association'));
+      const associationsToRemove = associations.filter(association => {
+        return isForCompensation$1(association.target) && !ignoredAssociations.includes(association);
+      });
+
+      // 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 isForCompensationAllowed(element) {
+    return element && is$1(element, 'bpmn:Activity') && !isEventSubProcess(element);
+  }
+
   /**
    * @typedef {import('didi').Injector} Injector
    */
@@ -41180,11 +41394,6 @@
         }
       }
 
-      if (is$1(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {
-        remove = true;
-      }
-
-
       // remove invalid connection,
       // unless it has been removed already
       if (remove) {
@@ -41218,11 +41427,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;
@@ -43114,6 +43326,7 @@
       'associationBehavior',
       'attachEventBehavior',
       'boundaryEventBehavior',
+      'compensateBoundaryEventBehaviour',
       'createBehavior',
       'createDataObjectBehavior',
       'createParticipantBehavior',
@@ -43153,6 +43366,7 @@
     associationBehavior: [ 'type', AssociationBehavior ],
     attachEventBehavior: [ 'type', AttachEventBehavior ],
     boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
+    compensateBoundaryEventBehaviour: [ 'type', CompensateBoundaryEventBehavior ],
     createBehavior: [ 'type', CreateBehavior ],
     createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
     createParticipantBehavior: [ 'type', CreateParticipantBehavior ],
@@ -43223,7 +43437,7 @@
    * @typedef {import('diagram-js/lib/util/Types').Rect} Rect
    *
    * @typedef { {
-   *   associationDirection?: string;
+   *   associationDirection?: 'None' | 'One' | 'Both';
    *   type: string;
    * } | boolean | null } CanConnectResult
    *
@@ -43377,6 +43591,8 @@
 
   BpmnRules.prototype.canConnectAssociation = canConnectAssociation;
 
+  BpmnRules.prototype.canConnectCompensationAssociation = canConnectCompensationAssociation;
+
   BpmnRules.prototype.canMove = canMove;
 
   BpmnRules.prototype.canAttach = canAttach;
@@ -43723,7 +43939,7 @@
       return connectDataAssociation;
     }
 
-    if (isCompensationBoundary(source) && isForCompensation(target)) {
+    if (canConnectCompensationAssociation(source, target)) {
       return {
         type: 'bpmn:Association',
         associationDirection: 'One'
@@ -43731,9 +43947,9 @@
     }
 
     if (canConnectAssociation(source, target)) {
-
       return {
-        type: 'bpmn:Association'
+        type: 'bpmn:Association',
+        associationDirection: 'None'
       };
     }
 
@@ -44200,11 +44416,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;
@@ -44220,6 +44431,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
@@ -44346,6 +44573,10 @@
     return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
   }
 
+  function isHostOfElement(potentialHost, element) {
+    return potentialHost.attachers.includes(element);
+  }
+
   var RulesModule = {
     __depends__: [
       RulesModule$1
@@ -46620,6 +46851,10 @@
           return false;
         }
 
+        if (propertyName === 'isForCompensation') {
+          return !isEventSubProcess(newBusinessObject);
+        }
+
         return true;
       });