camunda-bpmn-js 0.11.5 → 0.12.0

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

@@ -72069,78 +72069,183 @@
 	  Modeler$1.prototype._extensionModules
 	);
 
-	const HIGH_PRIORITY$l = 15000;
+	const HIGH_PRIORITY$l = 5000;
+
 
 	/**
-	 * BPMN specific create zeebe boundary event behavior
+	 * Zeebe BPMN behavior for ensuring that a BusinessRuleTask:
+	 * 1) Either has a taskDefinition ExtensionElement OR
+	 * 2) Or has a calledDecision ExtensionElement
+	 * 2.1) If it has a calledDecision ExtensionElement, it shall not have taskHeaders
 	 */
-	function CreateZeebeBoundaryEventBehavior(
-	    eventBus, elementFactory, bpmnFactory) {
+	class CleanUpBusinessRuleTaskBehavior extends CommandInterceptor {
+	  constructor(eventBus, modeling) {
+	    super(eventBus);
 
-	  CommandInterceptor.call(this, eventBus);
+	    /**
+	     * Remove zeebe:calledDecision when zeebe:taskDefinition is added
+	     */
+	    this.postExecute([
+	      'properties-panel.update-businessobject-list',
+	      'element.updateModdleProperties'
+	    ] , HIGH_PRIORITY$l, function(context) {
+	      const {
+	        element,
+	        currentObject,
+	        objectsToAdd,
+	        moddleElement,
+	        properties
+	      } = context;
 
-	  /**
-	   * replace intermediate catch event with boundary event when
-	   * attaching it to a shape
-	   */
-	  this.preExecute('shape.create', HIGH_PRIORITY$l, function(context) {
-	    const {
-	      shape,
-	      host
-	    } = context;
+	      // (1) map properties from both commands
+	      const extensionElement = currentObject || moddleElement,
+	            newValues = objectsToAdd || (properties && properties.values);
 
-	    const businessObject = getBusinessObject(shape);
+	      // (2) check conditions and potentially update
+	      if (
+	        is$1(element, 'bpmn:BusinessRuleTask')
+	        && extensionElement
+	        && is$1(extensionElement, 'bpmn:ExtensionElements')
+	        && extensionElement.get('values').some((ele) => is$1(ele, 'zeebe:CalledDecision'))
+	        && newValues
+	        && newValues.some((ele) => is$1(ele, 'zeebe:TaskDefinition'))
+	      ) {
+	        removeCalledDecision(element, extensionElement, modeling);
+	      }
+	    }, true);
 
-	    let attrs = {
-	      cancelActivity: true
-	    };
+	    /**
+	     * Remove zeebe:taskDefinition and zeebe:taskHeaders when zeebe:calledDecision
+	     */
+	    this.postExecute([
+	      'properties-panel.update-businessobject-list',
+	      'element.updateModdleProperties'
+	    ] , HIGH_PRIORITY$l, function(context) {
+	      const {
+	        element,
+	        currentObject,
+	        objectsToAdd,
+	        moddleElement,
+	        properties
+	      } = context;
 
-	    let newBusinessObject,
-	        hostBusinessObject,
-	        boundaryEvent,
-	        eventDefinitions;
+	      // (1) map properties from both commands
+	      const extensionElement = currentObject || moddleElement,
+	            newValues = objectsToAdd || (properties && properties.values);
 
-	    if (!host || !is$1(shape, 'bpmn:IntermediateCatchEvent')) {
-	      return;
-	    }
+	      // (2) check conditions and potentially update
+	      if (
+	        is$1(element, 'bpmn:BusinessRuleTask')
+	        && extensionElement
+	        && is$1(extensionElement, 'bpmn:ExtensionElements')
+	        && extensionElement.get('values').some(
+	          (ele) => is$1(ele, 'zeebe:TaskDefinition') || is$1(ele, 'zeebe:TaskHeaders'))
+	        && newValues
+	        && newValues.some((ele) => is$1(ele, 'zeebe:CalledDecision'))
+	      ) {
+	        removeTaskDefintionAndHeaders(element, extensionElement, modeling);
+	      }
+	    }, true);
 
-	    hostBusinessObject = getBusinessObject(host);
+	  }
+	}
 
-	    attrs = {
-	      attachedToRef: hostBusinessObject,
-	      ...attrs
-	    };
+	CleanUpBusinessRuleTaskBehavior.$inject = [
+	  'eventBus',
+	  'modeling'
+	];
 
-	    eventDefinitions = businessObject.eventDefinitions;
 
-	    newBusinessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);
+	// helper ////////////////////
 
-	    boundaryEvent = {
-	      type: 'bpmn:BoundaryEvent',
-	      businessObject: newBusinessObject,
-	    };
+	function removeFromExtensionElements(element, extensionElements, modeling, filterFun) {
+	  const values = extensionElements.get('values').filter(filterFun);
+
+	  modeling.updateModdleProperties(element, extensionElements, {
+	    values
+	  });
+	}
+
+	function removeCalledDecision(element, extensionElements, modeling) {
+	  removeFromExtensionElements(element, extensionElements, modeling,
+	    (ele) => !is$1(ele, 'zeebe:CalledDecision'));
+	}
+
+	function removeTaskDefintionAndHeaders(element, extensionElements, modeling) {
+	  removeFromExtensionElements(element, extensionElements, modeling,
+	    (ele) => !is$1(ele, 'zeebe:TaskDefinition') && !is$1(ele, 'zeebe:TaskHeaders'));
+	}
+
+	const HIGH_PRIORITY$m = 5000;
+
+
+	/**
+	 * Zeebe BPMN specific behavior for creating boundary events.
+	 */
+	class CreateZeebeBoundaryEventBehavior extends CommandInterceptor {
+	  constructor(bpmnFactory, elementFactory, eventBus) {
+	    super(eventBus);
+
+	    /**
+	     * Replace intermediate catch event with boundary event when attaching it to a shape.
+	     */
+	    this.preExecute('shape.create', HIGH_PRIORITY$m, function(context) {
+	      const {
+	        shape,
+	        host
+	      } = context;
+
+	      const businessObject = getBusinessObject(shape);
+
+	      let attrs = {
+	        cancelActivity: true
+	      };
+
+	      let newBusinessObject,
+	          hostBusinessObject,
+	          boundaryEvent,
+	          eventDefinitions;
+
+	      if (!host || !is$1(shape, 'bpmn:IntermediateCatchEvent')) {
+	        return;
+	      }
+
+	      hostBusinessObject = getBusinessObject(host);
+
+	      attrs = {
+	        ...attrs,
+	        attachedToRef: hostBusinessObject
+	      };
+
+	      eventDefinitions = businessObject.eventDefinitions;
+
+	      newBusinessObject = bpmnFactory.create('bpmn:BoundaryEvent', attrs);
 
-	    if (eventDefinitions && eventDefinitions[0]) {
 	      boundaryEvent = {
-	        ...boundaryEvent,
-	        eventDefinitionType: eventDefinitions[0].$type
+	        type: 'bpmn:BoundaryEvent',
+	        businessObject: newBusinessObject,
 	      };
-	    }
 
-	    context.shape = elementFactory.createShape(boundaryEvent);
+	      if (eventDefinitions && eventDefinitions[0]) {
+	        boundaryEvent = {
+	          ...boundaryEvent,
+	          eventDefinitionType: eventDefinitions[0].$type
+	        };
+	      }
+
+	      context.shape = elementFactory.createShape(boundaryEvent);
 
-	  }, true);
-	}
+	    }, true);
 
+	  }
+	}
 
 	CreateZeebeBoundaryEventBehavior.$inject = [
-	  'eventBus',
+	  'bpmnFactory',
 	  'elementFactory',
-	  'bpmnFactory'
+	  'eventBus'
 	];
 
