bpmn-js 9.3.2 → 9.4.0

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

@@ -2,21 +2,21 @@ import inherits from 'inherits-browser';
 
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
-import {
-  add as collectionAdd,
-  remove as collectionRemove
-} from 'diagram-js/lib/util/Collections';
-
 import {
   getBusinessObject,
   is
 } from '../../../util/ModelUtil';
 
 import {
-  createCategoryValue
+  createCategory,
+  createCategoryValue,
+  linkCategoryValue,
+  unlinkCategory,
+  unlinkCategoryValue
 } from './util/CategoryUtil';
 
-var HIGH_PRIORITY = 2000;
+
+var LOWER_PRIORITY = 770;
 
 
 /**
@@ -33,156 +33,268 @@ export default function GroupBehavior(
   injector.invoke(CommandInterceptor, this);
 
   /**
-   * Removes a referenced category value for a given group shape
+   * Returns all group element in the current registry
    *
-   * @param {djs.model.Shape} shape
+   * @return {Array<djs.model.shape>} a list of group shapes
    */
-  function removeReferencedCategoryValue(shape) {
-
-    var businessObject = getBusinessObject(shape),
-        categoryValue = businessObject.categoryValueRef;
-
-    if (!categoryValue) {
-      return;
-    }
-
-    var category = categoryValue.$parent;
-
-    if (!categoryValue) {
-      return;
-    }
-
-    collectionRemove(category.categoryValue, categoryValue);
-
-    // cleanup category if it is empty
-    if (category && !category.categoryValue.length) {
-      removeCategory(category);
-    }
+  function getGroupElements() {
+    return elementRegistry.filter(function(e) {
+      return is(e, 'bpmn:Group');
+    });
   }
 
   /**
-   * Removes a given category from the definitions
+   * Returns true if given category is referenced in one of the given elements
    *
-   * @param {ModdleElement} category
+   * @param { djs.model.Element[] } elements
+   * @param { ModdleElement } category
+   *
+   * @return { boolean }
    */
-  function removeCategory(category) {
+  function isReferencedCategory(elements, category) {
+    return elements.some(function(element) {
+      var businessObject = getBusinessObject(element);
 
-    var definitions = bpmnjs.getDefinitions();
+      var _category = businessObject.categoryValueRef && businessObject.categoryValueRef.$parent;
 
-    collectionRemove(definitions.get('rootElements'), category);
+      return _category === category;
+    });
   }
 
   /**
-   * Returns all group element in the current registry
+   * Returns true if given categoryValue is referenced in one of the given elements
    *
-   * @return {Array<djs.model.shape>} a list of group shapes
+   * @param { djs.model.Element[] } elements
+   * @param { ModdleElement } categoryValue
+   *
+   * @return { boolean }
    */
-  function getGroupElements() {
-    return elementRegistry.filter(function(e) {
-      return is(e, 'bpmn:Group');
+  function isReferencedCategoryValue(elements, categoryValue) {
+    return elements.some(function(element) {
+      var businessObject = getBusinessObject(element);
+
+      return businessObject.categoryValueRef === categoryValue;
     });
   }
 
   /**
-   * Returns true if given categoryValue is referenced in one of the given elements
+   * Remove category value unless it is still referenced
    *
-   * @param {Array<djs.model.shape>} elements
    * @param {ModdleElement} categoryValue
-   * @return {boolean}
+   * @param {ModdleElement} category
+   * @param {ModdleElement} businessObject
    */
-  function isReferenced(elements, categoryValue) {
-    return elements.some(function(e) {
-
-      var businessObject = getBusinessObject(e);
+  function removeCategoryValue(categoryValue, category, businessObject) {
 
-      return businessObject.categoryValueRef
-        && businessObject.categoryValueRef === categoryValue;
+    var groups = getGroupElements().filter(function(element) {
+      return element.businessObject !== businessObject;
     });
+
+    if (category && !isReferencedCategory(groups, category)) {
+      unlinkCategory(category);
+    }
+
+    if (categoryValue && !isReferencedCategoryValue(groups, categoryValue)) {
+      unlinkCategoryValue(categoryValue);
+    }
   }
 
   /**
-   * remove referenced category + value when group was deleted
+   * Add category value
+   *
+   * @param {ModdleElement} categoryValue
+   * @param {ModdleElement} category
    */
-  this.executed('shape.delete', function(event) {
+  function addCategoryValue(categoryValue, category) {
+    return linkCategoryValue(categoryValue, category, bpmnjs.getDefinitions());
+  }
 
-    var context = event.context,
-        shape = context.shape;
+  function setCategoryValue(element, context) {
+    var businessObject = getBusinessObject(element),
+        categoryValue = businessObject.categoryValueRef;
 
-    if (is(shape, 'bpmn:Group')) {
+    if (!categoryValue) {
+      categoryValue =
+      businessObject.categoryValueRef =
+      context.categoryValue = (
+        context.categoryValue || createCategoryValue(bpmnFactory)
+      );
+    }
 
-      var businessObject = getBusinessObject(shape),
-          categoryValueRef = businessObject.categoryValueRef,
-          groupElements = getGroupElements();
+    var category = categoryValue.$parent;
 
-      if (!isReferenced(groupElements, categoryValueRef)) {
-        removeReferencedCategoryValue(shape);
-      }
+    if (!category) {
+      category =
+      categoryValue.$parent =
+      context.category = (
+        context.category || createCategory(bpmnFactory)
+      );
     }
-  });
 
-  /**
-   * re-attach removed category
-   */
-  this.reverted('shape.delete', function(event) {
+    addCategoryValue(categoryValue, category, bpmnjs.getDefinitions());
+  }
+
+  function unsetCategoryValue(element, context) {
+    var category = context.category,
+        categoryValue = context.categoryValue,
+        businessObject = getBusinessObject(element);
+
+    if (categoryValue) {
+      businessObject.categoryValueRef = null;
+
+      removeCategoryValue(categoryValue, category, businessObject);
+    } else {
+      removeCategoryValue(null, businessObject.categoryValueRef.$parent, businessObject);
+    }
+  }
+
 
+  // ensure category + value exist before label editing
+
+  this.execute('label.create', function(event) {
     var context = event.context,
-        shape = context.shape;
+        labelTarget = context.labelTarget;
+
+    if (!is(labelTarget, 'bpmn:Group')) {
+      return;
+    }
 
-    if (is(shape, 'bpmn:Group')) {
+    setCategoryValue(labelTarget, context);
+  });
 
-      var businessObject = getBusinessObject(shape),
-          categoryValueRef = businessObject.categoryValueRef,
-          definitions = bpmnjs.getDefinitions(),
-          category = categoryValueRef ? categoryValueRef.$parent : null;
+  this.revert('label.create', function(event) {
+    var context = event.context,
+        labelTarget = context.labelTarget;
 
-      collectionAdd(category.get('categoryValue'), categoryValueRef);
-      collectionAdd(definitions.get('rootElements'), category);
+    if (!is(labelTarget, 'bpmn:Group')) {
+      return;
     }
+
+    unsetCategoryValue(labelTarget, context);
   });
 
-  /**
-   * create new category + value when group was created
-   */
-  this.execute('shape.create', function(event) {
+
+  // remove referenced category + value when group was deleted
+
+  this.execute('shape.delete', function(event) {
+
     var context = event.context,
         shape = context.shape,
         businessObject = getBusinessObject(shape);
 
-    if (is(businessObject, 'bpmn:Group') && !businessObject.categoryValueRef) {
+    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+      return;
+    }
+
+    var categoryValue = context.categoryValue = businessObject.categoryValueRef,
+        category;
+
+    if (categoryValue) {
+      category = context.category = categoryValue.$parent;
+
+      removeCategoryValue(categoryValue, category, businessObject);
+
+      businessObject.categoryValueRef = null;
+    }
+  });
+
+  this.reverted('shape.delete', function(event) {
+
+    var context = event.context,
+        shape = context.shape;
 
-      var definitions = bpmnjs.getDefinitions(),
-          categoryValue = createCategoryValue(definitions, bpmnFactory);
+    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+      return;
+    }
+
+    var category = context.category,
+        categoryValue = context.categoryValue,
+        businessObject = getBusinessObject(shape);
 
-      // link the reference to the Group
+    if (categoryValue) {
       businessObject.categoryValueRef = categoryValue;
+
+      addCategoryValue(categoryValue, category);
     }
   });
 
 
-  this.revert('shape.create', function(event) {
+  // create new category + value when group was created
+
+  this.execute('shape.create', function(event) {
+    var context = event.context,
+        shape = context.shape;
+
+    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+      return;
+    }
+
+    if (getBusinessObject(shape).categoryValueRef) {
+      setCategoryValue(shape, context);
+    }
+  });
+
+  this.reverted('shape.create', function(event) {
 
     var context = event.context,
         shape = context.shape;
 
-    if (is(shape, 'bpmn:Group')) {
-      removeReferencedCategoryValue(shape);
+    if (!is(shape, 'bpmn:Group') || shape.labelTarget) {
+      return;
+    }
+
+    if (getBusinessObject(shape).categoryValueRef) {
+      unsetCategoryValue(shape, context);
+    }
+  });
+
+
+  // copy + paste categoryValueRef with group
+
+  function copy(bo, clone) {
+    var targetBo = bpmnFactory.create(bo.$type);
+
+    return moddleCopy.copyElement(bo, targetBo, null, clone);
+  }
+
+  eventBus.on('copyPaste.copyElement', LOWER_PRIORITY, function(context) {
+    var descriptor = context.descriptor,
+        element = context.element;
+
+    if (!is(element, 'bpmn:Group') || element.labelTarget) {
+      return;
+    }
+
+    var groupBo = getBusinessObject(element);
+
+    if (groupBo.categoryValueRef) {
 
-      delete getBusinessObject(shape).categoryValueRef;
+      var categoryValue = groupBo.categoryValueRef;
 
+      descriptor.categoryValue = copy(categoryValue, true);
+
+      if (categoryValue.$parent) {
+        descriptor.category = copy(categoryValue.$parent, true);
+      }
     }
   });
 
-  // copy bpmn:CategoryValue when copying element
-  eventBus.on('moddleCopy.canCopyProperty', HIGH_PRIORITY, function(context) {
-    var property = context.property,
-        categoryValue;
+  eventBus.on('copyPaste.pasteElement', LOWER_PRIORITY, function(context) {
+    var descriptor = context.descriptor,
+        businessObject = descriptor.businessObject,
+        categoryValue = descriptor.categoryValue,
+        category = descriptor.category;
 
-    if (is(property, 'bpmn:CategoryValue')) {
-      categoryValue = createCategoryValue(bpmnjs.getDefinitions(), bpmnFactory);
+    if (categoryValue) {
+      categoryValue = businessObject.categoryValueRef = copy(categoryValue);
+    }
 
-      // return copy of category
-      return moddleCopy.copyElement(property, categoryValue);
+    if (category) {
+      categoryValue.$parent = copy(category);
     }
+
+    delete descriptor.category;
+    delete descriptor.categoryValue;
   });
 
 }

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

@@ -13,6 +13,8 @@ import {
 
 var HIGH_PRIORITY = 1500;
 
+export var GROUP_MIN_DIMENSIONS = { width: 140, height: 120 };
+
 export var LANE_MIN_DIMENSIONS = { width: 300, height: 60 };
 
 export var PARTICIPANT_MIN_DIMENSIONS = { width: 300, height: 150 };

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

@@ -125,7 +125,7 @@ export default function RootElementReferenceBehavior(
     var descriptor = context.descriptor,
         element = context.element;
 
-    if (!canHaveRootElementReference(element)) {
+    if (element.labelTarget || !canHaveRootElementReference(element)) {
       return;
     }
 
@@ -133,19 +133,16 @@ export default function RootElementReferenceBehavior(
         rootElement = getRootElement(businessObject);
 
     if (rootElement) {
+
+      // TODO(nikku): clone on copy
       descriptor.referencedRootElement = rootElement;
     }
   });
 
   eventBus.on('copyPaste.pasteElement', LOW_PRIORITY, function(context) {
     var descriptor = context.descriptor,
-        businessObject = descriptor.businessObject;
-
-    if (!canHaveRootElementReference(businessObject)) {
-      return;
-    }
-
-    var referencedRootElement = descriptor.referencedRootElement;
+        businessObject = descriptor.businessObject,
+        referencedRootElement = descriptor.referencedRootElement;
 
     if (!referencedRootElement) {
       return;
@@ -159,6 +156,8 @@ export default function RootElementReferenceBehavior(
     }
 
     setRootElement(businessObject, referencedRootElement);
+
+    delete descriptor.referencedRootElement;
   });
 }
 

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

@@ -5,6 +5,7 @@ import { is } from '../../../util/ModelUtil';
 import { isExpanded } from '../../../util/DiUtil';
 
 import {
+  GROUP_MIN_DIMENSIONS,
   LANE_MIN_DIMENSIONS,
   PARTICIPANT_MIN_DIMENSIONS,
   SUB_PROCESS_MIN_DIMENSIONS,
@@ -46,6 +47,10 @@ export default function SpaceToolBehavior(eventBus) {
       if (is(shape, 'bpmn:TextAnnotation')) {
         minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
       }
+
+      if (is(shape, 'bpmn:Group')) {
+        minDimensions[ id ] = GROUP_MIN_DIMENSIONS;
+      }
     });
 
     return minDimensions;

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

@@ -411,6 +411,15 @@ SubProcessPlaneBehavior.prototype._moveChildrenToShape = function(source, target
     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;

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

@@ -101,7 +101,7 @@ export default {
   messageFlowBehavior: [ 'type', MessageFlowBehavior ],
   modelingFeedback: [ 'type', ModelingFeedback ],
   removeElementBehavior: [ 'type', RemoveElementBehavior ],
-  removeEmbeddedLabelBoundsBehavior: ['type', RemoveEmbeddedLabelBoundsBehavior ],
+  removeEmbeddedLabelBoundsBehavior: [ 'type', RemoveEmbeddedLabelBoundsBehavior ],
   removeParticipantBehavior: [ 'type', RemoveParticipantBehavior ],
   replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
   replaceElementBehaviour: [ 'type', ReplaceElementBehaviour ],

package/lib/features/modeling/behavior/util/CategoryUtil.js

@@ -1,30 +1,83 @@
 import {
-  add as collectionAdd
+  add as collectionAdd,
+  remove as collectionRemove
 } from 'diagram-js/lib/util/Collections';
 
-import {
-  getBusinessObject
-} from '../../../../util/ModelUtil';
 
 /**
  * Creates a new bpmn:CategoryValue inside a new bpmn:Category
  *
- * @param {ModdleElement} definitions
  * @param {BpmnFactory} bpmnFactory
  *
  * @return {ModdleElement} categoryValue.
  */
-export function createCategoryValue(definitions, bpmnFactory) {
-  var categoryValue = bpmnFactory.create('bpmn:CategoryValue'),
-      category = bpmnFactory.create('bpmn:Category', {
-        categoryValue: [ categoryValue ]
-      });
+export function createCategory(bpmnFactory) {
+  return bpmnFactory.create('bpmn:Category');
+}
+
+/**
+ * Creates a new bpmn:CategoryValue inside a new bpmn:Category
+ *
+ * @param {BpmnFactory} bpmnFactory
+ *
+ * @return {ModdleElement} categoryValue.
+ */
+export function createCategoryValue(bpmnFactory) {
+  return bpmnFactory.create('bpmn:CategoryValue');
+}
+
+/**
+ * Adds category value to definitions
+ *
+ * @param {ModdleElement} categoryValue
+ * @param {ModdleElement} category
+ * @param {ModdleElement} definitions
+ *
+ * @return {ModdleElement} categoryValue
+ */
+export function linkCategoryValue(categoryValue, category, definitions) {
+  collectionAdd(category.get('categoryValue'), categoryValue);
+  categoryValue.$parent = category;
 
-  // add to correct place
   collectionAdd(definitions.get('rootElements'), category);
-  getBusinessObject(category).$parent = definitions;
-  getBusinessObject(categoryValue).$parent = category;
+  category.$parent = definitions;
 
   return categoryValue;
+}
+
+/**
+ * Unlink category value from parent
+ *
+ * @param {ModdleElement} categoryValue
+ *
+ * @return {ModdleElement} categoryValue
+ */
+export function unlinkCategoryValue(categoryValue) {
+  var category = categoryValue.$parent;
+
+  if (category) {
+    collectionRemove(category.get('categoryValue'), categoryValue);
+    categoryValue.$parent = null;
+  }
+
+  return categoryValue;
+}
+
+/**
+ * Unlink category from parent
+ *
+ * @param {ModdleElement} category
+ * @param {ModdleElement} definitions
+ *
+ * @return {ModdleElement} categoryValue
+ */
+export function unlinkCategory(category) {
+  var definitions = category.$parent;
+
+  if (definitions) {
+    collectionRemove(definitions.get('rootElements'), category);
+    category.$parent = null;
+  }
 
+  return category;
 }

package/lib/features/modeling/behavior/util/LayoutUtil.js

@@ -32,7 +32,7 @@ export function findNewLineStartIndex(oldWaypoints, newWaypoints, attachment, hi
 
     // point is after new segment index
     if (index >= newSegmentStartIndex) {
-      return (index+offset < newSegmentStartIndex) ? newSegmentStartIndex : index+offset;
+      return (index + offset < newSegmentStartIndex) ? newSegmentStartIndex : index + offset;
     }
 
     // if point is before new segment index
@@ -62,7 +62,7 @@ export function findNewLineStartIndex(oldWaypoints, newWaypoints, attachment, hi
       newIndex = index;
 
       // decide point should take right or left segment
-      if (insert && attachment.type !== 'bendpoint' && bendpointIndex-1 === index) {
+      if (insert && attachment.type !== 'bendpoint' && bendpointIndex - 1 === index) {
 
         var rel = relativePositionMidWaypoint(newWaypoints, bendpointIndex);
 
@@ -89,7 +89,7 @@ export function findNewLineStartIndex(oldWaypoints, newWaypoints, attachment, hi
   }
 
   // if nothing fits, take the middle segment
-  return Math.floor((newWaypoints.length - 2)/2);
+  return Math.floor((newWaypoints.length - 2) / 2);
 }
 
 
@@ -203,8 +203,8 @@ export function getAnchorPointAdjustment(position, newWaypoints, oldWaypoints, h
 
 function relativePositionMidWaypoint(waypoints, idx) {
 
-  var distanceSegment1 = getDistancePointPoint(waypoints[idx-1], waypoints[idx]),
-      distanceSegment2 = getDistancePointPoint(waypoints[idx], waypoints[idx+1]);
+  var distanceSegment1 = getDistancePointPoint(waypoints[idx - 1], waypoints[idx]),
+      distanceSegment2 = getDistancePointPoint(waypoints[idx], waypoints[idx + 1]);
 
   var relativePosition = distanceSegment1 / (distanceSegment1 + distanceSegment2);
 
@@ -218,7 +218,7 @@ function getAngleDelta(l1, l2) {
 }
 
 function getLine(waypoints, idx) {
-  return [ waypoints[idx], waypoints[idx+1] ];
+  return [ waypoints[idx], waypoints[idx + 1] ];
 }
 
 function getRelativeFootPosition(line, foot) {

package/lib/features/modeling/cmd/UpdateModdlePropertiesHandler.js

@@ -13,7 +13,7 @@ export default function UpdateModdlePropertiesHandler(elementRegistry) {
   this._elementRegistry = elementRegistry;
 }
 
-UpdateModdlePropertiesHandler.$inject = ['elementRegistry'];
+UpdateModdlePropertiesHandler.$inject = [ 'elementRegistry' ];
 
 UpdateModdlePropertiesHandler.prototype.execute = function(context) {
 
@@ -25,6 +25,9 @@ UpdateModdlePropertiesHandler.prototype.execute = function(context) {
     throw new Error('<moddleElement> required');
   }
 
+  // TODO(nikku): we need to ensure that ID properties
+  // are properly registered / unregistered via
+  // this._moddle.ids.assigned(id)
   var changed = context.changed || this.getVisualReferences(moddleElement).concat(element);
   var oldProperties = context.oldProperties || getModdleProperties(moddleElement, keys(properties));
 

package/lib/features/ordering/BpmnOrderingProvider.js

@@ -24,10 +24,12 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
 
   var orders = [
     { type: 'bpmn:SubProcess', order: { level: 6 } },
+
+    // handle SequenceFlow(s) like message flows and render them always on top
     {
       type: 'bpmn:SequenceFlow',
       order: {
-        level: 3,
+        level: 9,
         containers: [
           'bpmn:Participant',
           'bpmn:FlowElementsContainer'

package/lib/features/replace/BpmnReplace.js

@@ -199,6 +199,18 @@ export default function BpmnReplace(
       // else if property is explicitly set, use it
       else if (target && has(target, 'isExpanded')) {
         newElement.isExpanded = target.isExpanded;
+
+        // assign default size of new expanded element
+        var defaultSize = elementFactory.getDefaultSize(newBusinessObject, {
+          isExpanded: newElement.isExpanded
+        });
+
+        newElement.width = defaultSize.width;
+        newElement.height = defaultSize.height;
+
+        // keep element centered
+        newElement.x = element.x - (newElement.width - element.width) / 2;
+        newElement.y = element.y - (newElement.height - element.height) / 2;
       }
 
       // TODO: need also to respect min/max Size