bpmn-js 8.8.2 → 9.0.0-subprocesses.3

package/lib/features/modeling/BpmnUpdater.js

@@ -16,6 +16,7 @@ import {
 
 import {
   getBusinessObject,
+  getDi,
   is
 } from '../../util/ModelUtil';
 
@@ -307,8 +308,9 @@ BpmnUpdater.prototype.updateParent = function(element, oldParent) {
   var parentShape = element.parent;
 
   var businessObject = element.businessObject,
+      di = getDi(element),
       parentBusinessObject = parentShape && parentShape.businessObject,
-      parentDi = parentBusinessObject && parentBusinessObject.di;
+      parentDi = getDi(parentShape);
 
   if (is(element, 'bpmn:FlowNode')) {
     this.updateFlowNodeRefs(businessObject, parentBusinessObject, oldParent && oldParent.businessObject);
@@ -336,13 +338,13 @@ BpmnUpdater.prototype.updateParent = function(element, oldParent) {
     this.updateSemanticParent(businessObject.dataObjectRef, parentBusinessObject);
   }
 
-  this.updateDiParent(businessObject.di, parentDi);
+  this.updateDiParent(di, parentDi);
 };
 
 
 BpmnUpdater.prototype.updateBounds = function(shape) {
 
-  var di = shape.businessObject.di;
+  var di = getDi(shape);
 
   var target = (shape instanceof Label) ? this._getLabel(di) : di;
 
@@ -382,14 +384,17 @@ BpmnUpdater.prototype.updateFlowNodeRefs = function(businessObject, newContainme
 
 
 // update existing sourceElement and targetElement di information
-BpmnUpdater.prototype.updateDiConnection = function(di, newSource, newTarget) {
+BpmnUpdater.prototype.updateDiConnection = function(connection, newSource, newTarget) {
+  var connectionDi = getDi(connection),
+      newSourceDi = getDi(newSource),
+      newTargetDi = getDi(newTarget);
 
-  if (di.sourceElement && di.sourceElement.bpmnElement !== newSource) {
-    di.sourceElement = newSource && newSource.di;
+  if (connectionDi.sourceElement && connectionDi.sourceElement.bpmnElement !== getBusinessObject(newSource)) {
+    connectionDi.sourceElement = newSource && newSourceDi;
   }
 
-  if (di.targetElement && di.targetElement.bpmnElement !== newTarget) {
-    di.targetElement = newTarget && newTarget.di;
+  if (connectionDi.targetElement && connectionDi.targetElement.bpmnElement !== getBusinessObject(newTarget)) {
+    connectionDi.targetElement = newTarget && newTargetDi;
   }
 
 };
@@ -614,69 +619,72 @@ BpmnUpdater.prototype.updateSemanticParent = function(businessObject, newParent,
 
 
 BpmnUpdater.prototype.updateConnectionWaypoints = function(connection) {
-  connection.businessObject.di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));
+  var di = getDi(connection);
+
+  di.set('waypoint', this._bpmnFactory.createDiWaypoints(connection.waypoints));
 };
 
 
 BpmnUpdater.prototype.updateConnection = function(context) {
-
   var connection = context.connection,
       businessObject = getBusinessObject(connection),
-      newSource = getBusinessObject(connection.source),
-      newTarget = getBusinessObject(connection.target),
+      newSource = connection.source,
+      newSourceBo = getBusinessObject(newSource),
+      newTarget = connection.target,
+      newTargetBo = getBusinessObject(connection.target),
       visualParent;
 
   if (!is(businessObject, 'bpmn:DataAssociation')) {
 
     var inverseSet = is(businessObject, 'bpmn:SequenceFlow');
 
-    if (businessObject.sourceRef !== newSource) {
+    if (businessObject.sourceRef !== newSourceBo) {
       if (inverseSet) {
         collectionRemove(businessObject.sourceRef && businessObject.sourceRef.get('outgoing'), businessObject);
 
-        if (newSource && newSource.get('outgoing')) {
-          newSource.get('outgoing').push(businessObject);
+        if (newSourceBo && newSourceBo.get('outgoing')) {
+          newSourceBo.get('outgoing').push(businessObject);
         }
       }
 
-      businessObject.sourceRef = newSource;
+      businessObject.sourceRef = newSourceBo;
     }
 
-    if (businessObject.targetRef !== newTarget) {
+    if (businessObject.targetRef !== newTargetBo) {
       if (inverseSet) {
         collectionRemove(businessObject.targetRef && businessObject.targetRef.get('incoming'), businessObject);
 
-        if (newTarget && newTarget.get('incoming')) {
-          newTarget.get('incoming').push(businessObject);
+        if (newTargetBo && newTargetBo.get('incoming')) {
+          newTargetBo.get('incoming').push(businessObject);
         }
       }
 
-      businessObject.targetRef = newTarget;
+      businessObject.targetRef = newTargetBo;
     }
   } else
 
   if (is(businessObject, 'bpmn:DataInputAssociation')) {
 
     // handle obnoxious isMsome sourceRef
-    businessObject.get('sourceRef')[0] = newSource;
+    businessObject.get('sourceRef')[0] = newSourceBo;
 
-    visualParent = context.parent || context.newParent || newTarget;
+    visualParent = context.parent || context.newParent || newTargetBo;
 
-    this.updateSemanticParent(businessObject, newTarget, visualParent);
+    this.updateSemanticParent(businessObject, newTargetBo, visualParent);
   } else
 
   if (is(businessObject, 'bpmn:DataOutputAssociation')) {
-    visualParent = context.parent || context.newParent || newSource;
+    visualParent = context.parent || context.newParent || newSourceBo;
 
-    this.updateSemanticParent(businessObject, newSource, visualParent);
+    this.updateSemanticParent(businessObject, newSourceBo, visualParent);
 
     // targetRef = new target
-    businessObject.targetRef = newTarget;
+    businessObject.targetRef = newTargetBo;
   }
 
   this.updateConnectionWaypoints(connection);
 
-  this.updateDiConnection(businessObject.di, newSource, newTarget);
+  this.updateDiConnection(connection, newSource, newTarget);
 };
 
 

package/lib/features/modeling/ElementFactory.js

@@ -6,7 +6,15 @@ import {
 
 import inherits from 'inherits';
 
-import { is } from '../../util/ModelUtil';
+import {
+  getBusinessObject,
+  getDi,
+  is
+} from '../../util/ModelUtil';
+
+import {
+  isAny
+} from '../modeling/util/ModelingUtil';
 
 import {
   isExpanded
@@ -18,6 +26,10 @@ import {
   DEFAULT_LABEL_SIZE
 } from '../../util/LabelUtil';
 
+import {
+  ensureCompatDiRef
+} from '../../util/CompatibilityUtil';
+
 
 /**
  * A bpmn-aware factory for diagram-js shapes
@@ -46,7 +58,8 @@ ElementFactory.prototype.create = function(elementType, attrs) {
   // we assume their businessObjects have already been created
   // and wired via attrs
   if (elementType === 'label') {
-    return this.baseCreate(elementType, assign({ type: 'label' }, DEFAULT_LABEL_SIZE, attrs));
+    var di = attrs.di || this._bpmnFactory.createDiLabel();
+    return this.baseCreate(elementType, assign({ type: 'label', di: di }, DEFAULT_LABEL_SIZE, attrs));
   }
 
   return this.createBpmnElement(elementType, attrs);
@@ -58,7 +71,8 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
 
   attrs = attrs || {};
 
-  var businessObject = attrs.businessObject;
+  var businessObject = attrs.businessObject,
+      di = attrs.di;
 
   if (!businessObject) {
     if (!attrs.type) {
@@ -66,22 +80,23 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     }
 
     businessObject = this._bpmnFactory.create(attrs.type);
+
+    ensureCompatDiRef(businessObject);
   }
 
-  if (!businessObject.di) {
+  if (!isModdleDi(di)) {
+    var diAttrs = assign(
+      di || {},
+      { id: businessObject.id + '_di' }
+    );
+
     if (elementType === 'root') {
-      businessObject.di = this._bpmnFactory.createDiPlane(businessObject, [], {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiPlane(businessObject, diAttrs);
     } else
     if (elementType === 'connection') {
-      businessObject.di = this._bpmnFactory.createDiEdge(businessObject, [], {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiEdge(businessObject, diAttrs);
     } else {
-      businessObject.di = this._bpmnFactory.createDiShape(businessObject, {}, {
-        id: businessObject.id + '_di'
-      });
+      di = this._bpmnFactory.createDiShape(businessObject, diAttrs);
     }
   }
 
@@ -91,12 +106,6 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     }, attrs);
   }
 
-  if (attrs.di) {
-    assign(businessObject.di, attrs.di);
-
-    delete attrs.di;
-  }
-
   applyAttributes(businessObject, attrs, [
     'processRef',
     'isInterrupting',
@@ -105,11 +114,11 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
   ]);
 
   if (attrs.isExpanded) {
-    applyAttribute(businessObject.di, attrs, 'isExpanded');
+    applyAttribute(di, attrs, 'isExpanded');
   }
 
   if (is(businessObject, 'bpmn:ExclusiveGateway')) {
-    businessObject.di.isMarkerVisible = true;
+    di.isMarkerVisible = true;
   }
 
   var eventDefinitions,
@@ -131,65 +140,69 @@ ElementFactory.prototype.createBpmnElement = function(elementType, attrs) {
     delete attrs.eventDefinitionType;
   }
 
-  size = this._getDefaultSize(businessObject);
+  size = this.getDefaultSize(businessObject, di);
 
   attrs = assign({
-    businessObject: businessObject,
     id: businessObject.id
-  }, size, attrs);
+  }, size, attrs, {
+    businessObject: businessObject,
+    di: di
+  });
 
   return this.baseCreate(elementType, attrs);
 };
 
 
-ElementFactory.prototype._getDefaultSize = function(semantic) {
+ElementFactory.prototype.getDefaultSize = function(element, di) {
 
-  if (is(semantic, 'bpmn:SubProcess')) {
+  var bo = getBusinessObject(element);
+  di = di || getDi(element);
 
-    if (isExpanded(semantic)) {
+  if (is(bo, 'bpmn:SubProcess')) {
+    if (isExpanded(bo, di)) {
       return { width: 350, height: 200 };
     } else {
       return { width: 100, height: 80 };
     }
   }
 
-  if (is(semantic, 'bpmn:Task')) {
+  if (is(bo, 'bpmn:Task')) {
     return { width: 100, height: 80 };
   }
 
-  if (is(semantic, 'bpmn:Gateway')) {
+  if (is(bo, 'bpmn:Gateway')) {
     return { width: 50, height: 50 };
   }
 
-  if (is(semantic, 'bpmn:Event')) {
+  if (is(bo, 'bpmn:Event')) {
     return { width: 36, height: 36 };
   }
 
-  if (is(semantic, 'bpmn:Participant')) {
-    if (isExpanded(semantic)) {
+  if (is(bo, 'bpmn:Participant')) {
+    if (isExpanded(bo, di)) {
       return { width: 600, height: 250 };
     } else {
       return { width: 400, height: 60 };
     }
   }
 
-  if (is(semantic, 'bpmn:Lane')) {
+  if (is(bo, 'bpmn:Lane')) {
     return { width: 400, height: 100 };
   }
 
-  if (is(semantic, 'bpmn:DataObjectReference')) {
+  if (is(bo, 'bpmn:DataObjectReference')) {
     return { width: 36, height: 50 };
   }
 
-  if (is(semantic, 'bpmn:DataStoreReference')) {
+  if (is(bo, 'bpmn:DataStoreReference')) {
     return { width: 50, height: 50 };
   }
 
-  if (is(semantic, 'bpmn:TextAnnotation')) {
+  if (is(bo, 'bpmn:TextAnnotation')) {
     return { width: 100, height: 30 };
   }
 
-  if (is(semantic, 'bpmn:Group')) {
+  if (is(bo, 'bpmn:Group')) {
     return { width: 300, height: 300 };
   }
 
@@ -252,4 +265,14 @@ function applyAttribute(element, attrs, attributeName) {
   element[attributeName] = attrs[attributeName];
 
   delete attrs[attributeName];
+}
+
+
+function isModdleDi(element) {
+  return isAny(element, [
+    'bpmndi:BPMNShape',
+    'bpmndi:BPMNEdge',
+    'bpmndi:BPMNDiagram',
+    'bpmndi:BPMNPlane',
+  ]);
 }

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

@@ -4,6 +4,7 @@ import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
   getBusinessObject,
+  getDi,
   is
 } from '../../../util/ModelUtil';
 
@@ -45,8 +46,9 @@ export default function DataStoreBehavior(
 
       commandStack.execute('dataStore.updateContainment', {
         dataStoreBo: dataStoreBo,
+        dataStoreDi: getDi(dataStore),
         newSemanticParent: newDataStoreParentBo.processRef || newDataStoreParentBo,
-        newDiParent: newDataStoreParentBo.di
+        newDiParent: getDi(newDataStoreParent)
       });
     }
   }

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

@@ -3,7 +3,8 @@ import inherits from 'inherits';
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
-  getBusinessObject
+  getBusinessObject,
+  getDi
 } from '../../../util/ModelUtil';
 
 import {
@@ -26,12 +27,14 @@ export default function IsHorizontalFix(eventBus) {
   ];
 
   this.executed([ 'shape.move', 'shape.create', 'shape.resize' ], function(event) {
-    var bo = getBusinessObject(event.context.shape);
+    var shape = event.context.shape,
+        bo = getBusinessObject(shape),
+        di = getDi(shape);
 
-    if (isAny(bo, elementTypesToUpdate) && !bo.di.get('isHorizontal')) {
+    if (isAny(bo, elementTypesToUpdate) && !di.get('isHorizontal')) {
 
       // set attribute directly to avoid modeling#updateProperty side effects
-      bo.di.set('isHorizontal', true);
+      di.set('isHorizontal', true);
     }
   });
 

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

@@ -6,7 +6,8 @@ import inherits from 'inherits';
 
 import {
   is,
-  getBusinessObject
+  getBusinessObject,
+  getDi
 } from '../../../util/ModelUtil';
 
 import {
@@ -153,27 +154,27 @@ export default function LabelBehavior(
 
     var context = event.context,
         element = context.shape,
-        businessObject,
+        labelTarget = context.labelTarget,
         di;
 
     // we want to trigger on real labels only
-    if (!element.labelTarget) {
+    if (!labelTarget) {
       return;
     }
 
     // we want to trigger on BPMN elements only
-    if (!is(element.labelTarget || element, 'bpmn:BaseElement')) {
+    if (!is(labelTarget, 'bpmn:BaseElement')) {
       return;
     }
 
-    businessObject = element.businessObject,
-    di = businessObject.di;
-
+    di = getDi(labelTarget);
 
     if (!di.label) {
       di.label = bpmnFactory.create('bpmndi:BPMNLabel', {
         bounds: bpmnFactory.create('dc:Bounds')
       });
+
+      element.di = di;
     }
 
     assign(di.label.bounds, {

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

@@ -3,7 +3,7 @@ import inherits from 'inherits';
 import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
 
 import {
-  getBusinessObject,
+  getDi,
   is
 } from '../../../util/ModelUtil';
 
@@ -85,11 +85,11 @@ export default function ToggleElementCollapseBehaviour(
       hideEmptyLabels(shape.children);
 
       // remove collapsed marker
-      getBusinessObject(shape).di.isExpanded = true;
+      getDi(shape).isExpanded = true;
     } else {
 
       // place collapsed marker
-      getBusinessObject(shape).di.isExpanded = false;
+      getDi(shape).isExpanded = false;
     }
   });
 
@@ -101,16 +101,16 @@ export default function ToggleElementCollapseBehaviour(
 
     // revert removing/placing collapsed marker
     if (!shape.collapsed) {
-      getBusinessObject(shape).di.isExpanded = true;
+      getDi(shape).isExpanded = true;
 
     } else {
-      getBusinessObject(shape).di.isExpanded = false;
+      getDi(shape).isExpanded = false;
     }
   });
 
   this.postExecuted([ 'shape.toggleCollapse' ], LOW_PRIORITY, function(e) {
     var shape = e.context.shape,
-        defaultSize = elementFactory._getDefaultSize(shape),
+        defaultSize = elementFactory.getDefaultSize(shape),
         newBounds;
 
     if (shape.collapsed) {

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

@@ -3,6 +3,8 @@ import {
   remove as collectionRemove
 } from 'diagram-js/lib/util/Collections';
 
+import { getDi } from '../../../util/ModelUtil';
+
 
 export default function UpdateCanvasRootHandler(canvas, modeling) {
   this._canvas = canvas;
@@ -24,7 +26,7 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
       oldRoot = canvas.getRootElement(),
       oldRootBusinessObject = oldRoot.businessObject,
       bpmnDefinitions = oldRootBusinessObject.$parent,
-      diPlane = oldRootBusinessObject.di;
+      diPlane = getDi(oldRoot);
 
   // (1) replace process old <> new root
   canvas.setRootElement(newRoot, true);
@@ -37,10 +39,10 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
   oldRootBusinessObject.$parent = null;
 
   // (3) wire di
-  oldRootBusinessObject.di = null;
+  oldRoot.di = null;
 
   diPlane.bpmnElement = newRootBusinessObject;
-  newRootBusinessObject.di = diPlane;
+  newRoot.di = diPlane;
 
   context.oldRoot = oldRoot;
 
@@ -58,7 +60,7 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
       oldRoot = context.oldRoot,
       oldRootBusinessObject = oldRoot.businessObject,
       bpmnDefinitions = newRootBusinessObject.$parent,
-      diPlane = newRootBusinessObject.di;
+      diPlane = getDi(newRoot);
 
   // (1) replace process old <> new root
   canvas.setRootElement(oldRoot, true);
@@ -71,10 +73,10 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
   oldRootBusinessObject.$parent = bpmnDefinitions;
 
   // (3) wire di
-  newRootBusinessObject.di = null;
+  newRoot.di = null;
 
   diPlane.bpmnElement = oldRootBusinessObject;
-  oldRootBusinessObject.di = diPlane;
+  oldRoot.di = diPlane;
 
   // TODO(nikku): return changed elements?
   // return [ newRoot, oldRoot ];

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

@@ -6,7 +6,8 @@ import {
 } from 'min-dash';
 
 import {
-  getBusinessObject
+  getBusinessObject,
+  getDi
 } from '../../../util/ModelUtil';
 
 var DEFAULT_FLOW = 'default',
@@ -74,7 +75,7 @@ UpdatePropertiesHandler.prototype.execute = function(context) {
 
   var businessObject = element.businessObject,
       properties = unwrapBusinessObjects(context.properties),
-      oldProperties = context.oldProperties || getProperties(businessObject, properties);
+      oldProperties = context.oldProperties || getProperties(element, properties);
 
   if (isIdChange(properties, businessObject)) {
     ids.unclaim(businessObject[ID]);
@@ -97,7 +98,7 @@ UpdatePropertiesHandler.prototype.execute = function(context) {
   }
 
   // update properties
-  setProperties(businessObject, properties);
+  setProperties(element, properties);
 
   // store old values
   context.oldProperties = oldProperties;
@@ -142,7 +143,7 @@ UpdatePropertiesHandler.prototype.revert = function(context) {
       ids = this._moddle.ids;
 
   // update properties
-  setProperties(businessObject, oldProperties);
+  setProperties(element, oldProperties);
 
   if (isIdChange(properties, businessObject)) {
     ids.unclaim(properties[ID]);
@@ -161,16 +162,19 @@ function isIdChange(properties, businessObject) {
 }
 
 
-function getProperties(businessObject, properties) {
-  var propertyNames = keys(properties);
+function getProperties(element, properties) {
+  var propertyNames = keys(properties),
+      businessObject = element.businessObject,
+      di = getDi(element);
 
   return reduce(propertyNames, function(result, key) {
 
     // handle DI separately
     if (key !== DI) {
       result[key] = businessObject.get(key);
+
     } else {
-      result[key] = getDiProperties(businessObject.di, keys(properties.di));
+      result[key] = getDiProperties(di, keys(properties.di));
     }
 
     return result;
@@ -180,23 +184,26 @@ function getProperties(businessObject, properties) {
 
 function getDiProperties(di, propertyNames) {
   return reduce(propertyNames, function(result, key) {
-    result[key] = di.get(key);
+    result[key] = di && di.get(key);
 
     return result;
   }, {});
 }
 
 
-function setProperties(businessObject, properties) {
+function setProperties(element, properties) {
+  var businessObject = element.businessObject,
+      di = getDi(element);
+
   forEach(properties, function(value, key) {
 
     if (key !== DI) {
       businessObject.set(key, value);
     } else {
 
-      // only update, if businessObject.di exists
-      if (businessObject.di) {
-        setDiProperties(businessObject.di, value);
+      // only update, if di exists
+      if (di) {
+        setDiProperties(di, value);
       }
     }
   });

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

@@ -7,21 +7,23 @@ UpdateSemanticParentHandler.$inject = [ 'bpmnUpdater' ];
 
 UpdateSemanticParentHandler.prototype.execute = function(context) {
   var dataStoreBo = context.dataStoreBo,
+      dataStoreDi = context.dataStoreDi,
       newSemanticParent = context.newSemanticParent,
       newDiParent = context.newDiParent;
 
   context.oldSemanticParent = dataStoreBo.$parent;
-  context.oldDiParent = dataStoreBo.di.$parent;
+  context.oldDiParent = dataStoreDi.$parent;
 
   // update semantic parent
   this._bpmnUpdater.updateSemanticParent(dataStoreBo, newSemanticParent);
 
   // update DI parent
-  this._bpmnUpdater.updateDiParent(dataStoreBo.di, newDiParent);
+  this._bpmnUpdater.updateDiParent(dataStoreDi, newDiParent);
 };
 
 UpdateSemanticParentHandler.prototype.revert = function(context) {
   var dataStoreBo = context.dataStoreBo,
+      dataStoreDi = context.dataStoreDi,
       oldSemanticParent = context.oldSemanticParent,
       oldDiParent = context.oldDiParent;
 
@@ -29,6 +31,6 @@ UpdateSemanticParentHandler.prototype.revert = function(context) {
   this._bpmnUpdater.updateSemanticParent(dataStoreBo, oldSemanticParent);
 
   // update DI parent
-  this._bpmnUpdater.updateDiParent(dataStoreBo.di, oldDiParent);
+  this._bpmnUpdater.updateDiParent(dataStoreDi, oldDiParent);
 };
 

package/lib/features/palette/PaletteProvider.js

@@ -1,6 +1,7 @@
 import {
   assign
 } from 'min-dash';
+import { getDi } from '../../util/ModelUtil';
 
 
 /**
@@ -52,7 +53,8 @@ PaletteProvider.prototype.getPaletteEntries = function(element) {
       var shape = elementFactory.createShape(assign({ type: type }, options));
 
       if (options) {
-        shape.businessObject.di.isExpanded = options.isExpanded;
+        var di = getDi(shape);
+        di.isExpanded = options.isExpanded;
       }
 
       create.start(event, shape);