bpmn-js 16.3.2 → 16.4.0

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

@@ -1,139 +1,207 @@
-import { forEach } from 'min-dash';
-
-import { is } from '../../../util/ModelUtil';
-
-import { isExpanded } from '../../../util/DiUtil';
-
-import {
-  GROUP_MIN_DIMENSIONS,
-  LANE_MIN_DIMENSIONS,
-  PARTICIPANT_MIN_DIMENSIONS,
-  SUB_PROCESS_MIN_DIMENSIONS,
-  TEXT_ANNOTATION_MIN_DIMENSIONS
-} from './ResizeBehavior';
-
-import { getChildLanes } from '../util/LaneUtil';
-
-/**
- * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
- *
- * @typedef {import('../../../model/Types').Shape} Shape
- */
-
-var max = Math.max;
-
-/**
- * @param {EventBus} eventBus
- */
-export default function SpaceToolBehavior(eventBus) {
-  eventBus.on('spaceTool.getMinDimensions', function(context) {
-    var shapes = context.shapes,
-        axis = context.axis,
-        start = context.start,
-        minDimensions = {};
-
-    forEach(shapes, function(shape) {
-      var id = shape.id;
-
-      if (is(shape, 'bpmn:Participant')) {
-
-        if (isHorizontal(axis)) {
-          minDimensions[ id ] = PARTICIPANT_MIN_DIMENSIONS;
-        } else {
-          minDimensions[ id ] = {
-            width: PARTICIPANT_MIN_DIMENSIONS.width,
-            height: getParticipantMinHeight(shape, start)
-          };
-        }
-
-      }
-
-      if (is(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
-        minDimensions[ id ] = SUB_PROCESS_MIN_DIMENSIONS;
-      }
-
-      if (is(shape, 'bpmn:TextAnnotation')) {
-        minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
-      }
-
-      if (is(shape, 'bpmn:Group')) {
-        minDimensions[ id ] = GROUP_MIN_DIMENSIONS;
-      }
-    });
-
-    return minDimensions;
-  });
-}
-
-SpaceToolBehavior.$inject = [ 'eventBus' ];
-
-
-// helpers //////////
-function isHorizontal(axis) {
-  return axis === 'x';
-}
-
-/**
- * Get minimum height for participant taking lanes into account.
- *
- * @param {Shape} participant
- * @param {number} start
- *
- * @return {number}
- */
-function getParticipantMinHeight(participant, start) {
-  var lanesMinHeight;
-
-  if (!hasChildLanes(participant)) {
-    return PARTICIPANT_MIN_DIMENSIONS.height;
-  }
-
-  lanesMinHeight = getLanesMinHeight(participant, start);
-
-  return max(PARTICIPANT_MIN_DIMENSIONS.height, lanesMinHeight);
-}
-
-function hasChildLanes(element) {
-  return !!getChildLanes(element).length;
-}
-
-function getLanesMinHeight(participant, resizeStart) {
-  var lanes = getChildLanes(participant),
-      resizedLane;
-
-  // find the nested lane which is currently resized
-  resizedLane = findResizedLane(lanes, resizeStart);
-
-  // resized lane cannot shrink below the minimum height
-  // but remaining lanes' dimensions are kept intact
-  return participant.height - resizedLane.height + LANE_MIN_DIMENSIONS.height;
-}
-
-/**
- * Find nested lane which is currently resized.
- *
- * @param {Shape[]} lanes
- * @param {number} resizeStart
- *
- * @return {Shape}
- */
-function findResizedLane(lanes, resizeStart) {
-  var i, lane, childLanes;
-
-  for (i = 0; i < lanes.length; i++) {
-    lane = lanes[i];
-
-    // resizing current lane or a lane nested
-    if (resizeStart >= lane.y && resizeStart <= lane.y + lane.height) {
-      childLanes = getChildLanes(lane);
-
-      // a nested lane is resized
-      if (childLanes.length) {
-        return findResizedLane(childLanes, resizeStart);
-      }
-
-      // current lane is the resized one
-      return lane;
-    }
-  }
-}
+import { forEach } from 'min-dash';
+
+import { is } from '../../../util/ModelUtil';
+
+import {
+  isExpanded,
+  isHorizontal
+} from '../../../util/DiUtil';
+
+import {
+  GROUP_MIN_DIMENSIONS,
+  LANE_MIN_DIMENSIONS,
+  VERTICAL_LANE_MIN_DIMENSIONS,
+  PARTICIPANT_MIN_DIMENSIONS,
+  VERTICAL_PARTICIPANT_MIN_DIMENSIONS,
+  SUB_PROCESS_MIN_DIMENSIONS,
+  TEXT_ANNOTATION_MIN_DIMENSIONS
+} from './ResizeBehavior';
+
+import { getChildLanes } from '../util/LaneUtil';
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ *
+ * @typedef {import('../../../model/Types').Shape} Shape
+ */
+
+var max = Math.max;
+
+/**
+ * @param {EventBus} eventBus
+ */
+export default function SpaceToolBehavior(eventBus) {
+  eventBus.on('spaceTool.getMinDimensions', function(context) {
+    var shapes = context.shapes,
+        axis = context.axis,
+        start = context.start,
+        minDimensions = {};
+
+    forEach(shapes, function(shape) {
+      var id = shape.id;
+
+      if (is(shape, 'bpmn:Participant')) {
+        minDimensions[ id ] = getParticipantMinDimensions(shape, axis, start);
+      }
+
+      if (is(shape, 'bpmn:Lane')) {
+        minDimensions[ id ] = isHorizontal(shape) ? LANE_MIN_DIMENSIONS : VERTICAL_LANE_MIN_DIMENSIONS;
+      }
+
+      if (is(shape, 'bpmn:SubProcess') && isExpanded(shape)) {
+        minDimensions[ id ] = SUB_PROCESS_MIN_DIMENSIONS;
+      }
+
+      if (is(shape, 'bpmn:TextAnnotation')) {
+        minDimensions[ id ] = TEXT_ANNOTATION_MIN_DIMENSIONS;
+      }
+
+      if (is(shape, 'bpmn:Group')) {
+        minDimensions[ id ] = GROUP_MIN_DIMENSIONS;
+      }
+    });
+
+    return minDimensions;
+  });
+}
+
+SpaceToolBehavior.$inject = [ 'eventBus' ];
+
+
+// helpers //////////
+function isHorizontalAxis(axis) {
+  return axis === 'x';
+}
+
+/**
+ * Get minimum dimensions for participant taking lanes into account.
+ *
+ * @param {Shape} participant
+ * @param {Axis} axis
+ * @param {number} start
+ *
+ * @return {number}
+ */
+function getParticipantMinDimensions(participant, axis, start) {
+  var isHorizontalLane = isHorizontal(participant);
+
+  if (!hasChildLanes(participant)) {
+    return isHorizontalLane ? PARTICIPANT_MIN_DIMENSIONS : VERTICAL_PARTICIPANT_MIN_DIMENSIONS;
+  }
+
+  var isHorizontalResize = isHorizontalAxis(axis);
+  var minDimensions = {};
+
+  if (isHorizontalResize) {
+    if (isHorizontalLane) {
+      minDimensions = PARTICIPANT_MIN_DIMENSIONS;
+    } else {
+      minDimensions = {
+        width: getParticipantMinWidth(participant, start, isHorizontalResize),
+        height: VERTICAL_PARTICIPANT_MIN_DIMENSIONS.height
+      };
+    }
+
+  } else {
+    if (isHorizontalLane) {
+      minDimensions = {
+        width: PARTICIPANT_MIN_DIMENSIONS.width,
+        height: getParticipantMinHeight(participant, start, isHorizontalResize)
+      };
+    } else {
+      minDimensions = VERTICAL_PARTICIPANT_MIN_DIMENSIONS;
+    }
+  }
+
+  return minDimensions;
+}
+
+/**
+ * Get minimum height for participant taking lanes into account.
+ *
+ * @param {Shape} participant
+ * @param {number} start
+ * @param {boolean} isHorizontalResize
+ *
+ * @return {number}
+ */
+function getParticipantMinHeight(participant, start, isHorizontalResize) {
+  var lanesMinHeight;
+  lanesMinHeight = getLanesMinHeight(participant, start, isHorizontalResize);
+  return max(PARTICIPANT_MIN_DIMENSIONS.height, lanesMinHeight);
+}
+
+/**
+ * Get minimum width for participant taking lanes into account.
+ *
+ * @param {Shape} participant
+ * @param {number} start
+ * @param {boolean} isHorizontalResize
+ *
+ * @return {number}
+ */
+function getParticipantMinWidth(participant, start, isHorizontalResize) {
+  var lanesMinWidth;
+  lanesMinWidth = getLanesMinWidth(participant, start, isHorizontalResize);
+  return max(VERTICAL_PARTICIPANT_MIN_DIMENSIONS.width, lanesMinWidth);
+}
+
+function hasChildLanes(element) {
+  return !!getChildLanes(element).length;
+}
+
+function getLanesMinHeight(participant, resizeStart, isHorizontalResize) {
+  var lanes = getChildLanes(participant),
+      resizedLane;
+
+  // find the nested lane which is currently resized
+  resizedLane = findResizedLane(lanes, resizeStart, isHorizontalResize);
+
+  // resized lane cannot shrink below the minimum height
+  // but remaining lanes' dimensions are kept intact
+  return participant.height - resizedLane.height + LANE_MIN_DIMENSIONS.height;
+}
+
+function getLanesMinWidth(participant, resizeStart, isHorizontalResize) {
+  var lanes = getChildLanes(participant),
+      resizedLane;
+
+  // find the nested lane which is currently resized
+  resizedLane = findResizedLane(lanes, resizeStart, isHorizontalResize);
+
+  // resized lane cannot shrink below the minimum width
+  // but remaining lanes' dimensions are kept intact
+  return participant.width - resizedLane.width + VERTICAL_LANE_MIN_DIMENSIONS.width;
+}
+
+/**
+ * Find nested lane which is currently resized.
+ *
+ * @param {Shape[]} lanes
+ * @param {number} resizeStart
+ * @param {boolean} isHorizontalResize
+ *
+ * @return {Shape}
+ */
+function findResizedLane(lanes, resizeStart, isHorizontalResize) {
+  var i, lane, childLanes;
+
+  for (i = 0; i < lanes.length; i++) {
+    lane = lanes[i];
+
+    // resizing current lane or a lane nested
+    if (!isHorizontalResize && resizeStart >= lane.y && resizeStart <= lane.y + lane.height ||
+        isHorizontalResize && resizeStart >= lane.x && resizeStart <= lane.x + lane.width) {
+
+      childLanes = getChildLanes(lane);
+
+      // a nested lane is resized
+      if (childLanes.length) {
+        return findResizedLane(childLanes, resizeStart, isHorizontalResize);
+      }
+
+      // current lane is the resized one
+      return lane;
+    }
+  }
+}

package/lib/features/modeling/behavior/TextAnnotationBehavior.d.ts

@@ -0,0 +1,6 @@
+export default class TextAnnotationBehavior extends CommandInterceptor {
+    constructor(eventBus: any);
+}
+
+type EventBus = import('diagram-js/lib/core/EventBus').default;
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';

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

@@ -0,0 +1,43 @@
+import inherits from 'inherits-browser';
+
+import { is } from '../../../util/ModelUtil';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ */
+
+export default function TextAnnotationBehavior(eventBus) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  // On Append, TextAnnotations will be created on the Root.
+  // The default for connections will create the connection in the parent of
+  // the source element, so we overwrite the parent here.
+  this.preExecute('connection.create', function(context) {
+    const { target } = context;
+
+    if (!is(target, 'bpmn:TextAnnotation')) {
+      return;
+    }
+
+    context.parent = target.parent;
+  }, true);
+
+  this.preExecute([ 'shape.create', 'shape.resize', 'elements.move' ], function(context) {
+    const shapes = context.shapes || [ context.shape ];
+
+    if (shapes.length === 1 && is(shapes[0], 'bpmn:TextAnnotation')) {
+      context.hints = context.hints || {};
+
+      context.hints.autoResize = false;
+    }
+  }, true);
+}
+
+inherits(TextAnnotationBehavior, CommandInterceptor);
+
+TextAnnotationBehavior.$inject = [
+  'eventBus'
+];

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

