bpmn-js 16.2.0 → 16.3.0

package/lib/features/modeling/behavior/CompensateBoundaryEventBehavior.js

@@ -0,0 +1,216 @@
+import inherits from 'inherits-browser';
+
+import { getBusinessObject, is } from '../../../util/ModelUtil';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+import { hasEventDefinition, isEventSubProcess } from '../../../util/DiUtil';
+
+/**
+ * @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
+ */
+export default 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(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(oldTarget)) {
+        removeIsForCompensationProperty(oldTarget);
+      }
+
+      // newTarget perspective
+      if (isCompensationBoundaryEvent(source) && canBeForCompensation(newTarget)) {
+        addIsForCompensationProperty(newTarget);
+      }
+    }
+  }
+
+  function handlePropertiesUpdate(context) {
+    const { element } = context;
+
+    if (isForCompensation(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(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(connection, 'bpmn:Association'));
+    const associationsToRemove = associations.filter(association => isForCompensation(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(connection, 'bpmn:SequenceFlow')
+    );
+
+    modeling.removeElements(sequenceFlows);
+  }
+}
+
+inherits(CompensateBoundaryEventBehavior, CommandInterceptor);
+
+CompensateBoundaryEventBehavior.$inject = [
+  'eventBus',
+  'modeling',
+  'bpmnRules'
+];
+
+// helpers //////////
+
+function isForCompensation(element) {
+  const bo = getBusinessObject(element);
+  return bo && bo.get('isForCompensation');
+}
+
+function isCompensationBoundaryEvent(element) {
+  return element && is(element, 'bpmn:BoundaryEvent') &&
+    hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
+}
+
+function canBeForCompensation(element) {
+  return element && is(element, 'bpmn:Activity') && !isEventSubProcess(element);
+}

package/lib/features/modeling/behavior/ReplaceConnectionBehavior.js

@@ -76,11 +76,6 @@ export default function ReplaceConnectionBehavior(eventBus, modeling, bpmnRules,
       }
     }
 
-    if (is(connection, 'bpmn:Association') && !bpmnRules.canConnectAssociation(source, target)) {
-      remove = true;
-    }
-
-
     // remove invalid connection,
     // unless it has been removed already
     if (remove) {
@@ -114,11 +109,14 @@ export default function ReplaceConnectionBehavior(eventBus, modeling, bpmnRules,
 
     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;

package/lib/features/modeling/behavior/index.js

@@ -3,6 +3,7 @@ import AppendBehavior from './AppendBehavior';
 import AssociationBehavior from './AssociationBehavior';
 import AttachEventBehavior from './AttachEventBehavior';
 import BoundaryEventBehavior from './BoundaryEventBehavior';
+import CompensateBoundaryEventBehavior from './CompensateBoundaryEventBehavior';
 import CreateBehavior from './CreateBehavior';
 import CreateDataObjectBehavior from './CreateDataObjectBehavior';
 import CreateParticipantBehavior from './CreateParticipantBehavior';
@@ -47,6 +48,7 @@ export default {
     'associationBehavior',
     'attachEventBehavior',
     'boundaryEventBehavior',
+    'compensateBoundaryEventBehaviour',
     'createBehavior',
     'createDataObjectBehavior',
     'createParticipantBehavior',
@@ -86,6 +88,7 @@ export default {
   associationBehavior: [ 'type', AssociationBehavior ],
   attachEventBehavior: [ 'type', AttachEventBehavior ],
   boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
+  compensateBoundaryEventBehaviour: [ 'type', CompensateBoundaryEventBehavior ],
   createBehavior: [ 'type', CreateBehavior ],
   createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
   createParticipantBehavior: [ 'type', CreateParticipantBehavior ],

package/lib/features/replace/BpmnReplace.js

@@ -204,6 +204,10 @@ export default function BpmnReplace(
         return false;
       }
 
+      if (propertyName === 'isForCompensation') {
+        return !isEventSubProcess(newBusinessObject);
+      }
+
       return true;
     });
 

package/lib/features/rules/BpmnRules.d.ts

@@ -7,6 +7,7 @@ export default class BpmnRules extends RuleProvider {
     canConnectSequenceFlow: typeof canConnectSequenceFlow;
     canConnectDataAssociation: typeof canConnectDataAssociation;
     canConnectAssociation: typeof canConnectAssociation;
+    canConnectCompensationAssociation: typeof canConnectCompensationAssociation;
     canMove: typeof canMove;
     canAttach: typeof canAttach;
     canReplace: typeof canReplace;
@@ -27,7 +28,7 @@ type Point = import('diagram-js/lib/util/Types').Point;
 type Rect = import('diagram-js/lib/util/Types').Rect;
 
 export type CanConnectResult = {
-    associationDirection?: string;
+    associationDirection?: 'None' | 'One' | 'Both';
     type: string;
 } | boolean | null;
 
@@ -70,6 +71,14 @@ declare function canConnectDataAssociation(source: Element, target: Element): Ca
  */
 declare function canConnectAssociation(source: Element, target: Element): CanConnectResult;
 
+/**
+ * @param source
+ * @param target
+ *
+ * @return
+ */
+declare function canConnectCompensationAssociation(source: Element, target: Element): boolean;
+
 /**
  * @param elements
  * @param target

package/lib/features/rules/BpmnRules.js

@@ -50,7 +50,7 @@ import { isConnection } from 'diagram-js/lib/util/ModelUtil';
  * @typedef {import('diagram-js/lib/util/Types').Rect} Rect
  *
  * @typedef { {
- *   associationDirection?: string;
+ *   associationDirection?: 'None' | 'One' | 'Both';
  *   type: string;
  * } | boolean | null } CanConnectResult
  *
@@ -204,6 +204,8 @@ BpmnRules.prototype.canConnectDataAssociation = canConnectDataAssociation;
 
 BpmnRules.prototype.canConnectAssociation = canConnectAssociation;
 
+BpmnRules.prototype.canConnectCompensationAssociation = canConnectCompensationAssociation;
+
 BpmnRules.prototype.canMove = canMove;
 
 BpmnRules.prototype.canAttach = canAttach;
@@ -550,7 +552,7 @@ function canConnect(source, target, connection) {
     return connectDataAssociation;
   }
 
-  if (isCompensationBoundary(source) && isForCompensation(target)) {
+  if (canConnectCompensationAssociation(source, target)) {
     return {
       type: 'bpmn:Association',
       associationDirection: 'One'
@@ -558,9 +560,9 @@ function canConnect(source, target, connection) {
   }
 
   if (canConnectAssociation(source, target)) {
-
     return {
-      type: 'bpmn:Association'
+      type: 'bpmn:Association',
+      associationDirection: 'None'
     };
   }
 
@@ -1027,11 +1029,6 @@ function isOneTextAnnotation(source, target) {
  */
 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;
@@ -1047,6 +1044,22 @@ function canConnectAssociation(source, target) {
   return !!canConnectDataAssociation(source, target);
 }
 
+/**
+ * @param {Element} source
+ * @param {Element} target
+ *
+ * @return {boolean}
+ */
+function canConnectCompensationAssociation(source, target) {
+  return (
+    isSameScope(source, target) &&
+    isCompensationBoundary(source) &&
+    is(target, 'bpmn:Activity') &&
+    !isHostOfElement(target, source) &&
+    !isEventSubProcess(target)
+  );
+}
+
 /**
  * @param {Element} source
  * @param {Element} target
@@ -1172,3 +1185,7 @@ function canCopy(elements, element) {
 function getRootElement(element) {
   return getParent(element, 'bpmn:Process') || getParent(element, 'bpmn:Collaboration');
 }
+
+function isHostOfElement(potentialHost, element) {
+  return potentialHost.attachers.includes(element);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "16.2.0",
+  "version": "16.3.0",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "index.js",
   "files": [