bpmn-js 9.0.0-subprocesses.1 → 9.0.1

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

@@ -3,9 +3,7 @@ import AppendBehavior from './AppendBehavior';
 import AssociationBehavior from './AssociationBehavior';
 import AttachEventBehavior from './AttachEventBehavior';
 import BoundaryEventBehavior from './BoundaryEventBehavior';
-import RootElementReferenceBehavior from './RootElementReferenceBehavior';
 import CreateBehavior from './CreateBehavior';
-import FixHoverBehavior from './FixHoverBehavior';
 import CreateDataObjectBehavior from './CreateDataObjectBehavior';
 import CreateParticipantBehavior from './CreateParticipantBehavior';
 import DataInputAssociationBehavior from './DataInputAssociationBehavior';
@@ -14,24 +12,29 @@ import DeleteLaneBehavior from './DeleteLaneBehavior';
 import DetachEventBehavior from './DetachEventBehavior';
 import DropOnFlowBehavior from './DropOnFlowBehavior';
 import EventBasedGatewayBehavior from './EventBasedGatewayBehavior';
+import FixHoverBehavior from './FixHoverBehavior';
 import GroupBehavior from './GroupBehavior';
 import ImportDockingFix from './ImportDockingFix';
 import IsHorizontalFix from './IsHorizontalFix';
 import LabelBehavior from './LabelBehavior';
 import MessageFlowBehavior from './MessageFlowBehavior';
 import ModelingFeedback from './ModelingFeedback';
-import ReplaceConnectionBehavior from './ReplaceConnectionBehavior';
+import RemoveEmbeddedLabelBoundsBehavior from './RemoveEmbeddedLabelBoundsBehavior';
+import RemoveElementBehavior from './RemoveElementBehavior';
 import RemoveParticipantBehavior from './RemoveParticipantBehavior';
+import ReplaceConnectionBehavior from './ReplaceConnectionBehavior';
 import ReplaceElementBehaviour from './ReplaceElementBehaviour';
 import ResizeBehavior from './ResizeBehavior';
 import ResizeLaneBehavior from './ResizeLaneBehavior';
-import RemoveElementBehavior from './RemoveElementBehavior';
+import RootElementReferenceBehavior from './RootElementReferenceBehavior';
 import SpaceToolBehavior from './SpaceToolBehavior';
+import SubProcessPlaneBehavior from './SubProcessPlaneBehavior';
 import SubProcessStartEventBehavior from './SubProcessStartEventBehavior';
+import ToggleCollapseConnectionBehaviour from './ToggleCollapseConnectionBehaviour';
 import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
 import UnclaimIdBehavior from './UnclaimIdBehavior';
-import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
 import UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';
