bpmn-js 18.1.2 → 18.3.0

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

@@ -100,6 +100,9 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
 
   var rules = this._rules;
 
+  var sameTypeEventOptions = [],
+      eventDefinitionType;
+
   var filteredReplaceOptions = [];
 
   if (isArray(target) || !rules.allowed('shape.replace', { element: target })) {
@@ -116,10 +119,26 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
     return this._createEntries(target, replaceOptions.DATA_STORE_REFERENCE);
   }
 
+  // typed start, intermediate, and end events
+  if (is(businessObject, 'bpmn:Event') && !is(businessObject, 'bpmn:BoundaryEvent')) {
+    eventDefinitionType = businessObject.get('eventDefinitions')[0]?.$type;
+
+    sameTypeEventOptions = replaceOptions.TYPED_EVENT[eventDefinitionType] || [];
+
+    if (!isEventSubProcess(businessObject.$parent) && is(businessObject.$parent, 'bpmn:SubProcess')) {
+      sameTypeEventOptions = filter(sameTypeEventOptions, function(option) {
+        return option.target.type !== 'bpmn:StartEvent';
+      });
+    }
+  }
+
   // start events outside sub processes
   if (is(businessObject, 'bpmn:StartEvent') && !is(businessObject.$parent, 'bpmn:SubProcess')) {
 
-    filteredReplaceOptions = filter(replaceOptions.START_EVENT, differentType);
+    filteredReplaceOptions = filter(
+      replaceOptions.START_EVENT.concat(sameTypeEventOptions),
+      differentType
+    );
 
     return this._createEntries(target, filteredReplaceOptions);
   }
@@ -136,18 +155,20 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
 
   // start events inside event sub processes
   if (is(businessObject, 'bpmn:StartEvent') && isEventSubProcess(businessObject.$parent)) {
-    filteredReplaceOptions = filter(replaceOptions.EVENT_SUB_PROCESS_START_EVENT, function(replaceOption) {
+    filteredReplaceOptions = filter(
+      replaceOptions.EVENT_SUB_PROCESS_START_EVENT.concat(sameTypeEventOptions), function(replaceOption) {
 
-      var target = replaceOption.target;
+        var target = replaceOption.target;
 
-      var isInterrupting = target.isInterrupting !== false;
+        var isInterrupting = target.isInterrupting !== false;
 
-      var isInterruptingEqual = businessObject.isInterrupting === isInterrupting;
+        var isInterruptingEqual = businessObject.isInterrupting === isInterrupting;
 
-      // filters elements which types and event definition are equal but have have different interrupting types
-      return differentType(replaceOption) || !differentType(replaceOption) && !isInterruptingEqual;
+        // filters elements which types and event definition are equal but have have different interrupting types
+        return differentType(replaceOption) || !differentType(replaceOption) && !isInterruptingEqual;
 
-    });
+      }
+    );
 
     return this._createEntries(target, filteredReplaceOptions);
   }
@@ -155,7 +176,10 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
   // start events inside sub processes
   if (is(businessObject, 'bpmn:StartEvent') && !isEventSubProcess(businessObject.$parent)
       && is(businessObject.$parent, 'bpmn:SubProcess')) {
-    filteredReplaceOptions = filter(replaceOptions.START_EVENT_SUB_PROCESS, differentType);
+    filteredReplaceOptions = filter(
+      replaceOptions.START_EVENT_SUB_PROCESS.concat(sameTypeEventOptions),
+      differentType
+    );
 
     return this._createEntries(target, filteredReplaceOptions);
   }