-	inherits_browser(CreateZeebeBoundaryEventBehavior, CommandInterceptor);
-
 	function isZeebeServiceTask(element) {
 	  if (!is$1(element, 'zeebe:ZeebeServiceTask')) return false;
 
@@ -72151,6 +72256,113 @@
 	  return true;
 	}
 
+	/**
+	 * Get zeebe:IoMapping from an element.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {ModdleElement}
+	 */
+	function getIoMapping(element) {
+	  const businessObject = getBusinessObject(element);
+
+	  const extensionElements = businessObject.get('extensionElements');
+
+	  if (!extensionElements) {
+	    return;
+	  }
+
+	  return extensionElements.get('values').find((value) => {
+	    return is$1(value, 'zeebe:IoMapping');
+	  });
+	}
+
+	/**
+	 * Get zeebe:InputParameters from an element.
+	 *
+	 * @param  {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {Array<ModdleElement>}
+	 */
+	function getInputParameters(element) {
+	  const ioMapping = getIoMapping(element);
+
+	  if (ioMapping) {
+	    return ioMapping.get('zeebe:inputParameters');
+	  }
+
+	  return [];
+	}
+
+	/**
+	 * Get zeebe:OutputParameters from an element.
+	 *
+	 * @param  {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {Array<ModdleElement>}
+	 */
+	function getOutputParameters(element) {
+	  const ioMapping = getIoMapping(element);
+
+	  if (ioMapping) {
+	    return ioMapping.get('zeebe:outputParameters');
+	  }
+
+	  return [];
+	}
+
+	/**
+	 * Check whether element supports zeebe:Input or zeebe:Output.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {boolean}
+	 */
+	function isInputOutputSupported(element) {
+	  return areInputParametersSupported(element) || areOutputParametersSupported(element);
+	}
+
+	/**
+	 * Check whether element supports zeebe:Input.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {boolean}
+	 */
+	function areInputParametersSupported(element) {
+	  return isAny(element, [
+	    'bpmn:CallActivity',
+	    'bpmn:SubProcess',
+	    'bpmn:UserTask'
+	  ]) || isZeebeServiceTask(element);
+	}
+
+	/**
+	 * Check whether element supports zeebe:Output.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @return {boolean}
+	 */
+	function areOutputParametersSupported(element) {
+	  return isAny(element, [
+	    'bpmn:CallActivity',
+	    'bpmn:Event',
+	    'bpmn:ReceiveTask',
+	    'bpmn:SubProcess',
+	    'bpmn:UserTask',
+	    'zeebe:ZeebeServiceTask'
+	  ]);
+	}
+
+	function createElement(type, parent, factory, properties) {
+	  return ElementHelper_1.createElement(type, properties, parent, factory);
+	}
+
+	function createIoMapping(parent, bpmnFactory, properties) {
+	  return createElement('zeebe:IoMapping', parent, bpmnFactory, properties);
+	}
+
 	var is$g = require$$0.is;
 
 	var ExtensionElementsHelper = {};
@@ -72201,406 +72413,223 @@
 
 	var ExtensionElementsHelper_1 = ExtensionElementsHelper;
 
