bpmn-js 18.13.0 → 18.13.2

package/lib/features/copy-paste/BpmnCopyPaste.js

@@ -4,6 +4,8 @@ import {
   is
 } from '../../util/ModelUtil';
 
+import { collectElementsAnnotations } from '../../util/AnnotationUtil';
+
 import {
   forEach,
   isArray,
@@ -170,6 +172,21 @@ export default function BpmnCopyPaste(bpmnFactory, eventBus, moddleCopy) {
     }
   });
 
+  eventBus.on('copyPaste.createTree', function(context) {
+    var element = context.element,
+        children = context.children;
+
+    if (!is(element, 'bpmn:SubProcess')) {
+      return;
+    }
+
+    // add TextAnnotations to copy the closure,
+    // since by default they are children of a global process, not subprocess
+    forEach(collectElementsAnnotations(children), (entry) => {
+      children.push(entry.annotation);
+    });
+  });
+
   // resolve references
 
   eventBus.on('copyPaste.pasteElement', LOW_PRIORITY, function(context) {

package/lib/features/modeling/BpmnLayouter.js

@@ -467,17 +467,34 @@ function getBoundaryEventTargetLayout(attachOrientation, targetOrientation, atta
     }
   }
 
-  // attached to either top-right, top-left, bottom-right or bottom-left corner
-  // and orientation is same on the counter-axis
+  // attached to either top-right, top-left, bottom-right or bottom-left corner,
+  // or strictly above/below or left/right of the target. In the corner case,
+  // the orientation is compared on the counter-axis to decide the layout.
+
+  var verticalAttachOrientation = getVerticalOrientation(attachOrientation),
+      horizontalAttachOrientation = getHorizontalOrientation(attachOrientation),
+      verticalTargetOrientation = getVerticalOrientation(targetOrientation),
+      horizontalTargetOrientation = getHorizontalOrientation(targetOrientation);
+
+  // If the target is strictly above/below (no horizontal orientation)
+  if (verticalTargetOrientation && !horizontalTargetOrientation) {
+    return 'v';
+  }
+
+  // If the target is strictly left/right (no vertical orientation)
+  if (horizontalTargetOrientation && !verticalTargetOrientation) {
+    return 'h';
+  }
+
 
   if (isHorizontal) {
-    if (isSame(getVerticalOrientation(attachOrientation), getVerticalOrientation(targetOrientation))) {
+    if (isSame(verticalAttachOrientation, verticalTargetOrientation)) {
       return 'h';
     } else {
       return 'v';
     }
   } else {
-    if (isSame(getHorizontalOrientation(attachOrientation), getHorizontalOrientation(targetOrientation))) {
+    if (isSame(horizontalAttachOrientation, horizontalTargetOrientation)) {
       return 'v';
     } else {
       return 'h';

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

@@ -2,15 +2,20 @@ import inherits from 'inherits-browser';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-import { find } from 'min-dash';
+import { find, forEach } from 'min-dash';
 
 import { isExpanded } from '../../../util/DiUtil';
 
+import {
+  collectElementsAnnotations,
+  getElementAnnotations
+} from '../../../util/AnnotationUtil';
+
 import { getBusinessObject, getDi, is } from '../../../util/ModelUtil';
 
 import { getMid } from 'diagram-js/lib/layout/LayoutUtil';
 
-import { getBBox } from 'diagram-js/lib/util/Elements';
+import { getBBox, selfAndChildren } from 'diagram-js/lib/util/Elements';
 
 import {
   getPlaneIdFromShape,
@@ -41,7 +46,6 @@ var DEFAULT_POSITION = {
   y: 160
 };
 
-
 /**
  * Creates bpmndi:BPMNPlane elements and canvas planes when collapsed subprocesses are created.
  *
@@ -107,17 +111,26 @@ export default function SubProcessPlaneBehavior(
   }, true);
 
 
-  this.postExecuted('shape.create', function(context) {
-    var shape = context.shape,
-        rootElement = context.newRootElement;
+  this.postExecuted('elements.create', function(context) {
+    var elements = context.elements;
 
-    if (!rootElement || !shape.children) {
-      return;
-    }
+    forEach(elements, function(element) {
+      if (!isCollapsedSubProcess(element)) {
+        return;
+      }
+
+      var rootElement = elementRegistry.get(getPlaneIdFromShape(element));
+
+      if (!rootElement || !element.children || !element.children.length) {
+        return;
+      }
 
-    self._showRecursively(shape.children);
+      var children = getSubProcessChildren(element);
 
-    self._moveChildrenToShape(shape, rootElement);
+      self._showRecursively(children);
+
+      self._moveChildrenToShape(children, rootElement);
+    });
   }, true);
 
 
@@ -131,6 +144,20 @@ export default function SubProcessPlaneBehavior(
   }, true);
 
 
+  // remove annotations connected to elements inside the subprocess
+  this.preExecute('shape.delete', function(context) {
+    var shape = context.shape;
+
+    if (!is(shape, 'bpmn:SubProcess') || !isExpanded(shape)) {
+      return;
+    }
+
+    forEach(collectElementsAnnotations([ shape ]), (entry) => {
+      modeling.removeShape(entry.annotation);
+    });
+  }, true);
+
+
   this.preExecuted('shape.delete', function(context) {
     var shape = context.shape;
     if (!isCollapsedSubProcess(shape)) {
@@ -336,11 +363,27 @@ export default function SubProcessPlaneBehavior(
 
     if (!isExpanded(shape)) {
 
-      // collapsed
-      self._moveChildrenToShape(shape, rootElement);
+      // if an annotation is attached to both the sub-process and elements inside it,
+      // remove the inner associations, keeping only connections at the sub-process level,
+      // since we can't keep both after collapsing
+      self._disconnectSharedAnnotations(shape);
+
+      var children = getSubProcessChildren(shape);
+
+      self._moveChildrenToShape(children, rootElement);
 
     } else {
-      self._moveChildrenToShape(rootElement, shape);
+      self._moveChildrenToShape(rootElement.children.slice(), shape);
+
+      // annotations live at process level by design;
+      // move them back from the sub-process to the process root
+      forEach(collectElementsAnnotations(shape.children), (entry) => {
+        modeling.moveShape(entry.annotation, { x: 0, y: 0 }, shape.parent);
+
+        forEach(entry.associations, (association) => {
+          modeling.moveConnection(association, { x: 0, y: 0 }, shape.parent);
+        });
+      });
     }
   }, true);
 
@@ -410,33 +453,21 @@ export default function SubProcessPlaneBehavior(
 inherits(SubProcessPlaneBehavior, CommandInterceptor);
 
 /**
- * Moves the child elements from source to target.
+ * Moves the given elements to the target.
  *
  * If the target is a plane, the children are moved to the top left corner.
  * Otherwise, the center of the target is used.
  *
- * @param {Root} source
+ * @param {Element[]} children
  * @param {Root} target
  */
-SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(source, target) {
+SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(children, target) {
   var modeling = this._modeling;
 
-  var children = source.children;
-  var offset;
-
-  if (!children) {
+  if (!children.length) {
     return;
   }
 
-  // add external labels that weren't children of sub process
-  children = children.concat(children.reduce(function(labels, child) {
-    if (child.label && child.label.parent !== source) {
-      return labels.concat(child.label);
-    }
-
-    return labels;
-  }, []));
-
   // only change plane if there are no visible children, but don't move them
   var visibleChildren = children.filter(function(child) {
     return !child.hidden;
@@ -448,6 +479,7 @@ SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(source, target
   }
 
   var childrenBounds = getBBox(visibleChildren);
+  var offset;
 
   // target is a plane
   if (!target.x) {
@@ -473,6 +505,32 @@ SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(source, target
   modeling.moveElements(children, offset, target, { autoResize: false });
 };
 
+/**
+ * Remove all associations between inner elements and annotations that are
+ * also connected to the sub-process itself.
+ *
+ * @param {Element} shape
+ */
+SubProcessPlaneBehavior.prototype._disconnectSharedAnnotations = function(shape) {
+  var modeling = this._modeling;
+
+  var sharedAnnotations = new Set(
+    getElementAnnotations(shape).map((entry) => entry.annotation)
+  );
+
+  if (!sharedAnnotations.size) {
+    return;
+  }
+
+  forEach(collectElementsAnnotations(shape.children), (entry) => {
+    if (sharedAnnotations.has(entry.annotation)) {
+      forEach(entry.associations, (association) => {
+        modeling.removeConnection(association);
+      });
+    }
+  });
+};
+
 /**
  * Sets `hidden` property on all children of the given shape.
  *
@@ -586,3 +644,55 @@ SubProcessPlaneBehavior.$inject = [
   'bpmnjs',
   'elementRegistry'
 ];
+
+/**
+ * Collect text annotations and their associations connected to the given elements.
+ *
+ * @param {Element[]} elements
+ *
+ * @return {Element[]}
+ */
+function collectAnnotationElements(elements) {
+  var result = [];
+
+  forEach(collectElementsAnnotations(elements), (entry) => {
+    result.push(entry.annotation);
+    result.push.apply(result, entry.associations);
+  });
+
+  return result;
+}
+
+/**
+ * Collect all children of a collapsed subprocess that need to be moved
+ * to or from its plane, including annotations and external labels that
+ * live at the process level by design(ref: https://github.com/camunda/camunda-modeler/issues/5163#issuecomment-3946571271)
+ *
+ * @param {Element} element
+ *
+ * @return {Element[]}
+ */
+function getSubProcessChildren(element) {
+  return element.children.slice()
+    .concat(collectAnnotationElements(element.children))
+    .concat(getExternalLabels(element));
+}
+
+/**
+ * Returns external labels of the given element's children and their descendants
+ * that are not direct children of the element (i.e. parented elsewhere).
+ *
+ * @param {Element} element
+ *
+ * @return {Element[]}
+ */
+function getExternalLabels(element) {
+  return selfAndChildren(element.children || [], true, -1)
+    .reduce(function(labels, child) {
+      if (child.label && child.label.parent !== element) {
+        labels.push(child.label);
+      }
+      return labels;
+    }, []);
+}
+

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

@@ -12,6 +12,8 @@ import { selfAndAllChildren } from 'diagram-js/lib/util/Elements';
 
 import { isExpanded } from '../../../util/DiUtil';
 
+import { is } from '../../../util/ModelUtil';
+
 /**
  * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
  * @typedef {import('../Modeling').default} Modeling
@@ -34,7 +36,6 @@ export default function ToggleCollapseConnectionBehaviour(
 
   this.postExecuted('shape.toggleCollapse', 1500, function(context) {
 
-    // var shape = context.shape;
     var shape = context.shape;
 
     // only change connections when collapsing
@@ -65,6 +66,12 @@ export default function ToggleCollapseConnectionBehaviour(
         return;
       }
 
+      // don't reconnect TextAnnotation connections,
+      // since they should stay connected and moved with its element to the subprocess plane
+      if (is(c, 'bpmn:Association') && (is(c.source, 'bpmn:TextAnnotation') || is(c.target, 'bpmn:TextAnnotation'))) {
+        return;
+      }
+
       if (incoming) {
         modeling.reconnectEnd(c, shape, getMid(shape));
       } else {

package/lib/util/AnnotationUtil.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Get text annotations connected to the given element.
+ *
+ * @param element
+ *
+ * @return
+ */
+export function getElementAnnotations(element: Element): {
+    annotation: Element;
+    association: Element;
+}[];
+
+/**
+ * Recursively collect text annotations connected to the given elements and their descendants.
+ * De-duplicates by annotation, collecting all associations per annotation.
+ *
+ * @param elements
+ *
+ * @return
+ */
+export function collectElementsAnnotations(elements: Element[]): {
+    annotation: Element;
+    associations: Element[];
+}[];
+
+type Element = import("../model/Types").Element;

package/lib/util/AnnotationUtil.js

@@ -0,0 +1,55 @@
+import { forEach } from 'min-dash';
+import { selfAndChildren } from 'diagram-js/lib/util/Elements';
+import { is } from './ModelUtil';
+
+/**
+ * @typedef { import('../model/Types').Element } Element
+ */
+
+/**
+ * Get text annotations connected to the given element.
+ *
+ * @param {Element} element
+ *
+ * @return { { annotation: Element, association: Element }[] }
+ */
+export function getElementAnnotations(element) {
+  let result = [];
+
+  forEach(element.incoming, (connection) => {
+    if (is(connection, 'bpmn:Association') && is(connection.source, 'bpmn:TextAnnotation')) {
+      result.push({ annotation: connection.source, association: connection });
+    }
+  });
+
+  forEach(element.outgoing, (connection) => {
+    if (is(connection, 'bpmn:Association') && is(connection.target, 'bpmn:TextAnnotation')) {
+      result.push({ annotation: connection.target, association: connection });
+    }
+  });
+
+  return result;
+}
+
+/**
+ * Recursively collect text annotations connected to the given elements and their descendants.
+ * De-duplicates by annotation, collecting all associations per annotation.
+ *
+ * @param {Element[]} elements
+ *
+ * @return { { annotation: Element, associations: Element[] }[] }
+ */
+export function collectElementsAnnotations(elements) {
+  const result = new Map();
+
+  forEach(selfAndChildren(elements, true, -1), (element) => {
+    forEach(getElementAnnotations(element), (entry) => {
+      if (!result.has(entry.annotation)) {
+        result.set(entry.annotation, { annotation: entry.annotation, associations: [] });
+      }
+      result.get(entry.annotation).associations.push(entry.association);
+    });
+  });
+
+  return [ ...result.values() ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "18.13.0",
+  "version": "18.13.2",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "lib/index.js",
   "files": [
@@ -69,7 +69,7 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-replace": "^6.0.3",
-    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-terser": "^1.0.0",
     "babel-loader": "^10.0.0",
     "babel-plugin-istanbul": "^7.0.1",
     "bio-dts": "^0.11.0",
@@ -111,7 +111,7 @@
   },
   "dependencies": {
     "bpmn-moddle": "^10.0.0",
-    "diagram-js": "^15.9.0",
+    "diagram-js": "^15.10.0",
     "diagram-js-direct-editing": "^3.3.0",
     "ids": "^3.0.0",
     "inherits-browser": "^0.1.0",