bpmn-js 18.3.1 → 18.4.0

package/lib/draw/BpmnRenderer.js

@@ -462,8 +462,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_MESSAGE', {
         xScaleFactor: 0.9,
         yScaleFactor: 0.9,
-        containerWidth: element.width,
-        containerHeight: element.height,
+        containerWidth: attrs.width || element.width,
+        containerHeight: attrs.height || element.height,
         position: {
           mx: 0.235,
           my: 0.315
@@ -487,17 +487,23 @@ export default function BpmnRenderer(
       return messagePath;
     },
     'bpmn:TimerEventDefinition': function(parentGfx, element, attrs = {}) {
-      var circle = drawCircle(parentGfx, element.width, element.height, 0.2 * element.height, {
+      var baseWidth = attrs.width || element.width;
+      var baseHeight = attrs.height || element.height;
+
+      // use a lighter stroke for event suprocess icons
+      var strokeWidth = attrs.width ? 1 : 2;
+
+      var circle = drawCircle(parentGfx, baseWidth, baseHeight, 0.2 * baseHeight, {
         fill: getFillColor(element, defaultFillColor, attrs.fill),
         stroke: getStrokeColor(element, defaultStrokeColor, attrs.stroke),
-        strokeWidth: 2
+        strokeWidth: strokeWidth
       });
 
       var pathData = pathMap.getScaledPath('EVENT_TIMER_WH', {
         xScaleFactor: 0.75,
         yScaleFactor: 0.75,
-        containerWidth: element.width,
-        containerHeight: element.height,
+        containerWidth: baseWidth,
+        containerHeight: baseHeight,
         position: {
           mx: 0.5,
           my: 0.5
@@ -506,23 +512,23 @@ export default function BpmnRenderer(
 
       drawPath(parentGfx, pathData, {
         stroke: getStrokeColor(element, defaultStrokeColor, attrs.stroke),
-        strokeWidth: 2
+        strokeWidth: strokeWidth
       });
 
       for (var i = 0; i < 12; i++) {
         var linePathData = pathMap.getScaledPath('EVENT_TIMER_LINE', {
           xScaleFactor: 0.75,
           yScaleFactor: 0.75,
-          containerWidth: element.width,
-          containerHeight: element.height,
+          containerWidth: baseWidth,
+          containerHeight: baseHeight,
           position: {
             mx: 0.5,
             my: 0.5
           }
         });
 
-        var width = element.width / 2,
-            height = element.height / 2;
+        var width = baseWidth / 2,
+            height = baseHeight / 2;
 
         drawPath(parentGfx, linePathData, {
           strokeWidth: 1,
@@ -537,8 +543,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_ESCALATION', {
         xScaleFactor: 1,
         yScaleFactor: 1,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.5,
           my: 0.2
@@ -559,8 +565,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_CONDITIONAL', {
         xScaleFactor: 1,
         yScaleFactor: 1,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.5,
           my: 0.222
@@ -599,8 +605,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_ERROR', {
         xScaleFactor: 1.1,
         yScaleFactor: 1.1,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.2,
           my: 0.722
@@ -645,8 +651,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_COMPENSATION', {
         xScaleFactor: 1,
         yScaleFactor: 1,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.22,
           my: 0.5
@@ -667,8 +673,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_SIGNAL', {
         xScaleFactor: 0.9,
         yScaleFactor: 0.9,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.5,
           my: 0.2
@@ -689,10 +695,10 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_MULTIPLE', {
         xScaleFactor: 1.1,
         yScaleFactor: 1.1,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
-          mx: 0.222,
+          mx: 0.211,
           my: 0.36
         }
       });
@@ -703,6 +709,7 @@ export default function BpmnRenderer(
 
       return drawPath(parentGfx, pathData, {
         fill,
+        stroke: getStrokeColor(event, defaultStrokeColor, attrs.stroke),
         strokeWidth: 1
       });
     },
@@ -710,8 +717,8 @@ export default function BpmnRenderer(
       var pathData = pathMap.getScaledPath('EVENT_PARALLEL_MULTIPLE', {
         xScaleFactor: 1.2,
         yScaleFactor: 1.2,
-        containerWidth: event.width,
-        containerHeight: event.height,
+        containerWidth: attrs.width || event.width,
+        containerHeight: attrs.height || event.height,
         position: {
           mx: 0.458,
           my: 0.194
@@ -735,57 +742,59 @@ export default function BpmnRenderer(
     }
   };
 
-  function renderEventIcon(element, parentGfx, attrs = {}) {
+  function renderEventIcon(element, parentGfx, attrs = {}, proxyElement) {
     var semantic = getSemantic(element),
         isThrowing = isThrowEvent(semantic);
 
+    var nodeElement = proxyElement || element;
+
     if (semantic.get('eventDefinitions') && semantic.get('eventDefinitions').length > 1) {
       if (semantic.get('parallelMultiple')) {
-        return eventIconRenderers[ 'bpmn:ParallelMultipleEventDefinition' ](parentGfx, element, attrs, isThrowing);
+        return eventIconRenderers[ 'bpmn:ParallelMultipleEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
       }
       else {
-        return eventIconRenderers[ 'bpmn:MultipleEventDefinition' ](parentGfx, element, attrs, isThrowing);
+        return eventIconRenderers[ 'bpmn:MultipleEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
       }
     }
 
     if (isTypedEvent(semantic, 'bpmn:MessageEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:MessageEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:MessageEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:TimerEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:TimerEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:TimerEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:ConditionalEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:ConditionalEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:ConditionalEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:SignalEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:SignalEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:SignalEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:EscalationEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:EscalationEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:EscalationEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:LinkEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:LinkEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:LinkEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:ErrorEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:ErrorEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:ErrorEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:CancelEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:CancelEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:CancelEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:CompensateEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:CompensateEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:CompensateEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     if (isTypedEvent(semantic, 'bpmn:TerminateEventDefinition')) {
-      return eventIconRenderers[ 'bpmn:TerminateEventDefinition' ](parentGfx, element, attrs, isThrowing);
+      return eventIconRenderers[ 'bpmn:TerminateEventDefinition' ](parentGfx, nodeElement, attrs, isThrowing);
     }
 
     return null;
@@ -1207,14 +1216,23 @@ export default function BpmnRenderer(
   function renderSubProcess(parentGfx, element, attrs = {}) {
     var activity = renderActivity(parentGfx, element, attrs);
 
+    var expanded = isExpanded(element);
+
     if (isEventSubProcess(element)) {
       svgAttr(activity, {
         strokeDasharray: '0, 5.5',
         strokeWidth: 2.5
       });
-    }
 
-    var expanded = isExpanded(element);
+      if (!expanded) {
+        var flowElements = getSemantic(element).flowElements || [];
+        var startEvents = flowElements.filter(e => is(e, 'bpmn:StartEvent'));
+
+        if (startEvents.length === 1) {
+          renderEventSubProcessIcon(startEvents[0], parentGfx, attrs, element);
+        }
+      }
+    }
 
     renderEmbeddedLabel(parentGfx, element, expanded ? 'center-top' : 'center-middle', attrs);
 
@@ -1227,6 +1245,39 @@ export default function BpmnRenderer(
     return activity;
   }
 
+  function renderEventSubProcessIcon(startEvent, parentGfx, attrs, proxyElement) {
+    var iconSize = 22;
+
+    // match the colors of the enclosing subprocess
+    var proxyAttrs = {
+      fill: getFillColor(proxyElement, defaultFillColor, attrs.fill),
+      stroke: getStrokeColor(proxyElement, defaultStrokeColor, attrs.stroke),
+      width: iconSize,
+      height: iconSize
+    };
+
+    var interrupting = getSemantic(startEvent).isInterrupting;
+    var strokeDasharray = interrupting ? 0 : 3;
+
+    // better visibility for non-interrupting events
+    var strokeWidth = interrupting ? 1 : 1.2;
+
+    // make the icon look larger by drawing a smaller circle
+    var circleSize = 20;
+    var shift = (iconSize - circleSize) / 2;
+    var transform = 'translate(' + shift + ',' + shift + ')';
+
+    drawCircle(parentGfx, circleSize, circleSize, {
+      fill: proxyAttrs.fill,
+      stroke: proxyAttrs.stroke,
+      strokeWidth,
+      strokeDasharray,
+      transform
+    });
+
+    renderEventIcon(startEvent, parentGfx, proxyAttrs, proxyElement);
+  }
+
   function renderTask(parentGfx, element, attrs = {}) {
     var activity = renderActivity(parentGfx, element, attrs);
 

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

@@ -26,6 +26,7 @@ export default function SubProcessStartEventBehavior(injector, modeling) {
 
     if (
       !is(newShape, 'bpmn:SubProcess') ||
+      is(newShape,'bpmn:AdHocSubProcess') ||
       ! (is(oldShape, 'bpmn:Task') || is(oldShape, 'bpmn:CallActivity')) ||
       !isExpanded(newShape)
     ) {

package/lib/features/modeling/behavior/index.d.ts

@@ -1,2 +1,85 @@
-declare const _default: import("didi").ModuleDeclaration;
+declare const _default: {
+  adaptiveLabelPositioningBehavior: (string | typeof AdaptiveLabelPositioningBehavior)[];
+  appendBehavior: (string | typeof AppendBehavior)[];
+  associationBehavior: (string | typeof AssociationBehavior)[];
+  attachEventBehavior: (string | typeof AttachEventBehavior)[];
+  boundaryEventBehavior: (string | typeof BoundaryEventBehavior)[];
+  compensateBoundaryEventBehaviour: (string | typeof CompensateBoundaryEventBehavior)[];
+  createBehavior: (string | typeof CreateBehavior)[];
+  createDataObjectBehavior: (string | typeof CreateDataObjectBehavior)[];
+  createParticipantBehavior: (string | typeof CreateParticipantBehavior)[];
+  dataInputAssociationBehavior: (string | typeof DataInputAssociationBehavior)[];
+  dataStoreBehavior: (string | typeof DataStoreBehavior)[];
+  deleteLaneBehavior: (string | typeof DeleteLaneBehavior)[];
+  detachEventBehavior: (string | typeof DetachEventBehavior)[];
+  dropOnFlowBehavior: (string | typeof DropOnFlowBehavior)[];
+  eventBasedGatewayBehavior: (string | typeof EventBasedGatewayBehavior)[];
+  fixHoverBehavior: (string | typeof FixHoverBehavior)[];
+  groupBehavior: (string | typeof GroupBehavior)[];
+  importDockingFix: (string | typeof ImportDockingFix)[];
+  isHorizontalFix: (string | typeof IsHorizontalFix)[];
+  labelBehavior: (string | typeof LabelBehavior)[];
+  layoutConnectionBehavior: (string | typeof LayoutConnectionBehavior)[];
+  messageFlowBehavior: (string | typeof MessageFlowBehavior)[];
+  nonInterruptingBehavior: (string | typeof NonInterruptingBehavior)[];
+  removeElementBehavior: (string | typeof RemoveElementBehavior)[];
+  removeEmbeddedLabelBoundsBehavior: (string | typeof RemoveEmbeddedLabelBoundsBehavior)[];
+  removeParticipantBehavior: (string | typeof RemoveParticipantBehavior)[];
+  replaceConnectionBehavior: (string | typeof ReplaceConnectionBehavior)[];
+  replaceElementBehaviour: (string | typeof ReplaceElementBehaviour)[];
+  resizeBehavior: (string | typeof ResizeBehavior)[];
+  resizeLaneBehavior: (string | typeof ResizeLaneBehavior)[];
+  rootElementReferenceBehavior: (string | typeof RootElementReferenceBehavior)[];
+  spaceToolBehavior: (string | typeof SpaceToolBehavior)[];
+  subProcessPlaneBehavior: (string | typeof SubProcessPlaneBehavior)[];
+  subProcessStartEventBehavior: (string | typeof SubProcessStartEventBehavior)[];
+  textAnnotationBehavior: (string | typeof TextAnnotationBehavior)[];
+  toggleCollapseConnectionBehaviour: (string | typeof ToggleCollapseConnectionBehaviour)[];
+  toggleElementCollapseBehaviour: (string | typeof ToggleElementCollapseBehaviour)[];
+  unclaimIdBehavior: (string | typeof UnclaimIdBehavior)[];
+  unsetDefaultFlowBehavior: (string | typeof UnsetDefaultFlowBehavior)[];
+  updateFlowNodeRefsBehavior: (string | typeof UpdateFlowNodeRefsBehavior)[];
+  setCompensationActivityAfterPasteBehavior: (string | typeof SetCompensationActivityAfterPasteBehavior)[];
+};
 export default _default;
+import AdaptiveLabelPositioningBehavior from './AdaptiveLabelPositioningBehavior';
+import AppendBehavior from './AppendBehavior';
+import AssociationBehavior from './AssociationBehavior';
+import AttachEventBehavior from './AttachEventBehavior';
+import BoundaryEventBehavior from './BoundaryEventBehavior';
+import CompensateBoundaryEventBehavior from './CompensateBoundaryEventBehavior';
+import CreateBehavior from './CreateBehavior';
+import CreateDataObjectBehavior from './CreateDataObjectBehavior';
+import CreateParticipantBehavior from './CreateParticipantBehavior';
+import DataInputAssociationBehavior from './DataInputAssociationBehavior';
+import DataStoreBehavior from './DataStoreBehavior';
+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 LayoutConnectionBehavior from './LayoutConnectionBehavior';
+import MessageFlowBehavior from './MessageFlowBehavior';
+import NonInterruptingBehavior from './NonInterruptingBehavior';
+import RemoveElementBehavior from './RemoveElementBehavior';
+import RemoveEmbeddedLabelBoundsBehavior from './RemoveEmbeddedLabelBoundsBehavior';
+import RemoveParticipantBehavior from './RemoveParticipantBehavior';
+import ReplaceConnectionBehavior from './ReplaceConnectionBehavior';
+import ReplaceElementBehaviour from './ReplaceElementBehaviour';
+import ResizeBehavior from './ResizeBehavior';
+import ResizeLaneBehavior from './ResizeLaneBehavior';
+import RootElementReferenceBehavior from './RootElementReferenceBehavior';
+import SpaceToolBehavior from './SpaceToolBehavior';
+import SubProcessPlaneBehavior from './SubProcessPlaneBehavior';
+import SubProcessStartEventBehavior from './SubProcessStartEventBehavior';
+import TextAnnotationBehavior from './TextAnnotationBehavior';
+import ToggleCollapseConnectionBehaviour from './ToggleCollapseConnectionBehaviour';
+import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
+import UnclaimIdBehavior from './UnclaimIdBehavior';
+import UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';
+import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
+import SetCompensationActivityAfterPasteBehavior from './SetCompensationActivityAfterPasteBehavior';

package/lib/features/modeling-feedback/ModelingFeedback.js

@@ -7,6 +7,7 @@ import { is } from '../../util/ModelUtil';
  */
 
 var COLLAB_ERR_MSG = 'flow elements must be children of pools/participants';
+var DATA_OBJECT_ERR_MSG = 'Data object must be placed within a pool/participant.';
 
 /**
  * @param {EventBus} eventBus
@@ -32,8 +33,12 @@ export default function ModelingFeedback(eventBus, tooltips, translate) {
         shape = context.shape,
         target = context.target;
 
-    if (is(target, 'bpmn:Collaboration') && is(shape, 'bpmn:FlowNode')) {
-      showError(event, translate(COLLAB_ERR_MSG));
+    if (is(target, 'bpmn:Collaboration')) {
+      if (is(shape, 'bpmn:FlowNode')) {
+        showError(event, translate(COLLAB_ERR_MSG));
+      } else if (is(shape, 'bpmn:DataObjectReference')) {
+        showError(event, translate(DATA_OBJECT_ERR_MSG));
+      }
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "18.3.1",
+  "version": "18.4.0",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "lib/index.js",
   "files": [
@@ -70,7 +70,7 @@
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-replace": "^6.0.0",
     "@rollup/plugin-terser": "^0.4.4",
-    "babel-loader": "^9.2.1",
+    "babel-loader": "^10.0.0",
     "babel-plugin-istanbul": "^7.0.0",
     "bio-dts": "^0.11.0",
     "bpmn-font": "^0.12.1",
@@ -81,8 +81,8 @@
     "cross-env": "^7.0.3",
     "del": "^8.0.0",
     "del-cli": "^6.0.0",
-    "eslint": "^9.12.0",
-    "eslint-plugin-bpmn-io": "^2.0.2",
+    "eslint": "^9.21.0",
+    "eslint-plugin-bpmn-io": "^2.2.0",
     "execa": "^9.0.0",
     "file-drops": "^0.5.0",
     "karma": "^6.4.4",
@@ -106,7 +106,7 @@
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
     "ts-expect": "^1.3.0",
-    "typescript": "^5.6.3",
+    "typescript": "^5.7.3",
     "webpack": "^5.95.0"
   },
   "dependencies": {