-	function getElements(bo, type, prop) {
-	  const elems = ExtensionElementsHelper_1.getExtensionElements(bo, type);
-	  return !prop ? elems : (elems[0] || {})[prop] || [];
-	}
-
-	function getParameters(element, prop) {
-	  const inputOutput = getInputOutput(element);
-	  return (inputOutput && inputOutput.get(prop)) || [];
-	}
-
 	/**
-	   * Get a inputOutput from the business object
-	   *
-	   * @param {djs.model.Base} element
-	   *
-	   * @return {ModdleElement} the inputOutput object
-	   */
-	function getInputOutput(element) {
-	  const bo = getBusinessObject(element);
-	  return (getElements(bo, 'zeebe:IoMapping') || [])[0];
-	}
-
-
-	/**
-	   * Return all input parameters existing in the business object, and
-	   * an empty array if none exist.
-	   *
-	   * @param  {djs.model.Base} element
-	   *
-	   * @return {Array} a list of input parameter objects
-	   */
-	function getInputParameters(element) {
-	  return getParameters.apply(this, [ element, 'inputParameters' ]);
-	}
-
-	/**
-	   * Return all output parameters existing in the business object, and
-	   * an empty array if none exist.
-	   *
-	   * @param  {djs.model.Base} element
-	   *
-	   * @return {Array} a list of output parameter objects
-	   */
-	function getOutputParameters(element) {
-	  return getParameters.apply(this, [ element, 'outputParameters' ]);
-	}
-
-	/**
-	   * Returns 'true' if the given element supports inputOutput
-	   *
-	   * @param {djs.model.Base} element
-	   *
-	   * @return {boolean} a boolean value
-	   */
-	function isInputOutputSupported(element) {
-	  return areOutputParametersSupported(element) || areInputParametersSupported(element);
-	}
-
-	/**
-	   * Returns 'true' if the given element supports input parameters
-	   *
-	   * @param {djs.model.Base} element
-	   *
-	   * @return {boolean} a boolean value
-	   */
-	function areInputParametersSupported(element) {
-	  return isAny(element, [
-	    'bpmn:UserTask',
-	    'bpmn:SubProcess',
-	    'bpmn:CallActivity'
-	  ]) || isZeebeServiceTask(element);
-	}
-
-	/**
-	   * Returns 'true' if the given element supports output parameters
-	   *
-	   * @param {djs.model.Base} element
-	   *
-	   * @return {boolean} a boolean value
-	   */
-	function areOutputParametersSupported(element) {
-	  return isAny(element, [
-	    'zeebe:ZeebeServiceTask',
-	    'bpmn:UserTask',
-	    'bpmn:SubProcess',
-	    'bpmn:ReceiveTask',
-	    'bpmn:CallActivity',
-	    'bpmn:Event'
-	  ]);
-	}
-
-	function createElement(type, parent, factory, properties) {
-	  return ElementHelper_1.createElement(type, properties, parent, factory);
-	}
-
-	function createIOMapping(parent, bpmnFactory, properties) {
-	  return createElement('zeebe:IoMapping', parent, bpmnFactory, properties);
-	}
-
-	/**
-	 * Get getter function for IOMapping parameters according to provided property name
+	 * Get default value for zeebe:propagateAllChildVariables.
 	 *
-	 * @param {string} property
+	 * @param {djs.model.Base|ModdleElement} element
 	 *
-	 * @returns {Function} Getter function for the IOMapping parameters according to provided property name
+	 * @returns {boolean}
 	 */
