bpmn-js 12.1.0 → 13.0.0

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

@@ -15,14 +15,45 @@ import {
 import {
   forEach,
   filter,
+  isArray,
   isUndefined
 } from 'min-dash';
 
 import * as replaceOptions from '../replace/ReplaceOptions';
 
+/**
+ * @typedef {import('../features/BpmnFactory').default} BpmnFactory
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenu').default} PopupMenu
+ * @typedef {import('../features/Modeling').default} Modeling
+ * @typedef {import('../features/BpmnReplace').default} BpmnReplace
+ * @typedef {import('diagram-js/lib/features/Rules').default} Rules
+ * @typedef {import('diagram-js/lib/i18n/translate/translate').default} Translate
+ *
+ * @typedef {import('../../model/Types').Element} Element
+ * @typedef {import('../../model/Types').Moddle} Moddle
+ *
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenuProvider').PopupMenuEntries} PopupMenuEntries
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenuProvider').PopupMenuEntry} PopupMenuEntry
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenuProvider').PopupMenuEntryAction} PopupMenuEntryAction
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenuProvider').PopupMenuHeaderEntries} PopupMenuHeaderEntries
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenuProvider').default} PopupMenuProvider
+ * @typedef {import('diagram-js/lib/features/popup-menu/PopupMenu').PopupMenuTarget} PopupMenuTarget
+ *
+ * @typedef {import('./ReplaceOptions').ReplaceOption} ReplaceOption
+ */
 
 /**
- * This module is an element agnostic replace menu provider for the popup menu.
+ * A BPMN-specific popup menu provider.
+ *
+ * @implements {PopupMenuProvider}
+ *
+ * @param {BpmnFactory} bpmnFactory
+ * @param {PopupMenu} popupMenu
+ * @param {Modeling} modeling
+ * @param {Moddle} moddle
+ * @param {BpmnReplace} bpmnReplace
+ * @param {Rules} rules
+ * @param {Translate} translate
  */
 export default function ReplaceMenuProvider(
     bpmnFactory, popupMenu, modeling, moddle,
@@ -36,7 +67,7 @@ export default function ReplaceMenuProvider(
   this._rules = rules;
   this._translate = translate;
 
-  this.register();
+  this._register();
 }
 
 ReplaceMenuProvider.$inject = [
@@ -49,112 +80,104 @@ ReplaceMenuProvider.$inject = [
   'translate'
 ];
 
-
-/**
- * Register replace menu provider in the popup menu
- */
-ReplaceMenuProvider.prototype.register = function() {
+ReplaceMenuProvider.prototype._register = function() {
   this._popupMenu.registerProvider('bpmn-replace', this);
 };
 
-
 /**
- * Get all entries from replaceOptions for the given element and apply filters
- * on them. Get for example only elements, which are different from the current one.
- *
- * @param {djs.model.Base} element
+ * @param {PopupMenuTarget} target
  *
- * @return {Array<Object>} a list of menu entry items
+ * @return {PopupMenuEntries}
  */
-ReplaceMenuProvider.prototype.getEntries = function(element) {
+ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
 
-  var businessObject = element.businessObject;
+  var businessObject = target.businessObject;
 
   var rules = this._rules;
 
-  var entries;
+  var filteredReplaceOptions = [];
 
-  if (!rules.allowed('shape.replace', { element: element })) {
-    return [];
+  if (isArray(target) || !rules.allowed('shape.replace', { element: target })) {
+    return {};
   }
 
-  var differentType = isDifferentType(element);
+  var differentType = isDifferentType(target);
 
   if (is(businessObject, 'bpmn:DataObjectReference')) {
-    return this._createEntries(element, replaceOptions.DATA_OBJECT_REFERENCE);
+    return this._createEntries(target, replaceOptions.DATA_OBJECT_REFERENCE);
   }
 
-  if (is(businessObject, 'bpmn:DataStoreReference') && !is(element.parent, 'bpmn:Collaboration')) {
-    return this._createEntries(element, replaceOptions.DATA_STORE_REFERENCE);
+  if (is(businessObject, 'bpmn:DataStoreReference') && !is(target.parent, 'bpmn:Collaboration')) {
+    return this._createEntries(target, replaceOptions.DATA_STORE_REFERENCE);
   }
 
   // start events outside sub processes
   if (is(businessObject, 'bpmn:StartEvent') && !is(businessObject.$parent, 'bpmn:SubProcess')) {
 
-    entries = filter(replaceOptions.START_EVENT, differentType);
+    filteredReplaceOptions = filter(replaceOptions.START_EVENT, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // expanded/collapsed pools
   if (is(businessObject, 'bpmn:Participant')) {
 
-    entries = filter(replaceOptions.PARTICIPANT, function(entry) {
-      return isExpanded(element) !== entry.target.isExpanded;
+    filteredReplaceOptions = filter(replaceOptions.PARTICIPANT, function(replaceOption) {
+      return isExpanded(target) !== replaceOption.target.isExpanded;
     });
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // start events inside event sub processes
   if (is(businessObject, 'bpmn:StartEvent') && isEventSubProcess(businessObject.$parent)) {
-    entries = filter(replaceOptions.EVENT_SUB_PROCESS_START_EVENT, function(entry) {
+    filteredReplaceOptions = filter(replaceOptions.EVENT_SUB_PROCESS_START_EVENT, function(replaceOption) {
 
-      var target = entry.target;
+      var target = replaceOption.target;
 
       var isInterrupting = target.isInterrupting !== false;
 
-      var isInterruptingEqual = getBusinessObject(element).isInterrupting === isInterrupting;
+      var isInterruptingEqual = getBusinessObject(target).isInterrupting === isInterrupting;
 
       // filters elements which types and event definition are equal but have have different interrupting types
-      return differentType(entry) || !differentType(entry) && !isInterruptingEqual;
+      return differentType(replaceOption) || !differentType(replaceOption) && !isInterruptingEqual;
 
     });
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // start events inside sub processes
   if (is(businessObject, 'bpmn:StartEvent') && !isEventSubProcess(businessObject.$parent)
       && is(businessObject.$parent, 'bpmn:SubProcess')) {
-    entries = filter(replaceOptions.START_EVENT_SUB_PROCESS, differentType);
+    filteredReplaceOptions = filter(replaceOptions.START_EVENT_SUB_PROCESS, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // end events
   if (is(businessObject, 'bpmn:EndEvent')) {
 
-    entries = filter(replaceOptions.END_EVENT, function(entry) {
-      var target = entry.target;
+    filteredReplaceOptions = filter(replaceOptions.END_EVENT, function(replaceOption) {
+      var target = replaceOption.target;
 
       // hide cancel end events outside transactions
       if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' && !is(businessObject.$parent, 'bpmn:Transaction')) {
         return false;
       }
 
-      return differentType(entry);
+      return differentType(replaceOption);
     });
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // boundary events
   if (is(businessObject, 'bpmn:BoundaryEvent')) {
 
-    entries = filter(replaceOptions.BOUNDARY_EVENT, function(entry) {
+    filteredReplaceOptions = filter(replaceOptions.BOUNDARY_EVENT, function(replaceOption) {
 
-      var target = entry.target;
+      var target = replaceOption.target;
 
       if (target.eventDefinitionType == 'bpmn:CancelEventDefinition' &&
          !is(businessObject.attachedToRef, 'bpmn:Transaction')) {
@@ -164,121 +187,129 @@ ReplaceMenuProvider.prototype.getEntries = function(element) {
 
       var isCancelActivityEqual = businessObject.cancelActivity == cancelActivity;
 
-      return differentType(entry) || !differentType(entry) && !isCancelActivityEqual;
+      return differentType(replaceOption) || !differentType(replaceOption) && !isCancelActivityEqual;
     });
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // intermediate events
   if (is(businessObject, 'bpmn:IntermediateCatchEvent') ||
       is(businessObject, 'bpmn:IntermediateThrowEvent')) {
 
-    entries = filter(replaceOptions.INTERMEDIATE_EVENT, differentType);
+    filteredReplaceOptions = filter(replaceOptions.INTERMEDIATE_EVENT, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // gateways
   if (is(businessObject, 'bpmn:Gateway')) {
 
-    entries = filter(replaceOptions.GATEWAY, differentType);
+    filteredReplaceOptions = filter(replaceOptions.GATEWAY, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // transactions
   if (is(businessObject, 'bpmn:Transaction')) {
 
-    entries = filter(replaceOptions.TRANSACTION, differentType);
+    filteredReplaceOptions = filter(replaceOptions.TRANSACTION, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // expanded event sub processes
-  if (isEventSubProcess(businessObject) && isExpanded(element)) {
+  if (isEventSubProcess(businessObject) && isExpanded(target)) {
 
-    entries = filter(replaceOptions.EVENT_SUB_PROCESS, differentType);
+    filteredReplaceOptions = filter(replaceOptions.EVENT_SUB_PROCESS, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // expanded sub processes
-  if (is(businessObject, 'bpmn:SubProcess') && isExpanded(element)) {
+  if (is(businessObject, 'bpmn:SubProcess') && isExpanded(target)) {
 
-    entries = filter(replaceOptions.SUBPROCESS_EXPANDED, differentType);
+    filteredReplaceOptions = filter(replaceOptions.SUBPROCESS_EXPANDED, differentType);
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // collapsed ad hoc sub processes
-  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(element)) {
+  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(target)) {
 
-    entries = filter(replaceOptions.TASK, function(entry) {
+    filteredReplaceOptions = filter(replaceOptions.TASK, function(replaceOption) {
 
-      var target = entry.target;
+      var target = replaceOption.target;
 
       var isTargetSubProcess = target.type === 'bpmn:SubProcess';
 
       var isTargetExpanded = target.isExpanded === true;
 
-      return isDifferentType(element, target) && (!isTargetSubProcess || isTargetExpanded);
+      return isDifferentType(target, target) && (!isTargetSubProcess || isTargetExpanded);
     });
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
   // sequence flows
   if (is(businessObject, 'bpmn:SequenceFlow')) {
-    return this._createSequenceFlowEntries(element, replaceOptions.SEQUENCE_FLOW);
+    return this._createSequenceFlowEntries(target, replaceOptions.SEQUENCE_FLOW);
   }
 
   // flow nodes
   if (is(businessObject, 'bpmn:FlowNode')) {
-    entries = filter(replaceOptions.TASK, differentType);
+    filteredReplaceOptions = filter(replaceOptions.TASK, differentType);
 
-    // collapsed SubProcess can not be replaced with itself
-    if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(element)) {
-      entries = filter(entries, function(entry) {
-        return entry.label !== 'Sub Process (collapsed)';
+    // collapsed sub process cannot be replaced with itself
+    if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(target)) {
+      filteredReplaceOptions = filter(filteredReplaceOptions, function(replaceOption) {
+        return replaceOption.label !== 'Sub Process (collapsed)';
       });
     }
 
-    return this._createEntries(element, entries);
+    return this._createEntries(target, filteredReplaceOptions);
   }
 
-  return [];
+  return {};
 };
 
-
 /**
- * Get a list of header items for the given element. This includes buttons
- * for multi instance markers and for the ad hoc marker.
+ * @param {PopupMenuTarget} target
  *
- * @param {djs.model.Base} element
- *
- * @return {Array<Object>} a list of menu entry items
+ * @return {PopupMenuHeaderEntries}
  */
-ReplaceMenuProvider.prototype.getHeaderEntries = function(element) {
+ReplaceMenuProvider.prototype.getPopupMenuHeaderEntries = function(target) {
 
-  var headerEntries = [];
+  var headerEntries = {};
 
-  if (is(element, 'bpmn:Activity') && !isEventSubProcess(element)) {
-    headerEntries = headerEntries.concat(this._getLoopEntries(element));
+  if (is(target, 'bpmn:Activity') && !isEventSubProcess(target)) {
+    headerEntries = {
+      ...headerEntries,
+      ...this._getLoopCharacteristicsHeaderEntries(target)
+    };
   }
 
-  if (is(element, 'bpmn:DataObjectReference')) {
-    headerEntries = headerEntries.concat(this._getDataObjectIsCollection(element));
+  if (is(target, 'bpmn:DataObjectReference')) {
+    headerEntries = {
+      ...headerEntries,
+      ...this._getCollectionHeaderEntries(target)
+    };
   }
 
-  if (is(element, 'bpmn:Participant')) {
-    headerEntries = headerEntries.concat(this._getParticipantMultiplicity(element));
+  if (is(target, 'bpmn:Participant')) {
+    headerEntries = {
+      ...headerEntries,
+      ...this._getParticipantMultiplicityHeaderEntries(target)
+    };
   }
 
-  if (is(element, 'bpmn:SubProcess') &&
-      !is(element, 'bpmn:Transaction') &&
-      !isEventSubProcess(element)) {
-    headerEntries.push(this._getAdHocEntry(element));
+  if (is(target, 'bpmn:SubProcess') &&
+      !is(target, 'bpmn:Transaction') &&
+      !isEventSubProcess(target)) {
+    headerEntries = {
+      ...headerEntries,
+      ...this._getAdHocHeaderEntries(target)
+    };
   }
 
   return headerEntries;
@@ -286,50 +317,47 @@ ReplaceMenuProvider.prototype.getHeaderEntries = function(element) {
 
 
 /**
- * Creates an array of menu entry objects for a given element and filters the replaceOptions
- * according to a filter function.
+ * Create popup menu entries for the given target.
  *
- * @param  {djs.model.Base} element
- * @param  {Object} replaceOptions
+ * @param  {PopupMenuTarget} target
+ * @param  {ReplaceOption[]} replaceOptions
  *
- * @return {Array<Object>} a list of menu items
+ * @return {PopupMenuEntries}
  */
-ReplaceMenuProvider.prototype._createEntries = function(element, replaceOptions) {
-  var menuEntries = [];
+ReplaceMenuProvider.prototype._createEntries = function(target, replaceOptions) {
+  var entries = {};
 
   var self = this;
 
-  forEach(replaceOptions, function(definition) {
-    var entry = self._createMenuEntry(definition, element);
-
-    menuEntries.push(entry);
+  forEach(replaceOptions, function(replaceOption) {
+    entries[ replaceOption.actionName ] = self._createEntry(replaceOption, target);
   });
 
-  return menuEntries;
+  return entries;
 };
 
 /**
- * Creates an array of menu entry objects for a given sequence flow.
+ * Creates popup menu entries for the given sequence flow.
  *
- * @param  {djs.model.Base} element
- * @param  {Object} replaceOptions
-
- * @return {Array<Object>} a list of menu items
+ * @param  {PopupMenuTarget} target
+ * @param  {ReplaceOption[]} replaceOptions
+ *
+ * @return {PopupMenuEntries}
  */
-ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, replaceOptions) {
+ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(target, replaceOptions) {
 
-  var businessObject = getBusinessObject(element);
+  var businessObject = getBusinessObject(target);
 
-  var menuEntries = [];
+  var entries = {};
 
   var modeling = this._modeling,
       moddle = this._moddle;
 
   var self = this;
 
-  forEach(replaceOptions, function(entry) {
+  forEach(replaceOptions, function(replaceOption) {
 
-    switch (entry.actionName) {
+    switch (replaceOption.actionName) {
     case 'replace-with-default-flow':
       if (businessObject.sourceRef.default !== businessObject &&
             (is(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||
@@ -337,97 +365,103 @@ ReplaceMenuProvider.prototype._createSequenceFlowEntries = function(element, rep
              is(businessObject.sourceRef, 'bpmn:ComplexGateway') ||
              is(businessObject.sourceRef, 'bpmn:Activity'))) {
 
-        menuEntries.push(self._createMenuEntry(entry, element, function() {
-          modeling.updateProperties(element.source, { default: businessObject });
-        }));
+        entries = {
+          ...entries,
+          [ replaceOption.actionName ]: self._createEntry(replaceOption, target, function() {
+            modeling.updateProperties(target.source, { default: businessObject });
+          })
+        };
       }
       break;
     case 'replace-with-conditional-flow':
       if (!businessObject.conditionExpression && is(businessObject.sourceRef, 'bpmn:Activity')) {
 
-        menuEntries.push(self._createMenuEntry(entry, element, function() {
-          var conditionExpression = moddle.create('bpmn:FormalExpression', { body: '' });
+        entries = {
+          ...entries,
+          [ replaceOption.actionName ]: self._createEntry(replaceOption, target, function() {
+            var conditionExpression = moddle.create('bpmn:FormalExpression', { body: '' });
 
-          modeling.updateProperties(element, { conditionExpression: conditionExpression });
-        }));
+            modeling.updateProperties(target, { conditionExpression: conditionExpression });
+          })
+        };
       }
       break;
     default:
 
-      // default flows
+      // conditional flow -> sequence flow
       if (is(businessObject.sourceRef, 'bpmn:Activity') && businessObject.conditionExpression) {
-        return menuEntries.push(self._createMenuEntry(entry, element, function() {
-          modeling.updateProperties(element, { conditionExpression: undefined });
-        }));
+        entries = {
+          ...entries,
+          [ replaceOption.actionName ]: self._createEntry(replaceOption, target, function() {
+            modeling.updateProperties(target, { conditionExpression: undefined });
+          })
+        };
       }
 
-      // conditional flows
+      // default flow -> sequence flow
       if ((is(businessObject.sourceRef, 'bpmn:ExclusiveGateway') ||
            is(businessObject.sourceRef, 'bpmn:InclusiveGateway') ||
            is(businessObject.sourceRef, 'bpmn:ComplexGateway') ||
            is(businessObject.sourceRef, 'bpmn:Activity')) &&
            businessObject.sourceRef.default === businessObject) {
-
-        return menuEntries.push(self._createMenuEntry(entry, element, function() {
-          modeling.updateProperties(element.source, { default: undefined });
-        }));
+        entries = {
+          ...entries,
+          [ replaceOption.actionName ]: self._createEntry(replaceOption, target, function() {
+            modeling.updateProperties(target.source, { default: undefined });
+          })
+        };
       }
     }
   });
 
-  return menuEntries;
+  return entries;
 };
 
-
 /**
- * Creates and returns a single menu entry item.
+ * Create a popup menu entry for the given replace option.
  *
- * @param  {Object} definition a single replace options definition object
- * @param  {djs.model.Base} element
- * @param  {Function} [action] an action callback function which gets called when
- *                             the menu entry is being triggered.
+ * @param  {ReplaceOption} replaceOption
+ * @param  {PopupMenuTarget} target
+ * @param  {PopupMenuEntryAction} [action]
  *
- * @return {Object} menu entry item
+ * @return {PopupMenuEntry}
  */
-ReplaceMenuProvider.prototype._createMenuEntry = function(definition, element, action) {
+ReplaceMenuProvider.prototype._createEntry = function(replaceOption, target, action) {
   var translate = this._translate;
   var replaceElement = this._bpmnReplace.replaceElement;
 
   var replaceAction = function() {
-    return replaceElement(element, definition.target);
+    return replaceElement(target, replaceOption.target);
   };
 
-  var label = definition.label;
+  var label = replaceOption.label;
   if (label && typeof label === 'function') {
-    label = label(element);
+    label = label(target);
   }
 
   action = action || replaceAction;
 
-  var menuEntry = {
+  return {
     label: translate(label),
-    className: definition.className,
-    id: definition.actionName,
+    className: replaceOption.className,
     action: action
   };
-
-  return menuEntry;
 };
 
 /**
- * Get a list of menu items containing buttons for multi instance markers
+ * Get popup menu header entries for the loop characteristics of the given BPMN element.
  *
- * @param  {djs.model.Base} element
+ * @param  {PopupMenuTarget} target
  *
- * @return {Array<Object>} a list of menu items
+ * @return {PopupMenuHeaderEntries}
  */
-ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
+ReplaceMenuProvider.prototype._getLoopCharacteristicsHeaderEntries = function(target) {
 
   var self = this;
   var translate = this._translate;
 
   function toggleLoopEntry(event, entry) {
-    var newLoopCharacteristics = getBusinessObject(element).loopCharacteristics;
+    var newLoopCharacteristics = getBusinessObject(target).loopCharacteristics;
 
     if (entry.active) {
       newLoopCharacteristics = undefined;
@@ -439,10 +473,10 @@ ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
 
       newLoopCharacteristics.isSequential = entry.options.isSequential;
     }
-    self._modeling.updateProperties(element, { loopCharacteristics: newLoopCharacteristics });
+    self._modeling.updateProperties(target, { loopCharacteristics: newLoopCharacteristics });
   }
 
-  var businessObject = getBusinessObject(element),
+  var businessObject = getBusinessObject(target),
       loopCharacteristics = businessObject.loopCharacteristics;
 
   var isSequential,
@@ -456,9 +490,8 @@ ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
   }
 
 
-  var loopEntries = [
-    {
-      id: 'toggle-parallel-mi',
+  return {
+    'toggle-parallel-mi' : {
       className: 'bpmn-icon-parallel-mi-marker',
       title: translate('Parallel Multi Instance'),
       active: isParallel,
@@ -468,8 +501,7 @@ ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
         isSequential: false
       }
     },
-    {
-      id: 'toggle-sequential-mi',
+    'toggle-sequential-mi': {
       className: 'bpmn-icon-sequential-mi-marker',
       title: translate('Sequential Multi Instance'),
       active: isSequential,
@@ -479,8 +511,7 @@ ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
         isSequential: true
       }
     },
-    {
-      id: 'toggle-loop',
+    'toggle-loop': {
       className: 'bpmn-icon-loop-marker',
       title: translate('Loop'),
       active: isLoop,
@@ -489,57 +520,54 @@ ReplaceMenuProvider.prototype._getLoopEntries = function(element) {
         loopCharacteristics: 'bpmn:StandardLoopCharacteristics'
       }
     }
-  ];
-  return loopEntries;
+  };
 };
 
 /**
- * Get a list of menu items containing a button for the collection marker
+ * Get popup menu header entries for the collection property of the given BPMN element.
  *
- * @param  {djs.model.Base} element
+ * @param  {PopupMenuTarget} target
  *
- * @return {Array<Object>} a list of menu items
+ * @return {PopupMenuHeaderEntries}
  */
-ReplaceMenuProvider.prototype._getDataObjectIsCollection = function(element) {
+ReplaceMenuProvider.prototype._getCollectionHeaderEntries = function(target) {
 
   var self = this;
   var translate = this._translate;
 
-  var dataObject = element.businessObject.dataObjectRef;
+  var dataObject = target.businessObject.dataObjectRef;
 
   if (!dataObject) {
-    return [];
+    return {};
   }
 
   function toggleIsCollection(event, entry) {
     self._modeling.updateModdleProperties(
-      element,
+      target,
       dataObject,
       { isCollection: !entry.active });
   }
 
   var isCollection = dataObject.isCollection;
 
-  var dataObjectEntries = [
-    {
-      id: 'toggle-is-collection',
+  return {
+    'toggle-is-collection': {
       className: 'bpmn-icon-parallel-mi-marker',
       title: translate('Collection'),
       active: isCollection,
       action: toggleIsCollection,
     }
-  ];
-  return dataObjectEntries;
+  };
 };
 
 /**
- * Get a list of menu items containing a button for the participant multiplicity marker
+ * Get popup menu header entries for the participant multiplicity property of the given BPMN element.
  *
- * @param  {djs.model.Base} element
+ * @param  {PopupMenuTarget} target
  *
- * @return {Array<Object>} a list of menu items
+ * @return {PopupMenuHeaderEntries}
  */
-ReplaceMenuProvider.prototype._getParticipantMultiplicity = function(element) {
+ReplaceMenuProvider.prototype._getParticipantMultiplicityHeaderEntries = function(target) {
 
   var self = this;
   var bpmnFactory = this._bpmnFactory;
@@ -554,33 +582,30 @@ ReplaceMenuProvider.prototype._getParticipantMultiplicity = function(element) {
     }
 
     self._modeling.updateProperties(
-      element,
+      target,
       { participantMultiplicity: participantMultiplicity });
   }
 
-  var participantMultiplicity = element.businessObject.participantMultiplicity;
+  var participantMultiplicity = target.businessObject.participantMultiplicity;
 
-  var participantEntries = [
-    {
-      id: 'toggle-participant-multiplicity',
+  return {
+    'toggle-participant-multiplicity': {
       className: 'bpmn-icon-parallel-mi-marker',
       title: translate('Participant Multiplicity'),
       active: !!participantMultiplicity,
       action: toggleParticipantMultiplicity,
     }
-  ];
-  return participantEntries;
+  };
 };
 
-
 /**
- * Get the menu items containing a button for the ad hoc marker
+ * Get popup menu header entries for the ad-hoc property of the given BPMN element.
  *
- * @param  {djs.model.Base} element
+ * @param  {PopupMenuTarget} target
  *
- * @return {Object} a menu item
+ * @return {PopupMenuHeaderEntries}
  */
-ReplaceMenuProvider.prototype._getAdHocEntry = function(element) {
+ReplaceMenuProvider.prototype._getAdHocHeaderEntries = function(element) {
   var translate = this._translate;
   var businessObject = getBusinessObject(element);
 
@@ -588,25 +613,24 @@ ReplaceMenuProvider.prototype._getAdHocEntry = function(element) {
 
   var replaceElement = this._bpmnReplace.replaceElement;
 
-  var adHocEntry = {
-    id: 'toggle-adhoc',
-    className: 'bpmn-icon-ad-hoc-marker',
-    title: translate('Ad-hoc'),
-    active: isAdHoc,
-    action: function(event, entry) {
-      if (isAdHoc) {
-        return replaceElement(element, { type: 'bpmn:SubProcess' }, {
-          autoResize: false,
-          layoutConnection: false
-        });
-      } else {
-        return replaceElement(element, { type: 'bpmn:AdHocSubProcess' }, {
-          autoResize: false,
-          layoutConnection: false
-        });
+  return {
+    'toggle-adhoc': {
+      className: 'bpmn-icon-ad-hoc-marker',
+      title: translate('Ad-hoc'),
+      active: isAdHoc,
+      action: function(event, entry) {
+        if (isAdHoc) {
+          return replaceElement(element, { type: 'bpmn:SubProcess' }, {
+            autoResize: false,
+            layoutConnection: false
+          });
+        } else {
+          return replaceElement(element, { type: 'bpmn:AdHocSubProcess' }, {
+            autoResize: false,
+            layoutConnection: false
+          });
+        }
       }
     }
   };
-
-  return adHocEntry;
 };