camunda-bpmn-js 4.13.0 → 4.14.0

package/dist/camunda-cloud-modeler.development.js

@@ -113745,7 +113745,7 @@
    *
    * @return {Array<ModdleElement>|undefined} collection of event definitions or none
    */
-  function getEventDefinitions(element, type) {
+  function getEventDefinitions$1(element, type) {
     var eventDefinitions = element.eventDefinitions;
 
     if (!eventDefinitions || !type) {
@@ -113765,7 +113765,7 @@
    * @return {Array<ModdleElement>} collection of error event definitions
    */
   function getErrorEventDefinitions(element) {
-    return getEventDefinitions(element, 'bpmn:ErrorEventDefinition');
+    return getEventDefinitions$1(element, 'bpmn:ErrorEventDefinition');
   }
 
   /**
@@ -113776,7 +113776,7 @@
    * @return {Array<ModdleElement>} collection of escalation event definitions
    */
   function getEscalationEventDefinitions(element) {
-    return getEventDefinitions(element, 'bpmn:EscalationEventDefinition');
+    return getEventDefinitions$1(element, 'bpmn:EscalationEventDefinition');
   }
 
 
@@ -123204,6 +123204,118 @@
     return find$3(values, value => is$6(value, 'zeebe:IoMapping'));
   }
 
+  const DISALLOWED_START_LISTENER_TYPES = [
+    'bpmn:StartEvent',
+    'bpmn:BoundaryEvent'
+  ];
+
+  class CleanUpExecutionListenersBehavior extends CommandInterceptor$1 {
+    constructor(eventBus, modeling) {
+      super(eventBus);
+
+      // remove execution listeners of disallowed type
+      this.postExecuted('shape.replace', function(event) {
+        const element = event.context.newShape;
+
+        const executionListenersContainer = getExecutionListenersContainer(element);
+        if (!executionListenersContainer) {
+          return;
+        }
+
+        const listeners = executionListenersContainer.get('listeners');
+        const newListeners = withoutDisallowedListeners(element, listeners);
+
+        if (newListeners.length !== listeners.length) {
+          modeling.updateModdleProperties(element, executionListenersContainer, { listeners: newListeners });
+        }
+      });
+
+      // remove empty execution listener container
+      this.postExecuted('element.updateModdleProperties', function(event) {
+        const {
+          element,
+          moddleElement
+        } = event.context;
+
+        if (!is$6(moddleElement, 'zeebe:ExecutionListeners')) {
+          return;
+        }
+
+        const listeners = moddleElement.get('listeners');
+        if (listeners.length) {
+          return;
+        }
+
+        const extensionElements = moddleElement.$parent;
+        modeling.updateModdleProperties(element, extensionElements, { values: without$1(extensionElements.get('values'), moddleElement) });
+      });
+    }
+  }
+
+  CleanUpExecutionListenersBehavior.$inject = [
+    'eventBus',
+    'modeling'
+  ];
+
+  // helpers //////////
+  function withoutDisallowedListeners(element, listeners) {
+    listeners = withoutDisallowedStartListeners(element, listeners);
+    listeners = withoutDisallowedEndListeners(element, listeners);
+
+    return listeners;
+  }
+
+  function withoutDisallowedStartListeners(element, listeners) {
+    if (isAny$1(element, DISALLOWED_START_LISTENER_TYPES)) {
+      return listeners.filter(listener => listener.eventType !== 'start');
+    }
+
+    return listeners;
+  }
+
+  function withoutDisallowedEndListeners(element, listeners) {
+    if (shouldRemoveEndListeners(element)) {
+      return listeners.filter(listener => listener.eventType !== 'end');
+    }
+
+    return listeners;
+  }
+
+  function shouldRemoveEndListeners(element) {
+    if (
+      is$6(element, 'bpmn:BoundaryEvent') && isCompensationEvent(element) ||
+      is$6(element, 'bpmn:EndEvent') && isErrorEvent(element) ||
+      is$6(element, 'bpmn:Gateway')
+    ) {
+      return true;
+    }
+  }
+
+  function isCompensationEvent(element) {
+    const eventDefinitions = getEventDefinitions(element);
+
+    return find$3(eventDefinitions, function(definition) {
+      return is$6(definition, 'bpmn:CompensateEventDefinition');
+    });
+  }
+
+  function isErrorEvent(element) {
+    const eventDefinitions = getEventDefinitions(element);
+
+    return find$3(eventDefinitions, function(definition) {
+      return is$6(definition, 'bpmn:ErrorEventDefinition');
+    });
+  }
+
+  function getEventDefinitions(element) {
+    const businessObject = getBusinessObject$2(element);
+    return businessObject.get('eventDefinitions') || [];
+  }
+
+  function getExecutionListenersContainer(element) {
+    return getExtensionElementsList$1(element, 'zeebe:ExecutionListeners')[0];
+  }
+
   /**
    * Zeebe BPMN behavior ensuring that zeebe:subscription is removed from bpmn:Message
    * when it has no properties anymore.
@@ -124116,6 +124228,7 @@
     __init__: [
       'cleanUpBusinessRuleTaskBehavior',
       'cleanUpEndEventBehavior',
+      'cleanUpExecutionListenersBehavior',
       'cleanUpSubscriptionBehavior',
       'cleanUpTimerExpressionBehavior',
       'copyPasteBehavior',
@@ -124127,6 +124240,7 @@
     ],
     cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
     cleanUpEndEventBehavior: [ 'type', CleanUpEndEventBehavior ],
+    cleanUpExecutionListenersBehavior: [ 'type', CleanUpExecutionListenersBehavior ],
     cleanUpSubscriptionBehavior: [ 'type', CleanUpSubscriptionBehavior ],
     cleanUpTimerExpressionBehavior: [ 'type', CleanUpTimerExpressionBehavior ],
     copyPasteBehavior: [ 'type', ZeebeModdleExtension ],
@@ -155393,6 +155507,93 @@
   				isAttr: true
   			}
   		]
+  	},
+  	{
+  		name: "ExecutionListeners",
+  		superClass: [
+  			"Element"
+  		],
+  		meta: {
+  			allowedIn: [
+  				"bpmn:Event",
+  				"bpmn:Activity",
+  				"bpmn:Process",
+  				"bpmn:ExclusiveGateway",
+  				"bpmn:InclusiveGateway",
+  				"bpmn:ParallelGateway",
+  				"bpmn:EventBasedGateway"
+  			]
+  		},
+  		properties: [
+  			{
+  				name: "listeners",
+  				type: "ExecutionListener",
+  				isMany: true
+  			}
+  		]
+  	},
+  	{
+  		name: "ExecutionListener",
+  		superClass: [
+  			"Element"
+  		],
+  		meta: {
+  			allowedIn: [
+  				"zeebe:ExecutionListeners"
+  			]
+  		},
+  		properties: [
+  			{
+  				name: "eventType",
+  				type: "String",
+  				isAttr: true
+  			},
+  			{
+  				name: "retries",
+  				type: "String",
+  				isAttr: true
+  			},
+  			{
+  				name: "type",
+  				type: "String",
+  				isAttr: true
+  			}
+  		]
+  	},
+  	{
+  		name: "VersionTag",
+  		superClass: [
+  			"Element"
+  		],
+  		meta: {
+  			allowedIn: [
+  				"bpmn:Process"
+  			]
+  		},
+  		properties: [
+  			{
+  				name: "value",
+  				type: "String",
+  				isAttr: true
+  			}
+  		]
+  	},
+  	{
+  		name: "BindingTypeSupported",
+  		isAbstract: true,
+  		"extends": [
+  			"zeebe:CalledDecision",
+  			"zeebe:CalledElement",
+  			"zeebe:FormDefinition"
+  		],
+  		properties: [
+  			{
+  				name: "bindingType",
+  				isAttr: true,
+  				type: "String",
+  				"default": "latest"
+  			}
+  		]
   	}
   ];
   var zeebeModdle = {