@@ -32,6 +32,7 @@ import RootElementReferenceBehavior from './RootElementReferenceBehavior';
 import SpaceToolBehavior from './SpaceToolBehavior';
 import SubProcessPlaneBehavior from './SubProcessPlaneBehavior';
 import SubProcessStartEventBehavior from './SubProcessStartEventBehavior';
+import TextAnnotationBehavior from './TextAnnotationBehavior';
 import ToggleCollapseConnectionBehaviour from './ToggleCollapseConnectionBehaviour';
 import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
 import UnclaimIdBehavior from './UnclaimIdBehavior';
@@ -77,6 +78,7 @@ export default {
     'spaceToolBehavior',
     'subProcessPlaneBehavior',
     'subProcessStartEventBehavior',
+    'textAnnotationBehavior',
     'toggleCollapseConnectionBehaviour',
     'toggleElementCollapseBehaviour',
     'unclaimIdBehavior',
@@ -117,6 +119,7 @@ export default {
   spaceToolBehavior: [ 'type', SpaceToolBehavior ],
   subProcessPlaneBehavior: [ 'type', SubProcessPlaneBehavior ],
   subProcessStartEventBehavior: [ 'type', SubProcessStartEventBehavior ],
+  textAnnotationBehavior: [ 'type', TextAnnotationBehavior ],
   toggleCollapseConnectionBehaviour: [ 'type', ToggleCollapseConnectionBehaviour ],
   toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
   unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],

package/lib/features/modeling/util/LaneUtil.js

@@ -4,6 +4,10 @@ import {
   getParent
 } from './ModelingUtil';
 
+import {
+  isHorizontal
+} from '../../../util/DiUtil';
+
 import {
   asTRBL
 } from 'diagram-js/lib/layout/LayoutUtil';
@@ -111,16 +115,18 @@ export function computeLanesResize(shape, newBounds) {
       trblResize = getTRBLResize(shape, newBounds),
       resizeNeeded = [];
 
+  var isHorizontalLane = isHorizontal(shape);
+
   allLanes.forEach(function(other) {
 
     if (other === shape) {
       return;
     }
 
-    var topResize = 0,
-        rightResize = trblResize.right,
-        bottomResize = 0,
-        leftResize = trblResize.left;
+    var topResize = isHorizontalLane ? 0 : trblResize.top,
+        rightResize = isHorizontalLane ? trblResize.right : 0,
+        bottomResize = isHorizontalLane ? 0 : trblResize.bottom,
+        leftResize = isHorizontalLane ? trblResize.left : 0;
 
     var otherTrbl = asTRBL(other);
 
@@ -134,6 +140,16 @@ export function computeLanesResize(shape, newBounds) {
       }
     }
 
+    if (trblResize.left) {
+      if (abs(otherTrbl.right - shapeTrbl.left) < 10) {
+        rightResize = shapeNewTrbl.left - otherTrbl.right;
+      }
+
+      if (abs(otherTrbl.left - shapeTrbl.left) < 5) {
+        leftResize = shapeNewTrbl.left - otherTrbl.left;
+      }
+    }
+
     if (trblResize.bottom) {
       if (abs(otherTrbl.top - shapeTrbl.bottom) < 10) {
         topResize = shapeNewTrbl.bottom - otherTrbl.top;
@@ -144,6 +160,16 @@ export function computeLanesResize(shape, newBounds) {
       }
     }
 
+    if (trblResize.right) {
+      if (abs(otherTrbl.left - shapeTrbl.right) < 10) {
+        leftResize = shapeNewTrbl.right - otherTrbl.left;
+      }
+
+      if (abs(otherTrbl.right - shapeTrbl.right) < 5) {
+        rightResize = shapeNewTrbl.right - otherTrbl.right;
+      }
+    }
+
     if (topResize || rightResize || bottomResize || leftResize) {
 
       resizeNeeded.push({

package/lib/features/ordering/BpmnOrderingProvider.js

@@ -3,6 +3,7 @@ import inherits from 'inherits-browser';
 import OrderingProvider from 'diagram-js/lib/features/ordering/OrderingProvider';
 
 import {
+  is,
   isAny
 } from '../modeling/util/ModelingUtil';
 
@@ -54,6 +55,12 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
         ]
       }
     },
+    {
+      type: 'bpmn:TextAnnotation',
+      order: {
+        level: 9
+      }
+    },
     {
       type: 'bpmn:MessageFlow', order: {
         level: 9,
@@ -136,8 +143,8 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
 
   this.getOrdering = function(element, newParent) {
 
-    // render labels always on top
-    if (element.labelTarget) {
+    // render labels and text annotations always on top
+    if (element.labelTarget || is(element, 'bpmn:TextAnnotation')) {
       return {
         parent: canvas.findRoot(newParent) || canvas.getRootElement(),
         index: -1

package/lib/features/palette/PaletteProvider.js

@@ -2,8 +2,6 @@ import {
   assign
 } from 'min-dash';
 
-import { getDi } from '../../util/ModelUtil';
-
 /**
  * @typedef {import('diagram-js/lib/features/palette/Palette').default} Palette
  * @typedef {import('diagram-js/lib/features/create/Create').default} Create
@@ -75,12 +73,6 @@ PaletteProvider.prototype.getPaletteEntries = function() {
 
     function createListener(event) {
       var shape = elementFactory.createShape(assign({ type: type }, options));
-
-      if (options) {
-        var di = getDi(shape);
-        di.isExpanded = options.isExpanded;
-      }
-
       create.start(event, shape);
     }
 
@@ -180,7 +172,8 @@ PaletteProvider.prototype.getPaletteEntries = function() {
     ),
     'create.exclusive-gateway': createAction(
       'bpmn:ExclusiveGateway', 'gateway', 'bpmn-icon-gateway-none',
-      translate('Create gateway')
+      translate('Create gateway'),
+      { isMarkerVisible: true }
     ),
     'create.task': createAction(
       'bpmn:Task', 'activity', 'bpmn-icon-task',

package/lib/features/replace/BpmnReplace.js

@@ -162,6 +162,10 @@ export default function BpmnReplace(
 
     newElement.di = {};
 
+    if (type === 'bpmn:ExclusiveGateway') {
+      newElement.di.isMarkerVisible = true;
+    }
+
     // colors will be set to DI
     copyProperties(element.di, newElement.di, [
       'fill',

package/lib/features/rules/BpmnRules.js

@@ -984,11 +984,11 @@ function canResize(shape, newBounds) {
   }
 
   if (is(shape, 'bpmn:Lane')) {
-    return !newBounds || (newBounds.width >= 130 && newBounds.height >= 60);
+    return true;
   }
 
   if (is(shape, 'bpmn:Participant')) {
-    return !newBounds || (newBounds.width >= 250 && newBounds.height >= 50);
+    return true;
   }
 
   if (isTextAnnotation(shape)) {

package/lib/features/space-tool/BpmnSpaceTool.js

@@ -4,6 +4,8 @@ import SpaceTool from 'diagram-js/lib/features/space-tool/SpaceTool';
 
 import { getBusinessObject, is } from '../../util/ModelUtil';
 
+import { isHorizontal } from '../../util/DiUtil';
+
 /**
  * @typedef {import('didi').Injector} Injector
  *
@@ -40,15 +42,18 @@ BpmnSpaceTool.prototype.calculateAdjustments = function(elements, axis, delta, s
   // do not resize:
   //
   // * text annotations (horizontally/vertically)
-  // * empty pools (vertically)
+  // * empty horizontal pools (vertically)
+  // * empty vertical pools (horizontally)
   adjustments.resizingShapes = adjustments.resizingShapes.filter(function(shape) {
 
     if (is(shape, 'bpmn:TextAnnotation')) {
       return false;
     }
 
-    if (axis === 'y' && isCollapsedPool(shape)) {
-      return false;
+    if (isCollapsedPool(shape)) {
+      if (axis === 'y' && isHorizontal(shape) || axis === 'x' && !isHorizontal(shape)) {
+        return false;
+      }
     }
 
     return true;

package/package.json

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