bpmn-js 0.20.4 → 0.21.0

package/lib/features/modeling/ElementFactory.js

@@ -81,7 +81,7 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     delete attrs.colors;
   }
 
-  this.setAttrs(businessObject, attrs, [
+  applyAttributes(businessObject, attrs, [
     'processRef',
     'isInterrupting',
     'associationDirection',
@@ -89,7 +89,7 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
   ]);
 
   if (attrs.isExpanded) {
-    this.setAttr(businessObject.di, attrs, 'isExpanded');
+    applyAttribute(businessObject.di, attrs, 'isExpanded');
   }
 
   if (is(businessObject, 'bpmn:ExclusiveGateway')) {
@@ -122,23 +122,6 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
 };
 
 
-ElementFactory.prototype.setAttrs = function(element, attrs, properties) {
-
-  forEach(properties, function(property) {
-    if (attrs[property] !== undefined) {
-      this.setAttr(element, attrs, property);
-    }
-  }, this);
-};
-
-
-ElementFactory.prototype.setAttr = function(element, attrs, property) {
-  element[property] = attrs[property];
-
-  delete attrs[property];
-};
-
-
 ElementFactory.prototype._getDefaultSize = function(semantic) {
 
   if (is(semantic, 'bpmn:SubProcess')) {
@@ -200,3 +183,37 @@ ElementFactory.prototype.createParticipantShape = function(collapsed) {
 
   return this.createShape(attrs);
 };
+
+
+//////////// helpers ////////////////////////////////////
+
+/**
+ * Apply attributes from a map to the given element,
+ * remove attribute from the map on application.
+ *
+ * @param {Base} element
+ * @param {Object} attrs (in/out map of attributes)
+ * @param {Array<String>} attributeNames name of attributes to apply
+ */
+function applyAttributes(element, attrs, attributeNames) {
+
+  forEach(attributeNames, function(property) {
+    if (attrs[property] !== undefined) {
+      applyAttribute(element, attrs, property);
+    }
+  });
+}
+
+/**
+ * Apply named property to element and drain it from the attrs
+ * collection.
+ *
+ * @param {Base} element
+ * @param {Object} attrs (in/out map of attributes)
+ * @param {String} attributeName to apply
+ */
+function applyAttribute(element, attrs, attributeName) {
+  element[attributeName] = attrs[attributeName];
+
+  delete attrs[attributeName];
+}

package/lib/features/modeling/Modeling.js

@@ -64,7 +64,11 @@ Modeling.prototype.connect = function(source, target, attrs, hints) {
   var bpmnRules = this._bpmnRules;
 
   if (!attrs) {
-    attrs = bpmnRules.canConnect(source, target) || { type: 'bpmn:Association' };
+    attrs = bpmnRules.canConnect(source, target);
+  }
+
+  if (!attrs) {
+    return;
   }
 
   return this.createConnection(source, target, attrs, source.parent, hints);

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

@@ -2,12 +2,23 @@
 
 var inherits = require('inherits');
 
-var assign = require('lodash/object/assign');
+var assign = require('lodash/object/assign'),
+    find = require('lodash/collection/find');
 
 var CommandInterceptor = require('diagram-js/lib/command/CommandInterceptor');
 
 var getApproxIntersection = require('diagram-js/lib/util/LineIntersection').getApproxIntersection;
 
+function isPointInsideBBox(bbox, point) {
+  var x = point.x,
+      y = point.y;
+
+  return x >= bbox.x &&
+    x <= bbox.x + bbox.width &&
+    y >= bbox.y &&
+    y <= bbox.y + bbox.height;
+}
+
 function copy(obj) {
   return assign({}, obj);
 }
@@ -41,8 +52,15 @@ function DropOnFlow(eventBus, bpmnRules, modeling) {
 
       dockingPoint = intersection.bendpoint ? waypoints[intersection.index] : position;
 
-      waypointsBefore.push(copy(dockingPoint));
-      waypointsAfter.unshift(copy(dockingPoint));
+      // if last waypointBefore is inside shape's bounds, ignore docking point
+      if (!isPointInsideBBox(shape, waypointsBefore[waypointsBefore.length-1])) {
+        waypointsBefore.push(copy(dockingPoint));
+      }
+
+      // if first waypointAfter is inside shape's bounds, ignore docking point
+      if (!isPointInsideBBox(shape, waypointsAfter[0])) {
+        waypointsAfter.unshift(copy(dockingPoint));
+      }
     }
 
     source = targetFlow.source;
@@ -68,24 +86,40 @@ function DropOnFlow(eventBus, bpmnRules, modeling) {
 
   this.preExecute('elements.move', function(context) {
 
-    var parent = context.newParent,
+    var newParent = context.newParent,
         shapes = context.shapes,
-        shape,
-        shapeMid,
-        delta = context.delta;
+        delta = context.delta,
+        shape = shapes[0];
 
-    if (bpmnRules.canInsert(shapes, parent)) {
+    if (!shape || !newParent) {
+      return;
+    }
 
-      shape = shapes[0];
-      shapeMid = getMid(shape);
+    // if the new parent is a connection,
+    // change it to the new parent's parent
+    if (newParent && newParent.waypoints) {
+      context.newParent = newParent = newParent.parent;
+    }
 
-      context.targetFlow = parent;
-      context.newParent = parent.parent;
-      context.position = {
-        x: shapeMid.x + delta.x,
-        y: shapeMid.y + delta.y
-      };
+    var shapeMid = getMid(shape);
+    var newShapeMid = {
+      x: shapeMid.x + delta.x,
+      y: shapeMid.y + delta.y
+    };
+
+    // find a connection which intersects with the
+    // element's mid point
+    var connection = find(newParent.children, function(element) {
+      var canInsert = bpmnRules.canInsert(shapes, element);
+
+      return canInsert && getApproxIntersection(element.waypoints, newShapeMid);
+    });
+
+    if (connection) {
+      context.targetFlow = connection;
+      context.position = newShapeMid;
     }
+
   }, true);
 
   this.postExecuted('elements.move', function(context) {

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

@@ -110,7 +110,9 @@ ReplaceElementBehaviour.prototype.replaceElements = function(elements, newElemen
   }
 };
 
-ReplaceElementBehaviour.$inject = [ 'eventBus', 'bpmnReplace', 'bpmnRules', 'elementRegistry',
- 'selection', 'modeling' ];
+ReplaceElementBehaviour.$inject = [
+  'eventBus', 'bpmnReplace', 'bpmnRules',
+  'elementRegistry', 'selection', 'modeling'
+];
 
 module.exports = ReplaceElementBehaviour;

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

@@ -112,7 +112,7 @@ function getLabelAdjustment(label, newWaypoints, oldWaypoints, hints) {
       oldLabelLineIndex = attachment.segmentIndex,
       newLabelLineIndex = findNewLabelLineStartIndex(oldWaypoints, newWaypoints, attachment, hints);
 
-  if ( newLabelLineIndex === null ) {
+  if (newLabelLineIndex === null) {
     return { x: x, y: y };
   }
 
@@ -210,8 +210,9 @@ function getLine(waypoints, idx) {
 }
 
 function getRelativeFootPosition(line, foot) {
+
   var length = getDistancePointPoint(line[0], line[1]),
       lengthToFoot = getDistancePointPoint(line[0], foot);
 
-  return lengthToFoot / length;
+  return length === 0 ? 0 : lengthToFoot / length;
 }

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

@@ -2,7 +2,8 @@
 
 var sqrt = Math.sqrt,
     min = Math.min,
-    max = Math.max;
+    max = Math.max,
+    abs = Math.abs;
 
 /**
  * Calculate the square (power to two) of a number.
@@ -74,15 +75,15 @@ function getAttachment(point, line) {
     segmentEnd = line[idx + 1];
 
     if (pointsEqual(segmentStart, segmentEnd)) {
-      continue;
-    }
-
-    segmentStartDistance = getDistance(point, segmentStart);
-    segmentEndDistance = getDistance(point, segmentEnd);
+      intersections = [ segmentStart ];
+    } else {
+      segmentStartDistance = getDistance(point, segmentStart);
+      segmentEndDistance = getDistance(point, segmentEnd);
 
-    minDistance = min(segmentStartDistance, segmentEndDistance);
+      minDistance = min(segmentStartDistance, segmentEndDistance);
 
-    intersections = getCircleSegmentIntersections(segmentStart, segmentEnd, point, minDistance);
+      intersections = getCircleSegmentIntersections(segmentStart, segmentEnd, point, minDistance);
+    }
 
     if (intersections.length < 1) {
       throw new Error('expected between [1, 2] circle -> line intersections');
@@ -136,12 +137,6 @@ module.exports.getAttachment = getAttachment;
  */
 function getCircleSegmentIntersections(s1, s2, cc, cr) {
 
-  // silently round values
-  s1 = roundPoint(s1);
-  s2 = roundPoint(s2);
-  cc = roundPoint(cc);
-  cr = min(getDistance(s1, cc), getDistance(s2, cc));
-
   var baX = s2.x - s1.x;
   var baY = s2.y - s1.y;
   var caX = cc.x - s1.x;
@@ -155,6 +150,14 @@ function getCircleSegmentIntersections(s1, s2, cc, cr) {
   var q = c / a;
 
   var disc = pBy2 * pBy2 - q;
+
+  // check against negative value to work around
+  // negative, very close to zero results (-4e-15)
+  // being produced in some environments
+  if (disc < 0 && disc > -0.000001) {
+    disc = 0;
+  }
+
   if (disc < 0) {
     return [];
   }
@@ -165,8 +168,8 @@ function getCircleSegmentIntersections(s1, s2, cc, cr) {
   var abScalingFactor2 = -pBy2 - tmpSqrt;
 
   var i1 = {
-    x: round(s1.x - baX * abScalingFactor1),
-    y: round(s1.y - baY * abScalingFactor1)
+    x: s1.x - baX * abScalingFactor1,
+    y: s1.y - baY * abScalingFactor1
   };
 
   if (disc === 0) { // abScalingFactor1 == abScalingFactor2
@@ -174,10 +177,11 @@ function getCircleSegmentIntersections(s1, s2, cc, cr) {
   }
 
   var i2 = {
-    x: round(s1.x - baX * abScalingFactor2),
-    y: round(s1.y - baY * abScalingFactor2)
+    x: s1.x - baX * abScalingFactor2,
+    y: s1.y - baY * abScalingFactor2
   };
 
+  // return only points on line segment
   return [ i1, i2 ].filter(function(p) {
     return isPointInSegment(p, s1, s2);
   });
@@ -192,7 +196,14 @@ function isPointInSegment(p, segmentStart, segmentEnd) {
 }
 
 function fenced(n, rangeStart, rangeEnd) {
-  return min(rangeStart, rangeEnd) <= n && n <= max(rangeStart, rangeEnd);
+
+  // use matching threshold to work around
+  // precisison errors in intersection computation
+
+  return (
+    n >= min(rangeStart, rangeEnd) - EQUAL_THRESHOLD &&
+    n <= max(rangeStart, rangeEnd) + EQUAL_THRESHOLD
+  );
 }
 
 /**
@@ -211,17 +222,12 @@ function mid(p1, p2) {
   };
 }
 
-function round(n) {
-  return Math.round(n * 1000) / 1000;
-}
-
-function roundPoint(p) {
-  return {
-    x: round(p.x),
-    y: round(p.y)
-  };
-}
+var EQUAL_THRESHOLD = 0.1;
 
 function pointsEqual(p1, p2) {
-  return p1.x === p2.x && p1.y === p2.y;
+
+  return (
+    abs(p1.x - p2.x) <= EQUAL_THRESHOLD &&
+    abs(p1.y - p2.y) <= EQUAL_THRESHOLD
+  );
 }

package/lib/features/rules/BpmnRules.js

@@ -369,14 +369,7 @@ function canConnect(source, target, connection) {
     };
   }
 
-  if (is(connection, 'bpmn:Association') && canConnectAssociation(source, target)) {
-
-    return {
-      type: 'bpmn:Association'
-    };
-  }
-
-  if (isTextAnnotation(source) || isTextAnnotation(target)) {
+  if (canConnectAssociation(source, target)) {
 
     return {
       type: 'bpmn:Association'
@@ -705,6 +698,22 @@ function canResize(shape, newBounds) {
   return false;
 }
 
+/**
+ * Check, whether one side of the relationship
+ * is a text annotation.
+ */
+function isOneTextAnnotation(source, target) {
+
+  var sourceTextAnnotation = isTextAnnotation(source),
+      targetTextAnnotation = isTextAnnotation(target);
+
+  return (
+    (sourceTextAnnotation || targetTextAnnotation) &&
+    (sourceTextAnnotation !== targetTextAnnotation)
+  );
+}
+
+
 function canConnectAssociation(source, target) {
 
   // do not connect connections
@@ -712,9 +721,18 @@ function canConnectAssociation(source, target) {
     return false;
   }
 
-  // connect if different parent
-  return !isParent(target, source) &&
-         !isParent(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;
+  }
+
+  // allow connection of associations between <!TextAnnotation> and <TextAnnotation>
+  return isOneTextAnnotation(source, target);
 }
 
 function canConnectMessageFlow(source, target) {

package/lib/features/snapping/BpmnSnapping.js

@@ -373,18 +373,34 @@ BpmnSnapping.prototype.addTargetSnaps = function(snapPoints, shape, target) {
 
   var siblings = this.getSiblings(shape, target) || [];
 
-  forEach(siblings, function(s) {
+  forEach(siblings, function(sibling) {
 
     // do not snap to lanes
-    if (is(s, 'bpmn:Lane')) {
+    if (is(sibling, 'bpmn:Lane')) {
       return;
     }
 
-    snapPoints.add('mid', mid(s));
+    if (sibling.waypoints) {
+      forEach(sibling.waypoints, function(waypoint, i) {
+        var nextWaypoint = sibling.waypoints[i+1];
 
-    if (is(s, 'bpmn:Participant')) {
-      snapPoints.add('top-left', topLeft(s));
-      snapPoints.add('bottom-right', bottomRight(s));
+        if (!nextWaypoint) {
+          return;
+        }
+
+        if (nextWaypoint.x === waypoint.x || nextWaypoint.y === waypoint.y) {
+          snapPoints.add('mid', waypoint);
+        }
+      });
+
+      return;
+    }
+
+    snapPoints.add('mid', mid(sibling));
+
+    if (is(sibling, 'bpmn:Participant')) {
+      snapPoints.add('top-left', topLeft(sibling));
+      snapPoints.add('bottom-right', bottomRight(sibling));
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "0.20.4",
+  "version": "0.21.0",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "scripts": {
     "all": "grunt",
@@ -37,34 +37,34 @@
     "browserify": "^13.0.0",
     "browserify-derequire": "^0.9.1",
     "bundle-collapser": "^1.1.1",
-    "chai": "~2.2.0",
-    "eslint": "^2.11.1",
-    "eslint-plugin-mocha": "^2.2.0",
+    "chai": "^3.5.0",
+    "eslint": "^3.19.0",
+    "eslint-plugin-mocha": "^4.9.0",
     "grunt": "^0.4.4",
     "grunt-cli": "^0.1.13",
     "grunt-contrib-copy": "^0.7.0",
-    "grunt-eslint": "^18.1.0",
-    "grunt-karma": "^0.12.0",
+    "grunt-eslint": "^19.0.0",
+    "grunt-karma": "^2.0.0",
     "grunt-release": "^0.7.0",
     "jsondiffpatch": "^0.1.26",
-    "karma": "^0.13.0",
-    "karma-browserify": "^5.0.1",
+    "karma": "^1.7.0",
+    "karma-browserify": "^5.1.1",
     "karma-chai": "^0.1.0",
-    "karma-chrome-launcher": "^0.2.2",
+    "karma-chrome-launcher": "^2.1.1",
     "karma-env-preprocessor": "^0.1.1",
-    "karma-firefox-launcher": "^0.1.3",
-    "karma-ie-launcher": "^0.2.0",
-    "karma-mocha": "~0.1.0",
-    "karma-phantomjs-launcher": "^1.0.2",
-    "karma-safari-launcher": "^0.1.1",
-    "karma-sinon-chai": "~0.3.0",
-    "karma-spec-reporter": "0.0.26",
+    "karma-firefox-launcher": "^1.0.1",
+    "karma-ie-launcher": "^1.0.0",
+    "karma-mocha": "^1.3.0",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-sinon-chai": "^1.3.1",
+    "karma-spec-reporter": "0.0.31",
     "load-grunt-tasks": "^0.3.0",
-    "mocha": "^2.2.5",
+    "mocha": "^3.4.1",
     "mocha-test-container-support": "0.2.0",
     "phantomjs-prebuilt": "^2.1.12",
-    "sinon": "~1.14.1",
-    "sinon-chai": "~2.7.0",
+    "sinon": "^2.2.0",
+    "sinon-chai": "^2.10.0",
     "source-map-concat": "^1.0.0",
     "stringify": "^3.1.0",
     "time-grunt": "^0.3.2",
@@ -73,9 +73,9 @@
   },
   "dependencies": {
     "bpmn-moddle": "^0.14.0",
-    "diagram-js": "^0.19.2",
-    "diagram-js-direct-editing": "^0.17.1",
-    "diagram-js-origin": "^0.15.1",
+    "diagram-js": "^0.20.0",
+    "diagram-js-direct-editing": "^0.18.0",
+    "diagram-js-origin": "^0.15.2",
     "ids": "^0.2.0",
     "inherits": "^2.0.1",
     "lodash": "^3.0.1",

package/test/TestHelper.js

@@ -7,7 +7,7 @@ TestHelper.insertCSS('diagram-js.css', require('diagram-js/assets/diagram-js.css
 TestHelper.insertCSS('bpmn-embedded.css', require('../assets/bpmn-font/css/bpmn-embedded.css'));
 
 TestHelper.insertCSS('diagram-js-testing.css',
-  '.test-container .result { height: 500px; }' + '.test-container > div'
+  '.test-container .result { height: 500px; }' + '.test-container { height: 1000px !important }'
 );