camunda-bpmn-js 4.12.1 → 4.14.0

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

@@ -108432,6 +108432,24 @@
     return T$2((...args) => callbackRef.current(...args), []);
   }
 
+  function useElementVisible(element) {
+    const [visible, setVisible] = h(!!element && !!element.clientHeight);
+    y(() => {
+      if (!element) return;
+      const resizeObserver = new ResizeObserver(([entry]) => {
+        requestAnimationFrame(() => {
+          const newVisible = !!entry.contentRect.height;
+          if (newVisible !== visible) {
+            setVisible(newVisible);
+          }
+        });
+      });
+      resizeObserver.observe(element);
+      return () => resizeObserver.disconnect();
+    }, [element, visible]);
+    return visible;
+  }
+
   function Group$1(props) {
     const {
       element,
@@ -111291,6 +111309,7 @@
     } = props;
     const [localValue, setLocalValue] = h(value);
     const ref = useShowEntryEvent(id);
+    const visible = useElementVisible(ref.current);
     const handleInputCallback = F$2(() => {
       return debounce(target => onInput(target.value.length ? target.value : undefined));
     }, [onInput, debounce]);
@@ -111302,6 +111321,9 @@
     y(() => {
       autoResize && resizeToContents(ref.current);
     }, []);
+    y(() => {
+      visible && autoResize && resizeToContents(ref.current);
+    }, [visible]);
     p$1(() => {
       if (value === localValue) {
         return;
@@ -113723,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) {
@@ -113743,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');
   }
 
   /**
@@ -113754,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');
   }
 
 
@@ -119573,13 +119595,14 @@
     const getValue = header => {
       return header.value;
     };
-    return TextfieldEntry({
+    return TextAreaEntry({
       element: header,
       id: idPrefix + '-value',
       label: translate('Value'),
       getValue,
       setValue,
-      debounce
+      debounce,
+      autoResize: true
     });
   }
 
@@ -123181,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.
@@ -124093,6 +124228,7 @@
     __init__: [
       'cleanUpBusinessRuleTaskBehavior',
       'cleanUpEndEventBehavior',
+      'cleanUpExecutionListenersBehavior',
       'cleanUpSubscriptionBehavior',
       'cleanUpTimerExpressionBehavior',
       'copyPasteBehavior',
@@ -124104,6 +124240,7 @@
     ],
     cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
     cleanUpEndEventBehavior: [ 'type', CleanUpEndEventBehavior ],
+    cleanUpExecutionListenersBehavior: [ 'type', CleanUpExecutionListenersBehavior ],
     cleanUpSubscriptionBehavior: [ 'type', CleanUpSubscriptionBehavior ],
     cleanUpTimerExpressionBehavior: [ 'type', CleanUpTimerExpressionBehavior ],
     copyPasteBehavior: [ 'type', ZeebeModdleExtension ],
@@ -155370,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 = {