+import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
 
 export default {
   __init__: [
@@ -40,17 +43,16 @@ export default {
     'associationBehavior',
     'attachEventBehavior',
     'boundaryEventBehavior',
-    'rootElementReferenceBehavior',
     'createBehavior',
-    'fixHoverBehavior',
     'createDataObjectBehavior',
     'createParticipantBehavior',
-    'dataStoreBehavior',
     'dataInputAssociationBehavior',
+    'dataStoreBehavior',
     'deleteLaneBehavior',
     'detachEventBehavior',
     'dropOnFlowBehavior',
     'eventBasedGatewayBehavior',
+    'fixHoverBehavior',
     'groupBehavior',
     'importDockingFix',
     'isHorizontalFix',
@@ -58,26 +60,28 @@ export default {
     'messageFlowBehavior',
     'modelingFeedback',
     'removeElementBehavior',
+    'removeEmbeddedLabelBoundsBehavior',
     'removeParticipantBehavior',
     'replaceConnectionBehavior',
     'replaceElementBehaviour',
     'resizeBehavior',
     'resizeLaneBehavior',
-    'toggleElementCollapseBehaviour',
+    'rootElementReferenceBehavior',
     'spaceToolBehavior',
+    'subProcessPlaneBehavior',
     'subProcessStartEventBehavior',
+    'toggleCollapseConnectionBehaviour',
+    'toggleElementCollapseBehaviour',
     'unclaimIdBehavior',
-    'unsetDefaultFlowBehavior',
-    'updateFlowNodeRefsBehavior'
+    'updateFlowNodeRefsBehavior',
+    'unsetDefaultFlowBehavior'
   ],
   adaptiveLabelPositioningBehavior: [ 'type', AdaptiveLabelPositioningBehavior ],
   appendBehavior: [ 'type', AppendBehavior ],
   associationBehavior: [ 'type', AssociationBehavior ],
   attachEventBehavior: [ 'type', AttachEventBehavior ],
   boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
-  rootElementReferenceBehavior: [ 'type', RootElementReferenceBehavior ],
   createBehavior: [ 'type', CreateBehavior ],
-  fixHoverBehavior: [ 'type', FixHoverBehavior ],
   createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
   createParticipantBehavior: [ 'type', CreateParticipantBehavior ],
   dataInputAssociationBehavior: [ 'type', DataInputAssociationBehavior ],
@@ -86,22 +90,27 @@ export default {
   detachEventBehavior: [ 'type', DetachEventBehavior ],
   dropOnFlowBehavior: [ 'type', DropOnFlowBehavior ],
   eventBasedGatewayBehavior: [ 'type', EventBasedGatewayBehavior ],
+  fixHoverBehavior: [ 'type', FixHoverBehavior ],
   groupBehavior: [ 'type', GroupBehavior ],
   importDockingFix: [ 'type', ImportDockingFix ],
   isHorizontalFix: [ 'type', IsHorizontalFix ],
   labelBehavior: [ 'type', LabelBehavior ],
   messageFlowBehavior: [ 'type', MessageFlowBehavior ],
   modelingFeedback: [ 'type', ModelingFeedback ],
-  replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
+  removeElementBehavior: [ 'type', RemoveElementBehavior ],
+  removeEmbeddedLabelBoundsBehavior: ['type', RemoveEmbeddedLabelBoundsBehavior ],
   removeParticipantBehavior: [ 'type', RemoveParticipantBehavior ],
+  replaceConnectionBehavior: [ 'type', ReplaceConnectionBehavior ],
   replaceElementBehaviour: [ 'type', ReplaceElementBehaviour ],
   resizeBehavior: [ 'type', ResizeBehavior ],
   resizeLaneBehavior: [ 'type', ResizeLaneBehavior ],
-  removeElementBehavior: [ 'type', RemoveElementBehavior ],
-  toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
+  rootElementReferenceBehavior: [ 'type', RootElementReferenceBehavior ],
   spaceToolBehavior: [ 'type', SpaceToolBehavior ],
+  subProcessPlaneBehavior: [ 'type', SubProcessPlaneBehavior ],
   subProcessStartEventBehavior: [ 'type', SubProcessStartEventBehavior ],
+  toggleCollapseConnectionBehaviour: [ 'type', ToggleCollapseConnectionBehaviour ],
+  toggleElementCollapseBehaviour : [ 'type', ToggleElementCollapseBehaviour ],
   unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
-  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ],
-  unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ]
+  unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ],
+  updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ]
 };

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

@@ -5,6 +5,9 @@ import {
   pick
 } from 'min-dash';
 
+import {
+  getDi
+} from '../../../util/ModelUtil';
 
 var DEFAULT_COLORS = {
   fill: undefined,
@@ -63,12 +66,26 @@ SetColorHandler.prototype.postExecute = function(context) {
     // TODO @barmac: remove once we drop bpmn.io properties
     ensureLegacySupport(assignedDi);
 
-    self._commandStack.execute('element.updateProperties', {
-      element: element,
-      properties: {
-        di: assignedDi
-      }
-    });
+    if (element.labelTarget) {
+
+      // set label colors as bpmndi:BPMNLabel#color
+      self._commandStack.execute('element.updateModdleProperties', {
+        element: element,
+        moddleElement: getDi(element).label,
+        properties: {
+          color: di['background-color']
+        }
+      });
+    } else {
+
+      // set colors bpmndi:BPMNEdge or bpmndi:BPMNShape
+      self._commandStack.execute('element.updateProperties', {
+        element: element,
+        properties: {
+          di: assignedDi
+        }
+      });
+    }
   });
 
 };

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