-	function determineParamGetFunc(property) {
-	  if (property == 'inputParameters') {
-	    return getInputParameters;
-	  }
-
-	  if (property == 'outputParameters') {
-	    return getOutputParameters;
+	function getPropagateAllChildVariablesDefault(element) {
+	  if (!is$1(element, 'bpmn:CallActivity')) {
+	    return;
 	  }
-	}
 
-	/**
-	  * Determine default value for propagateAllChildVariables attribute
-	  * @param {Object} element representing a bpmn:CallActivity
-	  *
-	  * @returns {boolean}
-	  */
-	function determinePropAllChildVariablesDefault(element) {
 	  const outputParameters = getOutputParameters(element);
 
 	  if (outputParameters) {
-	    return (outputParameters.length > 0) ? false : true;
+	    return !outputParameters.length;
 	  }
 	}
 
 	/**
-	  * Get the 'zeebe:CalledElement' extension element for a given business Object
-	  * @param {Object} bo businessObject
-	  *
-	  * @returns {Object} the calledElement Moddle Object or undefined if zeebe:CalledElement does not exist
-	  */
+	 * Get zeebe:CalledElement of an element.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @returns {ModdleElement}
+	 */
 	function getCalledElement(element) {
 	  const calledElements = getCalledElements(element);
-	  return calledElements[0];
+
+	  return calledElements[ 0 ];
 	}
 
 	function getCalledElements(element) {
-	  const bo = getBusinessObject(element);
-	  const extElements = ExtensionElementsHelper_1.getExtensionElements(bo, 'zeebe:CalledElement');
-	  return extElements;
+	  const businessObject = getBusinessObject(element);
+
+	  return ExtensionElementsHelper_1.getExtensionElements(businessObject, 'zeebe:CalledElement');
 	}
 
 	/**
-	  * Check whether the propagateAllChildVariables attribute is set on an element.
-	  * Note that a default logic will be determine if it is not explicitly set.
-	  * @param {Object} element
-	  *
-	  * @returns {boolean}
-	  */
+	 * Check whether zeebe:propagateAllChildVariables is set on an element.
+	 * Fall back to default if zeebe:propagateAllChildVariables not set.
+	 *
+	 * @param {djs.model.Base|ModdleElement} element
+	 *
+	 * @returns {boolean}
+	 */
 	function isPropagateAllChildVariables(element) {
 	  if (!is$1(element, 'bpmn:CallActivity')) {
-	    return undefined;
+	    return;
 	  }
 
-	  const bo = getBusinessObject(element),
-	        calledElement = getCalledElement(bo);
+	  const businessObject = getBusinessObject(element),
+	        calledElement = getCalledElement(businessObject);
 
-	  return calledElement && has(calledElement, 'propagateAllChildVariables') ?
-	    calledElement.get('propagateAllChildVariables') :
-	    determinePropAllChildVariablesDefault(element);
+	  if (calledElement && has(calledElement, 'propagateAllChildVariables')) {
+	    return calledElement.get('propagateAllChildVariables');
+	  } else {
+	    return getPropagateAllChildVariablesDefault(element);
+	  }
 	}
 
-	const HIGH_PRIORITY$m = 15000;
+	const HIGH_PRIORITY$n = 5000;
+
 
 	/**
-	 * BPMN specific create zeebe call activity behavior
+	 * Zeebe BPMN specific behavior for creating call activities.
 	 */
-	function CreateZeebeCallActivityBehavior(
-	    eventBus, bpmnFactory) {
+	class CreateZeebeCallActivityBehavior extends CommandInterceptor {
+	  constructor(bpmnFactory, eventBus, modeling) {
+	    super(eventBus);
 
-	  CommandInterceptor.call(this, eventBus);
+	    /**
+	     * Add zeebe:CalledElement extension element with zeebe:propagateAllChildVariables attribute = false
+	     * when creating bpmn:CallActivity.
+	     */
+	    this.postExecuted('shape.create', HIGH_PRIORITY$n, function(context) {
+	      const { shape } = context;
 
-	  /**
-	   * add a zeebe:calledElement extensionElement with
-	   * propagateAllChildVariables attribute = false when creating
-	   * a bpmn:callActivity
-	   */
-	  this.postExecuted('shape.create', HIGH_PRIORITY$m, function(context) {
-	    const {
-	      shape
-	    } = context;
+	      if (!is$1(shape, 'bpmn:CallActivity')) {
+	        return;
+	      }
 
-	    if (!is$1(shape, 'bpmn:CallActivity')) {
-	      return;
-	    }
+	      const businessObject = getBusinessObject(shape);
 
-	    const bo = getBusinessObject(shape);
+	      let calledElement = getCalledElement(businessObject);
 
-	    // Reuse ExtensionElement if existing
-	    const extensionElements = bo.get('extensionElements') ||
-	      ElementHelper_1.createElement('bpmn:ExtensionElements', { values: [] }, bo, bpmnFactory);
+	      if (!calledElement) {
+	        calledElement = bpmnFactory.create('zeebe:CalledElement', {
+	          propagateAllChildVariables: false
+	        });
 
-	    // Ensure we have a calledElement
-	    let calledElement = getCalledElement(bo);
+	        let extensionElements = businessObject.get('extensionElements');
 
-	    if (!calledElement) {
-	      calledElement = bpmnFactory.create('zeebe:CalledElement', {});
-	      calledElement.propagateAllChildVariables = false;
+	        if (!extensionElements) {
+	          extensionElements = ElementHelper_1.createElement('bpmn:ExtensionElements', { values: [] }, businessObject, bpmnFactory);
 
-	      extensionElements.get('values').push(
-	        calledElement
-	      );
+	          modeling.updateProperties(shape, { extensionElements });
+	        }
 
-	      bo.extensionElements = extensionElements;
+	        modeling.updateModdleProperties(shape, extensionElements, {
+	          values: [
+	            ...(extensionElements.values || []),
+	            calledElement
+	          ]
+	        });
+	      } else if (!has(calledElement, 'propagateAllChildVariables')) {
 
-	      // Handle existing callActivities
-	    } else if (!has(calledElement, 'propagateAllChildVariables')) {
-	      calledElement.propagateAllChildVariables = false;
-	    }
+	        // if zeebe:CalledElement exist set zeebe:propagateAllChildVariables to false
+	        modeling.updateModdleProperties(shape, calledElement, {
+	          propagateAllChildVariables: false
+	        });
+	      }
+	    }, true);
 
-	  }, true);
+	  }
 	}
 
-
 	CreateZeebeCallActivityBehavior.$inject = [
+	  'bpmnFactory',
 	  'eventBus',
-	  'bpmnFactory'
+	  'modeling'
 	];
 
-	inherits_browser(CreateZeebeCallActivityBehavior, CommandInterceptor);
-
-	const HIGH_PRIORITY$n = 15000;
+	const HIGH_PRIORITY$o = 5000;
 
 
 	/**
-	 * UpdatePropagateAllChildVariablesBehavior reacts to either (1) toggling on propagateAllChildVariables
-	 * when there are outputParameters present or (2) to adding outputParameters when
-	 * propagateAllChildVariables is set to true.
-	 * It will ensure that the propagateAllChildVariables attribute on calledElement
-	 * extensionElements for callActivities is always consistent with outputParameter mappings
+	 * Zeebe BPMN behavior for updating zeebe:propagateAllChildVariables.
 	 */
-	function UpdatePropagateAllChildVariablesBehavior(
-	    eventBus) {
-
-	  CommandInterceptor.call(this, eventBus);
-
-	  // Behavior when toggling propagateAllChildVariables /////////////////////////
-	  /**
-	   * remove outputParameters from zeebe:IoMapping when setting propgateAlLChildVariables
-	   * to true in the proeprties panel
-	   */
-	  this.executed('properties-panel.update-businessobject' , HIGH_PRIORITY$n, function(context) {
-	    const {
-	      element,
-	      properties
-	    } = context;
-
-	    // (1) Don't execute this behavior if we are not in a call activity or not
-	    // have properties to update or not update the propagateAllChildVariables
-	    // to false
-	    if (!is$1(element, 'bpmn:CallActivity') ||
-	        !properties ||
-	        !!properties.propagateAllChildVariables === false) {
-	      return;
-	    }
-
-	    // (2) Check whether we have outputParameters
-	    const outputParameters = getOutputParameters(element),
-	          inputParameters = getInputParameters(element);
-
-	    if (!outputParameters ||
-	      outputParameters.length === 0) {
-	      return;
-	    }
-
-	    // (3) Store old outputParameters and remove them
-	    context.oldOutputParameters = outputParameters;
-
-	    const inputOutput = getInputOutput(element);
-	    inputOutput.outputParameters = [];
-
-	    // (4) if we also have no inputParameters, store IOMapping and remove it
-	    if (!inputParameters || inputParameters.length === 0) {
-	      const extensionElements = getBusinessObject(element).extensionElements;
-	      context.oldExtensionElements = extensionElements.values;
-
-	      extensionElements.values = extensionElements.values.filter(ele => ele.$type !== 'zeebe:IoMapping');
-	    }
-	  }, true);
-
-	  // Revert behavior when toggling propagateAllChildVariables //////////////////
-	  this.reverted('properties-panel.update-businessobject', HIGH_PRIORITY$n, function(context) {
-	    const {
-	      element,
-	      oldOutputParameters,
-	      oldExtensionElements
-	    } = context;
-
-	    // (1) Only intercept the revert, if the behavior became active
-	    if (oldOutputParameters) {
+	class UpdatePropagateAllChildVariablesBehavior extends CommandInterceptor {
+	  constructor(eventBus, modeling) {
+	    super(eventBus);
 
-	      // (2) If we removed the IOMapping, bring it back first
-	      if (oldExtensionElements) {
-	        const extensionElements = getBusinessObject(element).extensionElements;
+	    /**
+	     * Remove zeebe:OutputParameters when zeebe:propagateAllChildVariables is set to true.
+	     */
+	    this.postExecute('properties-panel.update-businessobject' , HIGH_PRIORITY$o, function(context) {
+	      const {
+	        element,
+	        properties
+	      } = context;
 
-	        extensionElements.values = oldExtensionElements;
+	      if (
+	        !is$1(element, 'bpmn:CallActivity')
+	        || !properties
+	        || !!properties.propagateAllChildVariables === false
+	      ) {
+	        return;
 	      }
 
-	      // (3) Bring back the outputParameters
-	      const inputOutput = getInputOutput(element);
-	      inputOutput.outputParameters = oldOutputParameters;
-	    }
-	  }, true);
-
+	      const inputParameters = getInputParameters(element),
+	            outputParameters = getOutputParameters(element);
 
-	  // Behavior when adding outputParameters ////////////////////////////////////
-	  /**
-	   * un-toggle propgateAlLChildVariables when adding output parameters
-	   */
-	  this.executed('properties-panel.update-businessobject-list' , HIGH_PRIORITY$n, function(context) {
-	    const {
-	      element,
-	      objectsToAdd
-	    } = context;
+	      if (!outputParameters || !outputParameters.length) {
+	        return;
+	      }
 
+	      const ioMapping = getIoMapping(element);
 
-	    // (1) Exit if we are not in a CallActivity, not adding an OutputParameter or not
-	    // having set propagateAllChildVariables to false
-	    if (!is$1(element, 'bpmn:CallActivity') ||
-	     !objectsToAdd ||
-	     objectsToAdd.length === 0 ||
-	     objectsToAdd.filter(obj => is$1(obj, 'zeebe:Output')).length === 0 ||
-	    isPropagateAllChildVariables(element) === false) {
-	      return;
-	    }
+	      modeling.updateModdleProperties(element, ioMapping, {
+	        'zeebe:outputParameters': []
+	      });
 
-	    // (2) Store the old propAllChildVariables value and update it then
-	    const bo = getBusinessObject(element),
-	          calledElement = getCalledElement(bo);
+	      if (!inputParameters || !inputParameters.length) {
+	        const businessObject = getBusinessObject(element),
+	              extensionElements = businessObject.get('extensionElements');
 
-	    context.oldPropagateAllChildVariables = true;
+	        const values = extensionElements.get('values').filter((element) => {
+	          return !is$1(element, 'zeebe:IoMapping');
+	        });
 
-	    calledElement.propagateAllChildVariables = false;
-	  }, true);
+	        modeling.updateModdleProperties(element, extensionElements, {
+	          values
+	        });
+	      }
+	    }, true);
 
-	  // Revert behavior when adding outputParmaeters ////////////////////////////////////
-	  this.reverted('properties-panel.update-businessobject-list' , HIGH_PRIORITY$n, function(context) {
-	    const {
-	      element,
-	      oldPropagateAllChildVariables
-	    } = context;
 
-	    // (1) Only intercept the revert, if the behavior became active
-	    if (oldPropagateAllChildVariables) {
-	      const bo = getBusinessObject(element),
-	            calledElement = getCalledElement(bo);
+	    /**
+	     * Set zeebe:propagateAllChildVariables to false on zeebe:Output added.
+	     */
+	    this.postExecute('properties-panel.update-businessobject-list' , HIGH_PRIORITY$o, function(context) {
+	      const {
+	        currentObject,
+	        element,
+	        objectsToAdd,
+	        propertyName
+	      } = context;
+
+	      if (!is$1(element, 'bpmn:CallActivity')
+	        || !is$1(currentObject, 'zeebe:IoMapping')
+	        || (propertyName !== 'outputParameters' && propertyName !== 'zeebe:outputParameters')
+	        || !objectsToAdd
+	        || !objectsToAdd.length
+	        || !objectsToAdd.find((object) => is$1(object, 'zeebe:Output'))
+	        || !isPropagateAllChildVariables(element)) {
+	        return;
+	      }
 
-	      calledElement.propagateAllChildVariables = oldPropagateAllChildVariables;
-	    }
-	  }, true);
+	      const businessObject = getBusinessObject(element),
+	            calledElement = getCalledElement(businessObject);
 
+	      modeling.updateModdleProperties(element, calledElement, {
+	        'zeebe:propagateAllChildVariables': false
+	      });
+	    }, true);
 
+	  }
 	}
 
-
 	UpdatePropagateAllChildVariablesBehavior.$inject = [
-	  'eventBus'
+	  'eventBus',
+	  'modeling'
 	];
 
+	const USER_TASK_FORM_PREFIX = 'UserTaskForm_';
 
-	inherits_browser(UpdatePropagateAllChildVariablesBehavior, CommandInterceptor);
-
-	const USER_TASK_FORM_PREFIX = 'userTaskForm_';
-
-
-	function getUserTaskForm(element, parent) {
-
-	  const rootElement = parent || getRootElement$1(element);
-
-	  // (1) get form definition from user task
-	  const formDefinition = getFormDefinition(element);
-
-	  if (!formDefinition) {
-	    return;
-	  }
-
-	  const formKey = formDefinition.get('formKey');
-
-	  // (2) retrieve user task form via form key
-	  const userTaskForm = findUserTaskForm(formKey, rootElement);
-
-	  return userTaskForm;
-	}
-
-	function getFormDefinition(element) {
-	  const businessObject = getBusinessObject(element);
-
-	  const formDefinitions = ExtensionElementsHelper_1.getExtensionElements(businessObject, 'zeebe:FormDefinition');
-
-	  return formDefinitions[0];
-	}
-
-	function createFormKey(formId) {
-	  return 'camunda-forms:bpmn:' + formId;
-	}
 
 	function createFormDefinition(properties, extensionElements, bpmnFactory) {
 	  return ElementHelper_1.createElement(
@@ -72611,6 +72640,14 @@
 	  );
 	}
 
+	function createFormId() {
+	  return nextId_1(USER_TASK_FORM_PREFIX);
+	}
+
+	function createFormKey(formId) {
+	  return `camunda-forms:bpmn:${ formId }`;
+	}
+
 	function createUserTaskForm(properties, extensionElements, bpmnFactory) {
 	  return ElementHelper_1.createElement(
 	    'zeebe:UserTaskForm',
@@ -72620,19 +72657,22 @@
 	  );
 	}
 
-	function createFormId() {
-	  return nextId_1(USER_TASK_FORM_PREFIX);
-	}
+	function findUserTaskForm(formKey, rootElement) {
+	  const userTaskForms = ExtensionElementsHelper_1.getExtensionElements(rootElement, 'zeebe:UserTaskForm');
 
+	  return find(userTaskForms, function(userTaskForm) {
+	    const id = userTaskForm.get('zeebe:id');
 
-	// helpers /////////////////////
+	    return createFormKey(id) === formKey;
+	  });
+	}
 
-	function findUserTaskForm(formKey, rootElement) {
-	  const forms = ExtensionElementsHelper_1.getExtensionElements(rootElement, 'zeebe:UserTaskForm');
+	function getFormDefinition(element) {
+	  const businessObject = getBusinessObject(element);
 
-	  return find(forms, function(userTaskForm) {
-	    return createFormKey(userTaskForm.id) === formKey;
-	  });
+	  const formDefinitions = ExtensionElementsHelper_1.getExtensionElements(businessObject, 'zeebe:FormDefinition');
+
+	  return formDefinitions[ 0 ];
 	}
 
 	function getRootElement$1(element) {
@@ -72646,162 +72686,125 @@
 	  return parent;
 	}
 
-	/**
-	 * Zeebe specific form definition behavior.
-	 */
-	function FormDefinitionBehavior(
-	    eventBus, bpmnFactory) {
-
-	  CommandInterceptor.call(this, eventBus);
-
-	  /**
-	   * ensures a zeebe:userTaskForm is cleaned up when user task got removed
-	   */
-	  this.executed('shape.delete', function(context) {
-	    const {
-	      shape,
-	      oldParent
-	    } = context;
+	function getUserTaskForm(element, parent) {
+	  const rootElement = parent || getRootElement$1(element);
 
-	    const rootElement = getRootElement$2(oldParent);
+	  const formDefinition = getFormDefinition(element);
 
-	    const userTaskForm = getUserTaskForm(shape, rootElement);
+	  if (!formDefinition) {
+	    return;
+	  }
 
-	    const rootExtensionElements = rootElement.get('extensionElements');
+	  const formKey = formDefinition.get('zeebe:formKey');
 
-	    if (!is$1(shape, 'bpmn:UserTask') || !userTaskForm) {
-	      return;
-	    }
+	  return findUserTaskForm(formKey, rootElement);
+	}
 
-	    remove$2(rootExtensionElements.get('values'), userTaskForm);
+	/**
+	 * Zeebe BPMN specific form definition behavior.
+	 */
+	class FormDefinitionBehavior extends CommandInterceptor {
+	  constructor(bpmnFactory, eventBus, modeling) {
+	    super(eventBus);
 
-	    context.removedUserTaskForm = userTaskForm;
-	  }, true);
+	    /**
+	     * Remove zeebe:UserTaskForm on user task removed.
+	     */
+	    this.postExecute('shape.delete', function(context) {
+	      const {
+	        oldParent,
+	        shape
+	      } = context;
 
-	  this.revert('shape.delete', function(context) {
-	    const {
-	      removedUserTaskForm,
-	      oldParent
-	    } = context;
+	      const rootElement = getRootElement$2(oldParent);
 
-	    const rootElement = getRootElement$2(oldParent);
+	      const userTaskForm = getUserTaskForm(shape, rootElement);
 
-	    const rootExtensionElements = rootElement.get('extensionElements');
+	      if (!is$1(shape, 'bpmn:UserTask') || !userTaskForm) {
+	        return;
+	      }
 
-	    if (!removedUserTaskForm) {
-	      return;
-	    }
+	      const rootExtensionElements = rootElement.get('extensionElements');
 
-	    add$1(rootExtensionElements.get('values'), removedUserTaskForm);
-	  }, true);
+	      const values = rootExtensionElements.get('values').filter((element) => {
+	        return element !== userTaskForm;
+	      });
 
+	      modeling.updateModdleProperties(shape, rootExtensionElements, { values });
+	    }, true);
 
-	  /**
-	   * create fresh new copied form definition + user task form
-	   */
-	  this.executed('shape.create', function(context) {
-	    const {
-	      shape,
-	    } = context;
 
-	    const oldFormDefinition = getFormDefinition(shape);
+	    /**
+	     * Create new zeebe:FormDefinition and zeebe:UserTaskForm on user task created.
+	     */
+	    this.postExecute('shape.create', function(context) {
+	      const { shape } = context;
 
-	    if (!is$1(shape, 'bpmn:UserTask') || !oldFormDefinition) {
-	      return;
-	    }
+	      const oldFormDefinition = getFormDefinition(shape);
 
-	    const oldUserTaskForm = getUserTaskForm(shape);
+	      if (!is$1(shape, 'bpmn:UserTask') || !oldFormDefinition) {
+	        return;
+	      }
 
-	    const rootElement = getRootElement$2(shape);
+	      const oldUserTaskForm = getUserTaskForm(shape);
 
-	    const businessObject = getBusinessObject(shape);
+	      const rootElement = getRootElement$2(shape);
 
-	    const extensionElements = businessObject.get('extensionElements');
+	      const businessObject = getBusinessObject(shape);
 
-	    let rootExtensionElements = rootElement.get('extensionElements');
+	      const extensionElements = businessObject.get('extensionElements');
 
-	    // (1) ensure extension elements in root
-	    if (!rootExtensionElements) {
+	      let rootExtensionElements = rootElement.get('extensionElements');
 
-	      rootExtensionElements = ElementHelper_1.createElement(
-	        'bpmn:ExtensionElements',
-	        { values: [] },
-	        rootElement,
-	        bpmnFactory
-	      );
+	      // (1) ensure extension elements exists
+	      if (!rootExtensionElements) {
+	        rootExtensionElements = ElementHelper_1.createElement('bpmn:ExtensionElements', { values: [] }, rootElement, bpmnFactory);
 
-	      rootElement.set('extensionElements', rootExtensionElements);
-	    }
+	        modeling.updateModdleProperties(shape, rootElement, { extensionElements: rootExtensionElements });
+	      }
 
-	    // (2) remove existing form definition
-	    context.oldFormDefinition = oldFormDefinition;
+	      // (2) remove existing form definition
+	      let values = extensionElements.get('values').filter((element) => {
+	        return element !== oldFormDefinition;
+	      });
 
-	    remove$2(extensionElements.get('values'), oldFormDefinition);
+	      // (3) create new form definition
+	      const formId = createFormId();
 
-	    const formId = createFormId();
+	      const newFormDefinition = createFormDefinition({ formKey: createFormKey(formId) }, extensionElements, bpmnFactory);
 
-	    // (3) create new form definition
-	    const formDefinition = createFormDefinition(
-	      {
-	        formKey: createFormKey(formId)
-	      },
-	      extensionElements,
-	      bpmnFactory
-	    );
+	      values = [
+	        ...values,
+	        newFormDefinition
+	      ];
 
-	    add$1(extensionElements.get('values'), formDefinition);
+	      modeling.updateModdleProperties(shape, extensionElements, {
+	        values
+	      });
 
-	    // (4) create new user task form
-	    const userTaskForm = createUserTaskForm(
-	      {
+	      // (4) create new user task form
+	      const userTaskForm = createUserTaskForm({
 	        id: formId,
 	        body: oldUserTaskForm ? oldUserTaskForm.get('body') : ''
-	      },
-	      rootExtensionElements,
-	      bpmnFactory
-	    );
-
-	    add$1(rootExtensionElements.get('values'), userTaskForm);
-	  }, true);
-
-	  this.revert('shape.create', function(context) {
-	    const {
-	      shape,
-	      oldFormDefinition
-	    } = context;
-
-	    const businessObject = getBusinessObject(shape);
-
-	    const extensionElements = businessObject.get('extensionElements');
-
-	    const formDefinition = getFormDefinition(shape);
-
-	    const userTaskForm = getUserTaskForm(shape);
-
-	    const rootElement = getRootElement$2(shape);
+	      }, rootExtensionElements, bpmnFactory);
 
-	    const rootExtensionElements = rootElement.get('extensionElements');
-
-	    if (!is$1(shape, 'bpmn:UserTask') || !userTaskForm) {
-	      return;
-	    }
-
-	    // we need to cover the old form definition to make <redo> possible
-	    remove$2(extensionElements.get('values'), formDefinition);
-	    add$1(extensionElements.get('values'), oldFormDefinition);
-
-	    remove$2(rootExtensionElements.get('values'), userTaskForm);
-	  }, true);
+	      modeling.updateModdleProperties(shape, rootExtensionElements, {
+	        values: [
+	          ...(rootExtensionElements.get('values') || []),
+	          userTaskForm
+	        ]
+	      });
+	    }, true);
 
+	  }
 	}
 
 	FormDefinitionBehavior.$inject = [
+	  'bpmnFactory',
 	  'eventBus',
-	  'bpmnFactory'
+	  'modeling'
 	];
 
-	inherits_browser(FormDefinitionBehavior, CommandInterceptor);
-
 
 	// helpers //////////////
 
@@ -72818,11 +72821,13 @@
 
 	var zeebeModelingBehaviors = {
 	  __init__: [
+	    'cleanUpBusinessRuleTaskBehavior',
 	    'createZeebeBoundaryEventBehavior',
 	    'createZeebeCallActivityBehavior',
 	    'updatePropagateAllChildVariablesBehavior',
 	    'formDefinitionBehavior'
 	  ],
+	  cleanUpBusinessRuleTaskBehavior: [ 'type', CleanUpBusinessRuleTaskBehavior ],
 	  createZeebeBoundaryEventBehavior: [ 'type', CreateZeebeBoundaryEventBehavior ],
 	  createZeebeCallActivityBehavior: [ 'type', CreateZeebeCallActivityBehavior ],
 	  updatePropagateAllChildVariablesBehavior: [ 'type', UpdatePropagateAllChildVariablesBehavior ],
@@ -73051,7 +73056,7 @@
 	  zeebeReplaceMenuProvider: [ 'type', ReplaceMenuProvider$1 ]
 	};
 
-	const HIGH_PRIORITY$o = 15000;
+	const HIGH_PRIORITY$p = 5000;
 
 	/**
 	 * Zeebe rule provider that allows to create boundary events with catch events
@@ -73069,7 +73074,7 @@
 
 	  init() {
 	    super.init();
-	    this.addRule('shape.attach', HIGH_PRIORITY$o,(context) => {
+	    this.addRule('shape.attach', HIGH_PRIORITY$p,(context) => {
 	      return this.canAttach(
 	        context.shape,
 	        context.target,
@@ -73497,12 +73502,12 @@
 	    }
 
 	    // Get the IOMapping
-	    let inputOutput = getInputOutput(element);
+	    let inputOutput = getIoMapping(element);
 
 	    if (!inputOutput) {
 	      const parent = extensionElements;
 
-	      inputOutput = createIOMapping(parent, bpmnFactory, {
+	      inputOutput = createIoMapping(parent, bpmnFactory, {
 	        inputParameters: [],
 	        outputParameters: []
 	      });
@@ -73557,7 +73562,7 @@
 	function getIOMappingEntries(element, bpmnFactory, translate, options) {
 
 	  // Get the IOMapping and determine whether we are dealing with input or output parameters
-	  const inputOutput = getInputOutput(element),
+	  const inputOutput = getIoMapping(element),
 	        params = determineParamGetFunc(options.prop)(element, false);
 
 	  if (!params.length) {
@@ -73626,6 +73631,19 @@
 	  }
 	}
 
+
+	// helpers //////////
+
+	function determineParamGetFunc(property) {
+	  if (property == 'inputParameters') {
+	    return getInputParameters;
+	  }
+
+	  if (property == 'outputParameters') {
+	    return getOutputParameters;
+	  }
+	}
+
 	function inputOutput$1(group, element, bpmnFactory, translate, options) {
 
 	  const inputOutputEntry = inputOutput(element, bpmnFactory, translate, options);
@@ -75417,6 +75435,29 @@
 					isAttr: true
 				}
 			]
+		},
+		{
+			name: "CalledDecision",
+			superClass: [
+				"Element"
+			],
+			meta: {
+				allowedIn: [
+					"bpmn:BusinessRuleTask"
+				]
+			},
+			properties: [
+				{
+					name: "decisionId",
+					type: "String",
+					isAttr: true
+				},
+				{
+					name: "resultVariable",
+					type: "String",
+					isAttr: true
+				}
+			]
 		}
 	];
 	var zeebeModdle = {