@@ -163,7 +187,7 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
   // end events
   if (is(businessObject, 'bpmn:EndEvent')) {
 
-    filteredReplaceOptions = filter(replaceOptions.END_EVENT, function(replaceOption) {
+    filteredReplaceOptions = filter(replaceOptions.END_EVENT.concat(sameTypeEventOptions), function(replaceOption) {
       var target = replaceOption.target;
 
       // hide cancel end events outside transactions
@@ -202,7 +226,10 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
   if (is(businessObject, 'bpmn:IntermediateCatchEvent') ||
       is(businessObject, 'bpmn:IntermediateThrowEvent')) {
 
-    filteredReplaceOptions = filter(replaceOptions.INTERMEDIATE_EVENT, differentType);
+    filteredReplaceOptions = filter(
+      replaceOptions.INTERMEDIATE_EVENT.concat(sameTypeEventOptions),
+      differentType
+    );
 
     return this._createEntries(target, filteredReplaceOptions);
   }
@@ -231,6 +258,14 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
     return this._createEntries(target, filteredReplaceOptions);
   }
 
+  // expanded ad hoc sub processes
+  if (is(businessObject, 'bpmn:AdHocSubProcess') && isExpanded(target)) {
+
+    filteredReplaceOptions = filter(replaceOptions.AD_HOC_SUBPROCESS_EXPANDED, differentType);
+
+    return this._createEntries(target, filteredReplaceOptions);
+  }
+
   // expanded sub processes
   if (is(businessObject, 'bpmn:SubProcess') && isExpanded(target)) {
 
@@ -239,18 +274,16 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
     return this._createEntries(target, filteredReplaceOptions);
   }
 
-  // collapsed ad hoc sub processes
-  if (is(businessObject, 'bpmn:AdHocSubProcess') && !isExpanded(target)) {
+  // collapsed sub process or collapsed ad hoc sub process
+  if (is(businessObject, 'bpmn:SubProcess') && !isExpanded(target)) {
 
     filteredReplaceOptions = filter(replaceOptions.TASK, function(replaceOption) {
 
-      var target = replaceOption.target;
-
-      var isTargetSubProcess = target.type === 'bpmn:SubProcess';
+      var isTargetSameType = replaceOption.target.type === target.type;
+      var isTargetExpanded = replaceOption.target.isExpanded === true;
 
-      var isTargetExpanded = target.isExpanded === true;
-
-      return isDifferentType(target, target) && (!isTargetSubProcess || isTargetExpanded);
+      // Collapsed subprocess cannot be replaced with itself or expanded subprocess of different type.
+      return isTargetSameType === isTargetExpanded;
     });
 
     return this._createEntries(target, filteredReplaceOptions);
@@ -265,13 +298,6 @@ ReplaceMenuProvider.prototype.getPopupMenuEntries = function(target) {
   if (is(businessObject, 'bpmn:FlowNode')) {
     filteredReplaceOptions = filter(replaceOptions.TASK, differentType);
 
-    // 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(target, filteredReplaceOptions);
   }
 
@@ -308,15 +334,6 @@ ReplaceMenuProvider.prototype.getPopupMenuHeaderEntries = function(target) {
     };
   }
 
-  if (is(target, 'bpmn:SubProcess') &&
-      !is(target, 'bpmn:Transaction') &&
-      !isEventSubProcess(target)) {
-    headerEntries = {
-      ...headerEntries,
-      ...this._getAdHocHeaderEntries(target)
-    };
-  }
-
   if (canBeNonInterrupting(target)) {
     headerEntries = {
       ...headerEntries,
@@ -614,44 +631,6 @@ ReplaceMenuProvider.prototype._getParticipantMultiplicityHeaderEntries = functio
   };
 };
 
-/**
- * Get popup menu header entries for the ad-hoc property of the given BPMN element.
- *
- * @param  {PopupMenuTarget} element
- *
- * @return {PopupMenuHeaderEntries}
- */
-ReplaceMenuProvider.prototype._getAdHocHeaderEntries = function(element) {
-  var translate = this._translate;
-  var businessObject = getBusinessObject(element);
-
-  var isAdHoc = is(businessObject, 'bpmn:AdHocSubProcess');
-
-  var replaceElement = this._bpmnReplace.replaceElement;
-
-  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
-          });
-        }
-      }
-    }
-  };
-};
-
-
 ReplaceMenuProvider.prototype._getNonInterruptingHeaderEntries = function(element) {
   const translate = this._translate;
   const businessObject = getBusinessObject(element);

package/lib/features/replace/BpmnReplace.js

@@ -145,7 +145,7 @@ export default function BpmnReplace(
     var type = targetElement.type,
         oldBusinessObject = element.businessObject;
 
-    if (isSubProcess(oldBusinessObject) && type === 'bpmn:SubProcess') {
+    if (isSubProcess(oldBusinessObject) && (type === 'bpmn:SubProcess' || type === 'bpmn:AdHocSubProcess')) {
       if (shouldToggleCollapsed(element, targetElement)) {
 
         // expanding or collapsing process

package/lib/features/replace/ReplaceOptions.d.ts

@@ -22,6 +22,10 @@ export const GATEWAY: ReplaceOption[];
  * @type {ReplaceOption[]}
  */
 export const SUBPROCESS_EXPANDED: ReplaceOption[];
+/**
+ * @type {ReplaceOption[]}
+ */
+export const AD_HOC_SUBPROCESS_EXPANDED: ReplaceOption[];
 /**
  * @type {ReplaceOption[]}
  */
@@ -58,6 +62,12 @@ export const SEQUENCE_FLOW: ReplaceOption[];
  * @type {ReplaceOption[]}
  */
 export const PARTICIPANT: ReplaceOption[];
+/**
+ * @type {{ [key: string]: ReplaceOption[]}}
+ */
+export const TYPED_EVENT: {
+    [key: string]: ReplaceOption[];
+};
 export type LabelGetter = () => string;
 export type ReplaceOption = {
     label: string | LabelGetter;

package/lib/features/replace/ReplaceOptions.js

@@ -427,6 +427,15 @@ export var SUBPROCESS_EXPANDED = [
       isExpanded: true
     }
   },
+  {
+    label: 'Ad-hoc sub-process',
+    actionName: 'replace-with-ad-hoc-subprocess',
+    className: 'bpmn-icon-subprocess-expanded',
+    target: {
+      type: 'bpmn:AdHocSubProcess',
+      isExpanded: true
+    }
+  },
   {
     label: 'Sub-process (collapsed)',
     actionName: 'replace-with-collapsed-subprocess',
@@ -438,6 +447,49 @@ export var SUBPROCESS_EXPANDED = [
   }
 ];
 
+/**
+ * @type {ReplaceOption[]}
+ */
+export var AD_HOC_SUBPROCESS_EXPANDED = [
+  {
+    label: 'Sub-process',
+    actionName: 'replace-with-subprocess',
+    className: 'bpmn-icon-subprocess-expanded',
+    target: {
+      type: 'bpmn:SubProcess',
+      isExpanded: true
+    }
+  },
+  {
+    label: 'Transaction',
+    actionName: 'replace-with-transaction',
+    className: 'bpmn-icon-transaction',
+    target: {
+      type: 'bpmn:Transaction',
+      isExpanded: true
+    }
+  },
+  {
+    label: 'Event sub-process',
+    actionName: 'replace-with-event-subprocess',
+    className: 'bpmn-icon-event-subprocess-expanded',
+    target: {
+      type: 'bpmn:SubProcess',
+      triggeredByEvent: true,
+      isExpanded: true
+    }
+  },
+  {
+    label: 'Ad-hoc sub-process (collapsed)',
+    actionName: 'replace-with-collapsed-ad-hoc-subprocess',
+    className: 'bpmn-icon-subprocess-collapsed',
+    target: {
+      type: 'bpmn:AdHocSubProcess',
+      isExpanded: false
+    }
+  }
+];
+
 /**
  * @type {ReplaceOption[]}
  */
@@ -460,6 +512,15 @@ export var TRANSACTION = [
       isExpanded: true
     }
   },
+  {
+    label: 'Ad-hoc sub-process',
+    actionName: 'replace-with-ad-hoc-subprocess',
+    className: 'bpmn-icon-subprocess-expanded',
+    target: {
+      type: 'bpmn:AdHocSubProcess',
+      isExpanded: true
+    }
+  },
   {
     label: 'Event sub-process',
     actionName: 'replace-with-event-subprocess',
@@ -570,6 +631,24 @@ export var TASK = [
       type: 'bpmn:SubProcess',
       isExpanded: true
     }
+  },
+  {
+    label: 'Ad-hoc sub-process (collapsed)',
+    actionName: 'replace-with-collapsed-ad-hoc-subprocess',
+    className: 'bpmn-icon-subprocess-collapsed',
+    target: {
+      type: 'bpmn:AdHocSubProcess',
+      isExpanded: false
+    }
+  },
+  {
+    label: 'Ad-hoc sub-process (expanded)',
+    actionName: 'replace-with-ad-hoc-subprocess',
+    className: 'bpmn-icon-subprocess-expanded',
+    target: {
+      type: 'bpmn:AdHocSubProcess',
+      isExpanded: true
+    }
   }
 ];
 
@@ -917,3 +996,203 @@ export var PARTICIPANT = [
     }
   }
 ];
+
+/**
+ * @type {{ [key: string]: ReplaceOption[]}}
+ */
+export var TYPED_EVENT = {
+  'bpmn:MessageEventDefinition': [
+    {
+      label: 'Message start event',
+      actionName: 'replace-with-message-start',
+      className: 'bpmn-icon-start-event-message',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:MessageEventDefinition'
+      }
+    },
+    {
+      label: 'Message intermediate catch event',
+      actionName: 'replace-with-message-intermediate-catch',
+      className: 'bpmn-icon-intermediate-event-catch-message',
+      target: {
+        type: 'bpmn:IntermediateCatchEvent',
+        eventDefinitionType: 'bpmn:MessageEventDefinition'
+      }
+    },
+    {
+      label: 'Message intermediate throw event',
+      actionName: 'replace-with-message-intermediate-throw',
+      className: 'bpmn-icon-intermediate-event-throw-message',
+      target: {
+        type: 'bpmn:IntermediateThrowEvent',
+        eventDefinitionType: 'bpmn:MessageEventDefinition'
+      }
+    },
+    {
+      label: 'Message end event',
+      actionName: 'replace-with-message-end',
+      className: 'bpmn-icon-end-event-message',
+      target: {
+        type: 'bpmn:EndEvent',
+        eventDefinitionType: 'bpmn:MessageEventDefinition'
+      }
+    }
+  ],
+  'bpmn:TimerEventDefinition': [
+    {
+      label: 'Timer start event',
+      actionName: 'replace-with-timer-start',
+      className: 'bpmn-icon-start-event-timer',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:TimerEventDefinition'
+      }
+    },
+    {
+      label: 'Timer intermediate catch event',
+      actionName: 'replace-with-timer-intermediate-catch',
+      className: 'bpmn-icon-intermediate-event-catch-timer',
+      target: {
+        type: 'bpmn:IntermediateCatchEvent',
+        eventDefinitionType: 'bpmn:TimerEventDefinition'
+      }
+    }
+  ],
+  'bpmn:ConditionalEventDefinition': [
+    {
+      label: 'Conditional start event',
+      actionName: 'replace-with-conditional-start',
+      className: 'bpmn-icon-start-event-condition',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:ConditionalEventDefinition'
+      }
+    },
+    {
+      label: 'Conditional intermediate catch event',
+      actionName: 'replace-with-conditional-intermediate-catch',
+      className: 'bpmn-icon-intermediate-event-catch-condition',
+      target: {
+        type: 'bpmn:IntermediateCatchEvent',
+        eventDefinitionType: 'bpmn:ConditionalEventDefinition'
+      }
+    }
+  ],
+  'bpmn:SignalEventDefinition': [
+    {
+      label: 'Signal start event',
+      actionName: 'replace-with-signal-start',
+      className: 'bpmn-icon-start-event-signal',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:SignalEventDefinition'
+      }
+    },
+    {
+      label: 'Signal intermediate catch event',
+      actionName: 'replace-with-signal-intermediate-catch',
+      className: 'bpmn-icon-intermediate-event-catch-signal',
+      target: {
+        type: 'bpmn:IntermediateCatchEvent',
+        eventDefinitionType: 'bpmn:SignalEventDefinition'
+      }
+    },
+    {
+      label: 'Signal intermediate throw event',
+      actionName: 'replace-with-signal-intermediate-throw',
+      className: 'bpmn-icon-intermediate-event-throw-signal',
+      target: {
+        type: 'bpmn:IntermediateThrowEvent',
+        eventDefinitionType: 'bpmn:SignalEventDefinition'
+      }
+    },
+    {
+      label: 'Signal end event',
+      actionName: 'replace-with-signal-end',
+      className: 'bpmn-icon-end-event-signal',
+      target: {
+        type: 'bpmn:EndEvent',
+        eventDefinitionType: 'bpmn:SignalEventDefinition'
+      }
+    }
+  ],
+  'bpmn:ErrorEventDefinition': [
+    {
+      label: 'Error start event',
+      actionName: 'replace-with-error-start',
+      className: 'bpmn-icon-start-event-error',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:ErrorEventDefinition'
+      }
+    },
+    {
+      label: 'Error end event',
+      actionName: 'replace-with-error-end',
+      className: 'bpmn-icon-end-event-error',
+      target: {
+        type: 'bpmn:EndEvent',
+        eventDefinitionType: 'bpmn:ErrorEventDefinition'
+      }
+    }
+  ],
+  'bpmn:EscalationEventDefinition': [
+    {
+      label: 'Escalation start event',
+      actionName: 'replace-with-escalation-start',
+      className: 'bpmn-icon-start-event-escalation',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:EscalationEventDefinition'
+      }
+    },
+    {
+      label: 'Escalation intermediate throw event',
+      actionName: 'replace-with-escalation-intermediate-throw',
+      className: 'bpmn-icon-intermediate-event-throw-escalation',
+      target: {
+        type: 'bpmn:IntermediateThrowEvent',
+        eventDefinitionType: 'bpmn:EscalationEventDefinition'
+      }
+    },
+    {
+      label: 'Escalation end event',
+      actionName: 'replace-with-escalation-end',
+      className: 'bpmn-icon-end-event-escalation',
+      target: {
+        type: 'bpmn:EndEvent',
+        eventDefinitionType: 'bpmn:EscalationEventDefinition'
+      }
+    }
+  ],
+  'bpmn:CompensateEventDefinition': [
+    {
+      label: 'Compensation start event',
+      actionName: 'replace-with-compensation-start',
+      className: 'bpmn-icon-start-event-compensation',
+      target: {
+        type: 'bpmn:StartEvent',
+        eventDefinitionType: 'bpmn:CompensateEventDefinition'
+      }
+    },
+    {
+      label: 'Compensation intermediate throw event',
+      actionName: 'replace-with-compensation-intermediate-throw',
+      className: 'bpmn-icon-intermediate-event-throw-compensation',
+      target: {
+        type: 'bpmn:IntermediateThrowEvent',
+        eventDefinitionType: 'bpmn:CompensateEventDefinition'
+      }
+    },
+    {
+      label: 'Compensation end event',
+      actionName: 'replace-with-compensation-end',
+      className: 'bpmn-icon-end-event-compensation',
+      target: {
+        type: 'bpmn:EndEvent',
+        eventDefinitionType: 'bpmn:CompensateEventDefinition'
+      }
+    }
+  ]
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "18.1.2",
+  "version": "18.3.0",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "lib/index.js",
   "files": [
@@ -98,7 +98,7 @@
     "mocha": "^10.7.3",
     "mocha-test-container-support": "0.2.0",
     "npm-run-all2": "^7.0.0",
-    "puppeteer": "^23.6.1",
+    "puppeteer": "^24.0.0",
     "remark-cli": "^12.0.0",
     "remark-preset-bpmn-io": "^0.2.1",
     "rollup": "^4.0.0",