@@ -29,7 +29,8 @@ UpdateCanvasRootHandler.prototype.execute = function(context) {
       diPlane = getDi(oldRoot);
 
   // (1) replace process old <> new root
-  canvas.setRootElement(newRoot, true);
+  canvas.setRootElement(newRoot);
+  canvas.removeRootElement(oldRoot);
 
   // (2) update root elements
   collectionAdd(bpmnDefinitions.rootElements, newRootBusinessObject);
@@ -63,7 +64,8 @@ UpdateCanvasRootHandler.prototype.revert = function(context) {
       diPlane = getDi(newRoot);
 
   // (1) replace process old <> new root
-  canvas.setRootElement(oldRoot, true);
+  canvas.setRootElement(oldRoot);
+  canvas.removeRootElement(newRoot);
 
   // (2) update root elements
   collectionRemove(bpmnDefinitions.rootElements, newRootBusinessObject);

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

@@ -1,24 +1,6 @@
-import {
-  some
-} from 'min-dash';
-
-import { is } from '../../../util/ModelUtil';
-
-
-/**
- * Return true if element has any of the given types.
- *
- * @param {djs.model.Base} element
- * @param {Array<string>} types
- *
- * @return {boolean}
- */
-export function isAny(element, types) {
-  return some(types, function(t) {
-    return is(element, t);
-  });
-}
+export { is, isAny } from '../../../util/ModelUtil';
 
+import { isAny } from '../../../util/ModelUtil';
 
 /**
  * Return the parent of the element with any of the given types.

package/lib/features/ordering/BpmnOrderingProvider.js

@@ -42,7 +42,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
         level: 9,
         containers: [
           'bpmn:Collaboration',
-          'bpmn:Process'
+          'bpmn:FlowElementsContainer'
         ]
       }
     },
@@ -70,7 +70,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
         level: 10,
         containers: [
           'bpmn:Collaboration',
-          'bpmn:Process'
+          'bpmn:FlowElementsContainer'
         ]
       }
     },
@@ -131,7 +131,7 @@ export default function BpmnOrderingProvider(eventBus, canvas, translate) {
     // render labels always on top
     if (element.labelTarget) {
       return {
-        parent: canvas.getRootElement(),
+        parent: canvas.findRoot(element.labelTarget) || canvas.getRootElement(),
         index: -1
       };
     }

package/lib/features/palette/PaletteProvider.js

@@ -90,7 +90,7 @@ PaletteProvider.prototype.getPaletteEntries = function(element) {
 
     create.start(event, [ subProcess, startEvent ], {
       hints: {
-        autoSelect: [ startEvent ]
+        autoSelect: [ subProcess ]
       }
     });
   }

package/lib/features/popup-menu/ReplaceMenuProvider.js

@@ -83,7 +83,7 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
     return this._createEntries(element, replaceOptions.DATA_OBJECT_REFERENCE);
   }
 
-  if (is(businessObject, 'bpmn:DataStoreReference')) {
+  if (is(businessObject, 'bpmn:DataStoreReference') && !is(element.parent, 'bpmn:Collaboration')) {
     return this._createEntries(element, replaceOptions.DATA_STORE_REFERENCE);
   }
 

package/lib/import/BpmnImporter.js

@@ -10,8 +10,6 @@ import {
 } from '../util/LabelUtil';
 
 import {
-  asBounds,
-  asTRBL,
   getMid
 } from 'diagram-js/lib/layout/LayoutUtil';
 
@@ -28,6 +26,13 @@ import {
 } from './Util';
 
 
+/**
+ * @param {ModdleElement} semantic
+ * @param {ModdleElement} di
+ * @param {Object} [attrs=null]
+ *
+ * @return {Object}
+ */
 function elementData(semantic, di, attrs) {
   return assign({
     id: semantic.id,
@@ -50,32 +55,6 @@ function getWaypoints(di, source, target) {
   });
 }
 
-var PLANE_PADDING = 50;
-
-function getPlaneBounds(plane) {
-  var planeTrbl = {
-    top: Infinity,
-    right: -Infinity,
-    bottom: -Infinity,
-    left: Infinity
-  };
-
-  plane.planeElement.forEach(function(element) {
-    if (!element.bounds) {
-      return;
-    }
-
-    var trbl = asTRBL(element.bounds);
-
-    planeTrbl.top = Math.min(trbl.top, planeTrbl.top);
-    planeTrbl.left = Math.min(trbl.left, planeTrbl.left);
-    planeTrbl.right = Math.max(trbl.right, planeTrbl.right);
-    planeTrbl.bottom = Math.max(trbl.bottom, planeTrbl.bottom);
-  });
-
-  return asBounds(planeTrbl);
-}
-
 function notYetDrawn(translate, semantic, refSemantic, property) {
   return new Error(translate('element {element} referenced by {referenced}#{property} not yet drawn', {
     element: elementToString(refSemantic),
@@ -130,39 +109,17 @@ BpmnImporter.prototype.add = function(semantic, di, parentElement) {
 
   // ROOT ELEMENT
   // handle the special case that we deal with a
-  // invisible root element (process or collaboration)
+  // invisible root element (process, subprocess or collaboration)
   if (is(di, 'bpmndi:BPMNPlane')) {
 
-    if (is(semantic, 'bpmn:SubProcess')) {
-      var plane = this._canvas.createPlane(semantic.id, element);
-
-      // Get size of expanded element
-      var bounds = getPlaneBounds(di);
-
-      var primary = this._elementRegistry.get(semantic.id);
-      element = this._elementFactory.createShape(elementData(semantic, di, {
-        collapsed: false,
-        hidden: false,
-        x: bounds.x - PLANE_PADDING,
-        y: bounds.y - PLANE_PADDING,
-        width: bounds.width + PLANE_PADDING * 2,
-        height: bounds.height + PLANE_PADDING * 2,
-        isFrame: true
-      }));
+    var attrs = is(semantic, 'bpmn:SubProcess')
+      ? { id: semantic.id + '_plane' }
+      : {};
 
-      element.id = element.id + '_secondary';
-      element.isSecondary = true;
-      element.primaryShape = primary;
+    // add a virtual element (not being drawn)
+    element = this._elementFactory.createRoot(elementData(semantic, di, attrs));
 
-      this._canvas.addShape(element, plane.rootElement);
-    }
-    else {
-
-      // add a virtual element (not being drawn)
-      element = this._elementFactory.createRoot(elementData(semantic, di));
-
-      this._canvas.createPlane(semantic.id, element);
-    }
+    this._canvas.addRootElement(element);
   }
 
   // SHAPE
@@ -173,7 +130,7 @@ BpmnImporter.prototype.add = function(semantic, di, parentElement) {
 
     hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
 
-    bounds = di.bounds;
+    var bounds = di.bounds;
 
     element = this._elementFactory.createShape(elementData(semantic, di, {
       collapsed: collapsed,
@@ -198,7 +155,7 @@ BpmnImporter.prototype.add = function(semantic, di, parentElement) {
 
       // check whether data store is inside our outside of its semantic parent
       if (!isPointInsideBBox(parentElement, getMid(bounds))) {
-        parentElement = this._canvas.findPlane(parentElement).rootElement;
+        parentElement = this._canvas.findRoot(parentElement);
       }
     }
 
@@ -226,7 +183,7 @@ BpmnImporter.prototype.add = function(semantic, di, parentElement) {
       // are rendered correctly across different "hacks" people
       // love to model such as cross participant / sub process
       // associations
-      parentElement = this._canvas.findPlane(parentElement).rootElement;
+      parentElement = this._canvas.findRoot(parentElement);
     }
 
     // insert sequence flows behind other flow nodes (cf. #727)

package/lib/import/Importer.js

@@ -1,5 +1,13 @@
+import {
+  find,
+  forEach,
+  map
+} from 'min-dash';
+
 import BpmnTreeWalker from './BpmnTreeWalker';
 
+import { is } from '../util/ModelUtil';
+
 
 /**
  * The importBpmnDiagram result.
@@ -65,18 +73,29 @@ export function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
 
     var walker = new BpmnTreeWalker(visitor, translate);
 
-    // traverse BPMN 2.0 document model,
-    // starting at definitions
-    if (!bpmnDiagram && definitions.diagrams) {
-      for (var i = 0; i < definitions.diagrams.length; i++) {
-        walker.handleDefinitions(definitions, definitions.diagrams[i]);
-      }
-    } else {
-      walker.handleDefinitions(definitions, bpmnDiagram);
+
+    bpmnDiagram = bpmnDiagram || (definitions.diagrams && definitions.diagrams[0]);
+
+    var diagramsToImport = getDiagramsToImport(definitions, bpmnDiagram);
+
+    if (!diagramsToImport) {
+      throw new Error(translate('no diagram to display'));
     }
 
-    var mainDiagram = bpmnDiagram || definitions.diagrams[0];
-    canvas.setActivePlane(mainDiagram.plane.bpmnElement.id);
+    // traverse BPMN 2.0 document model,
+    // starting at definitions
+    forEach(diagramsToImport, function(diagram) {
+      walker.handleDefinitions(definitions, diagram);
+    });
+
+    var rootId = bpmnDiagram.plane.bpmnElement.id;
+
+    // we do need to account for different ways we create root elements
+    // each nested imported <root> do have the `_plane` suffix, while
+    // the root <root> is found under the business object ID
+    canvas.setRootElement(
+      canvas.findRoot(rootId + '_plane') || canvas.findRoot(rootId)
+    );
   }
 
   return new Promise(function(resolve, reject) {
@@ -103,3 +122,104 @@ export function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
     }
   });
 }
+
+/**
+ * Returns all diagrams in the same hirarchy as the requested diagram.
+ * Includes all parent and sub process diagrams.
+ *
+ * @param {Array} definitions
+ * @param {Object} bpmnDiagram
+ *
+ * @returns {Array<Object>}
+ */
+function getDiagramsToImport(definitions, bpmnDiagram) {
+  if (!bpmnDiagram) {
+    return;
+  }
+
+  var bpmnElement = bpmnDiagram.plane.bpmnElement,
+      rootElement = bpmnElement;
+
+  if (!is(bpmnElement, 'bpmn:Process') && !is(bpmnElement, 'bpmn:Collaboration')) {
+    rootElement = findRootProcess(bpmnElement);
+  }
+
+  // in case the process is part of a collaboration, the plane references the
+  // collaboration, not the process
+  var collaboration;
+
+  if (is(rootElement, 'bpmn:Collaboration')) {
+    collaboration = rootElement;
+  } else {
+    collaboration = find(definitions.rootElements, function(element) {
+      if (!is(element, 'bpmn:Collaboration')) {
+        return;
+      }
+
+      return find(element.participants, function(participant) {
+        return participant.processRef === rootElement;
+      });
+    });
+  }
+
+  var rootElements = [ rootElement ];
+
+  // all collaboration processes can contain sub-diagrams
+  if (collaboration) {
+    rootElements = map(collaboration.participants, function(participant) {
+      return participant.processRef;
+    });
+
+    rootElements.push(collaboration);
+  }
+
+  var allChildren = selfAndAllFlowElements(rootElements);
+
+  // if we have multiple diagrams referencing the same element, we
+  // use the first in the file
+  var diagramsToImport = [ bpmnDiagram ];
+  var handledElements = [ bpmnElement ];
+
+  forEach(definitions.diagrams, function(diagram) {
+    var businessObject = diagram.plane.bpmnElement;
+
+    if (
+      allChildren.indexOf(businessObject) !== -1 &&
+      handledElements.indexOf(businessObject) === -1
+    ) {
+      diagramsToImport.push(diagram);
+      handledElements.push(businessObject);
+    }
+  });
+
+
+  return diagramsToImport;
+}
+
+function selfAndAllFlowElements(elements) {
+  var result = [];
+
+  forEach(elements, function(element) {
+    if (!element) {
+      return;
+    }
+
+    result.push(element);
+
+    result = result.concat(selfAndAllFlowElements(element.flowElements));
+  });
+
+  return result;
+}
+
+function findRootProcess(element) {
+  var parent = element;
+
+  while (parent) {
+    if (is(parent, 'bpmn:Process')) {
+      return parent;
+    }
+
+    parent = parent.$parent;
+  }
+}

package/lib/util/DrilldownUtil.js

@@ -0,0 +1,66 @@
+import { getDi, is } from './ModelUtil';
+
+
+export var planeSuffix = '_plane';
+
+/**
+ * Get primary shape ID for a plane.
+ *
+ * @param  {djs.model.Base|ModdleElement} element
+ *
+ * @returns {String}
+ */
+export function getShapeIdFromPlane(element) {
+  var id = element.id;
+
+  return removePlaneSuffix(id);
+}
+
+/**
+ * Get plane ID for a primary shape.
+ *
+ * @param  {djs.model.Base|ModdleElement} element
+ *
+ * @returns {String}
+ */
+export function getPlaneIdFromShape(element) {
+  var id = element.id;
+
+  if (is(element, 'bpmn:SubProcess')) {
+    return addPlaneSuffix(id);
+  }
+
+  return id;
+}
+
+/**
+ * Get plane ID for primary shape ID.
+ *
+ * @param {String} id
+ *
+ * @returns {String}
+ */
+export function toPlaneId(id) {
+  return addPlaneSuffix(id);
+}
+
+/**
+ * Check wether element is plane.
+ *
+ * @param  {djs.model.Base|ModdleElement} element
+ *
+ * @returns {Boolean}
+ */
+export function isPlane(element) {
+  var di = getDi(element);
+
+  return is(di, 'bpmndi:BPMNPlane');
+}
+
+function addPlaneSuffix(id) {
+  return id + planeSuffix;
+}
+
+function removePlaneSuffix(id) {
+  return id.replace(new RegExp(planeSuffix + '$'), '');
+}

package/lib/util/ModelUtil.js

@@ -1,3 +1,8 @@
+import {
+  some
+} from 'min-dash';
+
+
 /**
  * Is an element of the given BPMN type?
  *
@@ -13,6 +18,20 @@ export function is(element, type) {
 }
 
 
+/**
+ * Return true if element has any of the given types.
+ *
+ * @param {djs.model.Base} element
+ * @param {Array<string>} types
+ *
+ * @return {boolean}
+ */
+export function isAny(element, types) {
+  return some(types, function(t) {
+    return is(element, t);
+  });
+}
+
 /**
  * Return the business object for a given element.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "9.0.0-subprocesses.1",
+  "version": "9.0.1",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "index.js",
   "files": [
@@ -100,7 +100,7 @@
   "dependencies": {
     "bpmn-moddle": "^7.1.2",
     "css.escape": "^1.5.1",
-    "diagram-js": "^7.6.0",
+    "diagram-js": "^8.1.2",
     "diagram-js-direct-editing": "^1.6.3",
     "ids": "^1.0.0",
     "inherits": "^2.0.4",

package/test/helper/index.js

@@ -256,12 +256,7 @@ export function createViewer(container, viewerInstance, xml, diagramId) {
 
   clearBpmnJS();
 
-  var viewer = new viewerInstance({
-    container: container,
-    canvas: {
-      deferUpdate: false
-    }
-  });
+  var viewer = new viewerInstance({ container: container });
 
   setBpmnJS(viewer);