bpmn-js 18.6.0 → 18.6.2

package/lib/draw/BpmnRenderer.js

@@ -951,7 +951,7 @@ export default function BpmnRenderer(
     taskMarkerRenderers[ type ](parentGfx, element, attrs);
   }
 
-  function renderTaskMarkers(parentGfx, element, taskMarkers, attrs = {}) {
+  function renderTaskMarkers(parentGfx, element, taskMarkers = [], attrs = {}) {
     attrs = {
       fill: attrs.fill,
       stroke: attrs.stroke,
@@ -961,14 +961,14 @@ export default function BpmnRenderer(
 
     var semantic = getSemantic(element);
 
-    var subprocess = taskMarkers && taskMarkers.includes('SubProcessMarker');
+    var subprocess = taskMarkers.includes('SubProcessMarker');
 
     if (subprocess) {
       attrs = {
         ...attrs,
         seq: -21,
         parallel: -22,
-        compensation: -42,
+        compensation: -25,
         loop: -18,
         adhoc: 10
       };
@@ -977,22 +977,22 @@ export default function BpmnRenderer(
         ...attrs,
         seq: -5,
         parallel: -6,
-        compensation: -27,
+        compensation: -7,
         loop: 0,
-        adhoc: 10
+        adhoc: -8
       };
     }
 
-    forEach(taskMarkers, function(marker) {
-      renderTaskMarker(marker, parentGfx, element, attrs);
-    });
-
     if (semantic.get('isForCompensation')) {
-      renderTaskMarker('CompensationMarker', parentGfx, element, attrs);
+      taskMarkers.push('CompensationMarker');
     }
 
     if (is(semantic, 'bpmn:AdHocSubProcess')) {
-      renderTaskMarker('AdhocMarker', parentGfx, element, attrs);
+      taskMarkers.push('AdhocMarker');
+
+      if (!subprocess) {
+        assign(attrs, { compensation: attrs.compensation - 18 });
+      }
     }
 
     var loopCharacteristics = semantic.get('loopCharacteristics'),
@@ -1000,18 +1000,40 @@ export default function BpmnRenderer(
 
     if (loopCharacteristics) {
 
+      assign(attrs, {
+        compensation: attrs.compensation - 18,
+      });
+
+      if (taskMarkers.includes('AdhocMarker')) {
+        assign(attrs, {
+          seq: -23,
+          loop: -18,
+          parallel: -24
+        });
+      }
+
       if (isSequential === undefined) {
-        renderTaskMarker('LoopMarker', parentGfx, element, attrs);
+        taskMarkers.push('LoopMarker');
       }
 
       if (isSequential === false) {
-        renderTaskMarker('ParallelMarker', parentGfx, element, attrs);
+        taskMarkers.push('ParallelMarker');
       }
 
       if (isSequential === true) {
-        renderTaskMarker('SequentialMarker', parentGfx, element, attrs);
+        taskMarkers.push('SequentialMarker');
       }
     }
+
+    if (taskMarkers.includes('CompensationMarker') && taskMarkers.length === 1) {
+      assign(attrs, {
+        compensation: -8
+      });
+    }
+
+    forEach(taskMarkers, function(marker) {
+      renderTaskMarker(marker, parentGfx, element, attrs);
+    });
   }
 
   function renderLabel(parentGfx, label, attrs = {}) {

package/lib/features/copy-paste/ModdleCopy.js

@@ -4,14 +4,15 @@ import {
   has,
   isArray,
   isDefined,
-  isFunction,
   isObject,
   matchPattern,
   reduce,
   sortBy
 } from 'min-dash';
 
-var DISALLOWED_PROPERTIES = [
+import { is } from '../../util/ModelUtil';
+
+const DISALLOWED_PROPERTIES = [
   'artifacts',
   'dataInputAssociations',
   'dataOutputAssociations',
@@ -23,6 +24,13 @@ var DISALLOWED_PROPERTIES = [
   'categoryValue'
 ];
 
+const ALLOWED_REFERENCES = [
+  'errorRef',
+  'escalationRef',
+  'messageRef',
+  'signalRef'
+];
+
 /**
  * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
  * @typedef {import('../modeling/BpmnFactory').default} BpmnFactory
@@ -44,25 +52,35 @@ export default function ModdleCopy(eventBus, bpmnFactory, moddle) {
   this._moddle = moddle;
 
   // copy extension elements last
-  eventBus.on('moddleCopy.canCopyProperties', function(context) {
-    var propertyNames = context.propertyNames;
+  eventBus.on('moddleCopy.canCopyProperties', (context) => {
+    const { propertyNames } = context;
 
     if (!propertyNames || !propertyNames.length) {
       return;
     }
 
-    return sortBy(propertyNames, function(propertyName) {
+    return sortBy(propertyNames, (propertyName) => {
       return propertyName === 'extensionElements';
     });
   });
 
   // default check whether property can be copied
-  eventBus.on('moddleCopy.canCopyProperty', function(context) {
-    var parent = context.parent,
-        parentDescriptor = isObject(parent) && parent.$descriptor,
-        propertyName = context.propertyName;
+  eventBus.on('moddleCopy.canCopyProperty', (context) => {
+    const {
+      parent,
+      property,
+      propertyName
+    } = context;
+
+    const parentDescriptor = isObject(parent) && parent.$descriptor;
+
+    if (propertyName && ALLOWED_REFERENCES.includes(propertyName)) {
 
-    if (propertyName && DISALLOWED_PROPERTIES.indexOf(propertyName) !== -1) {
+      // allow copying reference
+      return property;
+    }
+
+    if (propertyName && DISALLOWED_PROPERTIES.includes(propertyName)) {
 
       // disallow copying property
       return false;
@@ -78,8 +96,8 @@ export default function ModdleCopy(eventBus, bpmnFactory, moddle) {
   });
 
   // do NOT allow to copy empty extension elements
-  eventBus.on('moddleCopy.canSetCopiedProperty', function(context) {
-    var property = context.property;
+  eventBus.on('moddleCopy.canSetCopiedProperty', (context) => {
+    const { property } = context;
 
     if (is(property, 'bpmn:ExtensionElements') && (!property.values || !property.values.length)) {
 
@@ -106,15 +124,13 @@ ModdleCopy.$inject = [
  * @return {ModdleElement}
  */
 ModdleCopy.prototype.copyElement = function(sourceElement, targetElement, propertyNames, clone = false) {
-  var self = this;
-
   if (propertyNames && !isArray(propertyNames)) {
     propertyNames = [ propertyNames ];
   }
 
   propertyNames = propertyNames || getPropertyNames(sourceElement.$descriptor);
 
-  var canCopyProperties = this._eventBus.fire('moddleCopy.canCopyProperties', {
+  const canCopyProperties = this._eventBus.fire('moddleCopy.canCopyProperties', {
     propertyNames: propertyNames,
     sourceElement: sourceElement,
     targetElement: targetElement,
@@ -130,20 +146,20 @@ ModdleCopy.prototype.copyElement = function(sourceElement, targetElement, proper
   }
 
   // copy properties
-  forEach(propertyNames, function(propertyName) {
-    var sourceProperty;
+  forEach(propertyNames, (propertyName) => {
+    let sourceProperty;
 
     if (has(sourceElement, propertyName)) {
       sourceProperty = sourceElement.get(propertyName);
     }
 
-    var copiedProperty = self.copyProperty(sourceProperty, targetElement, propertyName, clone);
+    const copiedProperty = this.copyProperty(sourceProperty, targetElement, propertyName, clone);
 
     if (!isDefined(copiedProperty)) {
       return;
     }
 
-    var canSetProperty = self._eventBus.fire('moddleCopy.canSetCopiedProperty', {
+    const canSetProperty = this._eventBus.fire('moddleCopy.canSetCopiedProperty', {
       parent: targetElement,
       property: copiedProperty,
       propertyName: propertyName
@@ -172,10 +188,9 @@ ModdleCopy.prototype.copyElement = function(sourceElement, targetElement, proper
  * @return {any}
  */
 ModdleCopy.prototype.copyProperty = function(property, parent, propertyName, clone = false) {
-  var self = this;
 
   // allow others to copy property
-  var copiedProperty = this._eventBus.fire('moddleCopy.canCopyProperty', {
+  let copiedProperty = this._eventBus.fire('moddleCopy.canCopyProperty', {
     parent: parent,
     property: property,
     propertyName: propertyName,
@@ -195,7 +210,7 @@ ModdleCopy.prototype.copyProperty = function(property, parent, propertyName, clo
     return copiedProperty;
   }
 
-  var propertyDescriptor = this._moddle.getPropertyDescriptor(parent, propertyName);
+  const propertyDescriptor = this._moddle.getPropertyDescriptor(parent, propertyName);
 
   // do NOT copy references
   if (propertyDescriptor.isReference) {
@@ -209,10 +224,10 @@ ModdleCopy.prototype.copyProperty = function(property, parent, propertyName, clo
 
   // copy arrays
   if (isArray(property)) {
-    return reduce(property, function(childProperties, childProperty) {
+    return reduce(property, (childProperties, childProperty) => {
 
       // recursion
-      copiedProperty = self.copyProperty(childProperty, parent, propertyName, clone);
+      const copiedProperty = this.copyProperty(childProperty, parent, propertyName, clone);
 
       // copying might NOT be allowed
       if (copiedProperty) {
@@ -229,12 +244,12 @@ ModdleCopy.prototype.copyProperty = function(property, parent, propertyName, clo
       return;
     }
 
-    copiedProperty = self._bpmnFactory.create(property.$type);
+    copiedProperty = this._bpmnFactory.create(property.$type);
 
     copiedProperty.$parent = parent;
 
     // recursion
-    copiedProperty = self.copyElement(property, copiedProperty, null, clone);
+    copiedProperty = this.copyElement(property, copiedProperty, null, clone);
 
     return copiedProperty;
   }
@@ -261,7 +276,7 @@ ModdleCopy.prototype._copyId = function(id, element, clone = false) {
 // helpers //////////
 
 export function getPropertyNames(descriptor, keepDefaultProperties) {
-  return reduce(descriptor.properties, function(properties, property) {
+  return reduce(descriptor.properties, (properties, property) => {
 
     if (keepDefaultProperties && property.default) {
       return properties;
@@ -269,8 +284,4 @@ export function getPropertyNames(descriptor, keepDefaultProperties) {
 
     return properties.concat(property.name);
   }, []);
-}
-
-function is(element, type) {
-  return element && isFunction(element.$instanceOf) && element.$instanceOf(type);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "18.6.0",
+  "version": "18.6.2",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "lib/index.js",
   "files": [
@@ -97,7 +97,7 @@
     "karma-webpack": "^5.0.1",
     "mocha": "^10.8.2",
     "mocha-test-container-support": "0.2.0",
-    "npm-run-all2": "^7.0.2",
+    "npm-run-all2": "^8.0.0",
     "puppeteer": "~24.5.0",
     "remark-cli": "^12.0.0",
     "remark-preset-bpmn-io": "^0.2.1",