camunda-bpmn-js 0.11.5 → 0.12.0

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

@@ -72078,18 +72078,19 @@
 
 
 	/**
-	 * Camunda BPMN specific `camunda:errorEventDefinition` behavior.
-	 *
-	 * When `camunda:type` is set to something different than `external`
-	 * on an element, then `camunda:errorEventDefinition` extension elements
-	 * shall be removed.
+	 * Camunda BPMN specific camunda:ErrorEventDefinition behavior.
 	 */
-	function DeleteErrorEventDefinitionBehavior(eventBus) {
-
-	  CommandInterceptor.call(this, eventBus);
+	class DeleteErrorEventDefinitionBehavior extends CommandInterceptor {
+	  constructor(eventBus, modeling) {
+	    super(eventBus);
 
-	  this.executed([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$l, function(context) {
+	    /**
+	     * Remove camunda:ErrorEventDefinitions on camunda:type set to external.
+	     */
+	    this.postExecute([
+	      'element.updateProperties',
+	      'properties-panel.update-businessobject'
+	    ], HIGH_PRIORITY$l, function(context) {
 	      const {
 	        element,
 	        oldProperties,
@@ -72097,52 +72098,30 @@
 	      } = context;
 
 	      const businessObject = getBusinessObject(element),
-	            extensionElements = businessObject.extensionElements;
+	            extensionElements = businessObject.get('extensionElements');
 
-	      // (1) Check whether behavior is suitable
-	      if (
-	        is$1(element, 'camunda:ExternalCapable') &&
-	        extensionElements &&
-	        externalTypeChanged(oldProperties, properties)
-	      ) {
+	      if (is$1(element, 'camunda:ExternalCapable')
+	        && extensionElements
+	        && externalTypeChanged(oldProperties, properties)) {
 
-	        // (2) Delete camunda:ErrorEventDefinition elements and save them for revert
-	        context.deletedErrorEventDefinitions = extensionElements.values;
+	        const values = extensionElements.get('values').filter((element) => {
+	          return !is$1(element, 'camunda:ErrorEventDefinition');
+	        });
 
-	        extensionElements.values = extensionElements.values.filter(
-	          element => !is$1(element, 'camunda:ErrorEventDefinition')
-	        );
+	        modeling.updateModdleProperties(element, extensionElements, { values });
 	      }
-
 	    }, true);
 
-	  this.reverted([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$l, function({ context }) {
-	      const {
-	        element,
-	        deletedErrorEventDefinitions: oldExtensionElements
-	      } = context;
-
-	      const businessObject = getBusinessObject(element);
-
-	      // Only intercept the revert, if the behavior became active
-	      if (oldExtensionElements) {
-	        const extensionElements = businessObject.extensionElements;
-
-	        extensionElements.values = oldExtensionElements;
-	      }
-	    });
+	  }
 	}
 
-
 	DeleteErrorEventDefinitionBehavior.$inject = [
-	  'eventBus'
+	  'eventBus',
+	  'modeling'
 	];
 
-	inherits_browser(DeleteErrorEventDefinitionBehavior, CommandInterceptor);
-
 
-	// helper //////////////////
+	// helpers //////////
 
 	function externalTypeChanged(oldProperties, updatesProperties) {
 	  const {
@@ -72156,22 +72135,23 @@
 	  return oldType === 'external' && newType !== 'external';
 	}
 
-	const HIGH_PRIORITY$m = 15000;
+	const HIGH_PRIORITY$m = 5000;
 
 
 	/**
-	 * Camunda BPMN specific `camunda:FailedJobRetryTimeCycle` behavior.
-	 *
-	 * When `camunda:asyncAfter` or `camunda:asyncBefore` are set to false
-	 * on an element, then `camunda:FailedJobRetryTimeCycle` shall be removed. This ensures
-	 * that the BPMN diagram XML reflects the behavior of Camunda Platform engine.
+	 * Camunda BPMN specific camunda:FailedJobRetryTimeCycle behavior.
 	 */
-	function DeleteRetryTimeCycleBehavior(eventBus) {
-
-	  CommandInterceptor.call(this, eventBus);
+	class DeleteRetryTimeCycleBehavior extends CommandInterceptor {
+	  constructor(eventBus, modeling) {
+	    super(eventBus);
 
-	  this.executed([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$m, function(context) {
+	    /**
+	     * Remove camunda:FailedJobRetryTimeCycle if camunda:asyncAfter or camunda:asyncBefore is set to false.
+	     */
+	    this.postExecute([
+	      'element.updateProperties',
+	      'properties-panel.update-businessobject'
+	    ], HIGH_PRIORITY$m, function(context) {
 	      const {
 	        element,
 	        properties
@@ -72180,112 +72160,76 @@
 	      const businessObject = getBusinessObject(element),
 	            extensionElements = businessObject.extensionElements;
 
-	      // (1.1) Execute if...
-	      if (is$1(element, 'camunda:AsyncCapable') && // ...asyncCapable
-	        properties && // ...properties updated
-	        (properties['camunda:asyncBefore'] === false || // ...update async (1)
-	          properties['camunda:asyncAfter'] === false) && // ...update async (2)
-	        (extensionElements && extensionElements.values.length) && // ...we have extensionElements
-	        (extensionElements.values.find(ele => is$1(ele, 'camunda:FailedJobRetryTimeCycle'))) && // ...we have retryTimeCycle
-	        !getTimerEventDefinition(element) // ...we don't have a TimerEventDefinition
+	      if (
+	        !is$1(element, 'camunda:AsyncCapable')
+	        || (properties[ 'camunda:asyncBefore' ] !== false && properties[ 'camunda:asyncAfter' ] !== false)
+	        || !extensionElements
+	        || !extensionElements.get('values').length
+	        || !extensionElements.get('values').find((value) => is$1(value, 'camunda:FailedJobRetryTimeCycle'))
+	        || getTimerEventDefinition(element)
+	        || isAsyncBefore(businessObject)
+	        || isAsyncAfter(businessObject)
 	      ) {
-
-	        // (1.2) ... but don't execute if one async is still true
-	        if (isAsyncBefore(businessObject) || isAsyncAfter(businessObject)) {
-	          return;
-	        }
-
-	        // (2) Delete the camunda:FailedJobRetryTimeCycle and save them for revert
-	        context.deleteRetryCycleOldExtElements = extensionElements.values;
-
-	        extensionElements.values = extensionElements.values.filter(
-	          ele => !is$1(ele, 'camunda:FailedJobRetryTimeCycle'));
+	        return;
 	      }
 
-	    }, true);
-
-	  this.reverted([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$m, function({ context }) {
-	      const {
-	        element,
-	        deleteRetryCycleOldExtElements: oldExtensionElements
-	      } = context;
-
-	      const businessObject = getBusinessObject(element);
+	      const values = extensionElements.get('values').filter((element) => {
+	        return !is$1(element, 'camunda:FailedJobRetryTimeCycle');
+	      });
 
-	      // Only intercept the revert, if the behavior became active
-	      if (oldExtensionElements) {
-	        const extensionElements = businessObject.extensionElements;
+	      modeling.updateModdleProperties(element, extensionElements, { values });
+	    }, true);
 
-	        extensionElements.values = oldExtensionElements;
-	      }
-	    });
+	  }
 	}
 
-
 	DeleteRetryTimeCycleBehavior.$inject = [
-	  'eventBus'
+	  'eventBus',
+	  'modeling'
 	];
 
-	inherits_browser(DeleteRetryTimeCycleBehavior, CommandInterceptor);
 
+	// helpers //////////
 
-	// helper //////////////////
-
-	/**
-	 * Returns true if the attribute 'camunda:asyncBefore' is set
-	 * to true.
-	 *
-	 * @param  {ModdleElement} bo
-	 *
-	 * @return {boolean} a boolean value
-	 */
-	function isAsyncBefore(bo) {
-	  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
+	function isAsyncBefore(businessObject) {
+	  return !!(businessObject.get('camunda:asyncBefore') || businessObject.get('camunda:async'));
 	}
 
-	/**
-	 * Returns true if the attribute 'camunda:asyncAfter' is set
-	 * to true.
-	 *
-	 * @param  {ModdleElement} bo
-	 *
-	 * @return {boolean} a boolean value
-	 */
-	function isAsyncAfter(bo) {
-	  return !!bo.get('camunda:asyncAfter');
+	function isAsyncAfter(businessObject) {
+	  return !!businessObject.get('camunda:asyncAfter');
 	}
 
 	function getTimerEventDefinition(element) {
 	  return getEventDefinition$2(element, 'bpmn:TimerEventDefinition');
 	}
 
-	function getEventDefinition$2(element, eventType) {
+	function getEventDefinition$2(element, type) {
 	  const businessObject = getBusinessObject(element);
 
 	  const eventDefinitions = businessObject.get('eventDefinitions') || [];
 
-	  return find(eventDefinitions, function(definition) {
-	    return is$1(definition, eventType);
+	  return eventDefinitions.find((eventDefinition) => {
+	    return is$1(eventDefinition, type);
 	  });
 	}
 
-	const HIGH_PRIORITY$n = 15000;
+	const HIGH_PRIORITY$n = 5000;
 
 
 	/**
-	 * Camunda BPMN specific `camunda:exclusive` behavior.
-	 *
-	 * When `camunda:asyncAfter` or `camunda:asyncBefore` are set to false
-	 * on an element, then `camunda:exclusive` shall be set to true. This ensures
-	 * that the BPMN diagram XML reflects the behavior of Camunda Platform engine.
+	 * Camunda BPMN specific camunda:exclusive behavior.
 	 */
-	function UpdateCamundaExclusiveBehavior(eventBus) {
-
-	  CommandInterceptor.call(this, eventBus);
+	class UpdateCamundaExclusiveBehavior extends CommandInterceptor {
+	  constructor(eventBus) {
+	    super(eventBus);
 
-	  this.preExecute([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$n, function(context) {
+	    /**
+	     * Set camunda:exclusive to true on camunda:asyncBefore or camunda:asyncAfter set to false.
+	     */
+	    this.preExecute([
+	      'element.updateProperties',
+	      'properties-panel.update-businessobject'
+	    ], HIGH_PRIORITY$n, function(context) {
 	      const {
 	        element,
 	        properties
@@ -72293,125 +72237,53 @@
 
 	      const businessObject = getBusinessObject(element);
 
-	      // (1.1) Execute if...
-	      if (is$1(element, 'camunda:AsyncCapable') && // ...asyncCapable
-	          properties && // ...properties updated
-	          (properties['camunda:asyncBefore'] === false || // ...update async before or (1)
-	            properties['camunda:asyncAfter'] === false) && // ...update async after (2)
-	          !isExclusive(businessObject) // ...is currently not exclusive
+	      if (!is$1(element, 'camunda:AsyncCapable')
+	        || (properties[ 'camunda:asyncBefore' ] !== false && properties[ 'camunda:asyncAfter' ] !== false)
+	        || isExclusive(businessObject)
+	        || (isAsyncAfter$1(businessObject) && properties[ 'camunda:asyncAfter' ] !== false)
+	        || (isAsyncBefore$1(businessObject) && properties[ 'camunda:asyncBefore' ] !== false)
+	        || (properties[ 'camunda:asyncBefore' ] === true || properties[ 'camunda:asyncAfter' ] === true)
 	      ) {
-
-	        // (1.2) ...but don't execute if...
-	        if ((isAsyncAfter$1(businessObject) && properties['camunda:asyncAfter'] !== false) || // ...asyncAfter will stay
-	            (isAsyncBefore$1(businessObject) && properties['camunda:asyncBefore'] !== false) || // ...asyncBefore will stay
-	            (properties['camunda:asyncBefore'] || properties['camunda:asyncAfter']) // one is set to true
-	        ) {
-	          return;
-	        }
-
-	        // (2) Update the context
-	        properties['camunda:exclusive'] = true;
+	        return;
 	      }
+
+	      properties[ 'camunda:exclusive' ] = true;
 	    }, true);
-	}
 
+	  }
+	}
 
 	UpdateCamundaExclusiveBehavior.$inject = [
 	  'eventBus'
 	];
 
-	inherits_browser(UpdateCamundaExclusiveBehavior, CommandInterceptor);
-
 
-	// helper //////////////////
+	// helpers //////////
 
-	/**
-	 * Returns true if the attribute 'camunda:asyncBefore' is set
-	 * to true.
-	 *
-	 * @param  {ModdleElement} bo
-	 *
-	 * @return {boolean} a boolean value
-	 */
-	function isAsyncBefore$1(bo) {
-	  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
+	function isAsyncBefore$1(businessObject) {
+	  return !!(businessObject.get('camunda:asyncBefore') || businessObject.get('camunda:async'));
 	}
 
-	/**
-	 * Returns true if the attribute 'camunda:asyncAfter' is set
-	 * to true.
-	 *
-	 * @param  {ModdleElement} bo
-	 *
-	 * @return {boolean} a boolean value
-	 */
-	function isAsyncAfter$1(bo) {
-	  return !!bo.get('camunda:asyncAfter');
+	function isAsyncAfter$1(businessObject) {
+	  return !!businessObject.get('camunda:asyncAfter');
 	}
 
-	/**
-	* Returns true if the attribute 'camunda:exclusive' is set
-	* to true.
-	*
-	* @param  {ModdleElement} bo
-	*
-	* @return {boolean} a boolean value
-	*/
-	function isExclusive(bo) {
-	  return !!bo.get('camunda:exclusive');
+	function isExclusive(businessObject) {
+	  return !!businessObject.get('camunda:exclusive');
 	}
 
-	/**
-	 * Camunda BPMN specific `camunda:inputOutput` behavior.
-	 */
-	function UpdateInputOutputBehavior(eventBus, modeling) {
-
-	  CommandInterceptor.call(this, eventBus);
-
-	  this.postExecute([
-	    'element.updateProperties',
-	    'element.updateModdleProperties',
-	    'properties-panel.update-businessobject-list'
-	  ], function(context) {
-	    const {
-	      element,
-	      oldProperties,
-	      propertyName
-	    } = context;
-
-	    const businessObject = getBusinessObject(element);
-	    const inputOutput = getInputOutput(businessObject);
-	    const extensionElements = businessObject.get('extensionElements');
-
-	    // do not apply if inputOutput got recently added
-	    if (!oldProperties && propertyName === 'values') {
-	      return;
-	    }
+	function getInputOutput(businessObject) {
+	  const extensionElements = businessObject.get('extensionElements');
 
-	    // remove camunda:inputOutput if there are no input/output parameters anymore
-	    if (inputOutput && isEmpty$1(inputOutput)) {
-	      const filtered = extensionElements.values.filter(function(element) {
-	        return element !== inputOutput;
-	      });
+	  if (!extensionElements) {
+	    return;
+	  }
 
-	      modeling.updateModdleProperties(element, extensionElements, {
-	        values: filtered
-	      });
-	    }
-	  }, true);
+	  return extensionElements.get('values').find((value) => {
+	    return is$1(value, 'camunda:InputOutput');
+	  });
 	}
 
-
-	UpdateInputOutputBehavior.$inject = [
-	  'eventBus',
-	  'modeling'
-	];
-
-	inherits_browser(UpdateInputOutputBehavior, CommandInterceptor);
-
-
-	// helper //////////////////
-
 	function getInputParameters(inputOutput) {
 	  return inputOutput.get('inputParameters');
 	}
@@ -72420,81 +72292,117 @@
 	  return inputOutput.get('outputParameters');
 	}
 
-	function getInputOutput(businessObject) {
-	  const extensionElements = businessObject.get('extensionElements');
+	function isInputOutputEmpty(inputOutput) {
+	  const inputParameters = getInputParameters(inputOutput);
+	  const outputParameters = getOutputParameters(inputOutput);
 
-	  if (!extensionElements) {
-	    return;
-	  }
+	  return !inputParameters.length && !outputParameters.length;
+	}
 
-	  const values = extensionElements.get('values');
+	/**
+	 * Camunda BPMN specific camunda:InputOutput behavior.
+	 */
+	class UpdateInputOutputBehavior extends CommandInterceptor {
+	  constructor(eventBus, modeling) {
+	    super(eventBus);
 
-	  return values.find((value) => {
-	    return is$1(value, 'camunda:InputOutput');
-	  });
-	}
+	    /**
+	     * Remove empty camunda:InputOutput on update.
+	     */
+	    this.postExecute([
+	      'element.updateProperties',
+	      'element.updateModdleProperties',
+	      'properties-panel.update-businessobject-list'
+	    ], function(context) {
+	      const {
+	        element,
+	        oldProperties,
+	        propertyName
+	      } = context;
 
-	function isEmpty$1(inputOutput) {
-	  const inputParameters = getInputParameters(inputOutput);
-	  const outputParameters = getOutputParameters(inputOutput);
+	      const businessObject = getBusinessObject(element),
+	            inputOutput = getInputOutput(businessObject),
+	            extensionElements = businessObject.get('extensionElements');
 
-	  return inputParameters.length === 0 && outputParameters.length === 0;
+	      // do not remove newly added camunda:InputOutput
+	      if (!oldProperties && propertyName === 'values') {
+	        return;
+	      }
+
+	      if (inputOutput && isInputOutputEmpty(inputOutput)) {
+	        const values = extensionElements.get('values').filter(function(element) {
+	          return element !== inputOutput;
+	        });
+
+	        modeling.updateModdleProperties(element, extensionElements, { values });
+	      }
+	    }, true);
+	  }
 	}
 
+	UpdateInputOutputBehavior.$inject = [
+	  'eventBus',
+	  'modeling'
+	];
+
 	const HIGH_PRIORITY$o = 5000;
 
 
 	/**
-	 * Camunda BPMN specific `camunda:resultVariable` behavior.
-	 *
-	 * When `camunda:resultVariable` is removed from a service task like element
-	 * `camunda:mapDecisionResult` for the element will be cleaned up.
+	 * Camunda BPMN specific camunda:resultVariable behavior.
 	 */
-	function UpdateResultVariableBehavior(eventBus) {
-
-	  CommandInterceptor.call(this, eventBus);
+	class UpdateResultVariableBehavior extends CommandInterceptor {
+	  constructor(eventBus) {
+	    super(eventBus);
 
-	  this.preExecute([ 'properties-panel.update-businessobject', 'element.updateProperties' ],
-	    HIGH_PRIORITY$o, function(context) {
+	    /**
+	     * Remove camunda:mapDecisionResult on camunda:resultVariable removed.
+	     */
+	    this.preExecute([
+	      'element.updateProperties',
+	      'properties-panel.update-businessobject'
+	    ], HIGH_PRIORITY$o, function(context) {
 	      const {
 	        element,
 	        properties
 	      } = context;
 
 	      if (
-	        is$1(element, 'camunda:DmnCapable') &&
-	        has(properties, 'camunda:resultVariable') &&
-	        isEmpty$2(properties['camunda:resultVariable'])
+	        is$1(element, 'camunda:DmnCapable')
+	        && has(properties, 'camunda:resultVariable')
+	        && isEmpty$1(properties[ 'camunda:resultVariable' ])
 	      ) {
-	        properties['camunda:mapDecisionResult'] = null;
+	        properties[ 'camunda:mapDecisionResult' ] = null;
 	      }
 	    }, true);
-	}
 
+	  }
+	}
 
 	UpdateResultVariableBehavior.$inject = [
 	  'eventBus'
 	];
 
-	inherits_browser(UpdateResultVariableBehavior, CommandInterceptor);
-
 
-	// helper //////////////////
+	// helpers //////////
 
-	function isEmpty$2(value) {
+	function isEmpty$1(value) {
 	  return value == undefined || value === '';
 	}
 
 	/**
-	 * Camunda BPMN specific user task forms behavior ensuring that only one of the following options is configured:
-	 *
-	 * 1. embedded, external or Camunda forms using camunda:formKey
-	 * 2. Camunda forms using camunda:formRef
+	 * Camunda BPMN specific user task forms behavior.
 	 */
 	class UserTaskFormsBehavior extends CommandInterceptor {
 	  constructor(eventBus) {
 	    super(eventBus);
 
+	    /**
+	     * Ensure that only one of the following options is configured:
+	     *
+	     * 1. embedded, external or Camunda forms using camunda:formKey
+	     * 2. Camunda forms using camunda:formRef
+	     */
 	    this.preExecute([
 	      'element.updateProperties',
 	      'element.updateModdleProperties',
@@ -72508,13 +72416,13 @@
 	        context.element.businessObject
 	      );
 
-	      if ('camunda:formKey' in properties) {
+	      if (has(properties, 'camunda:formKey')) {
 	        Object.assign(properties, {
 	          'camunda:formRef': undefined,
 	          'camunda:formRefBinding': undefined,
 	          'camunda:formRefVersion': undefined
 	        });
-	      } else if ('camunda:formRef' in properties) {
+	      } else if (has(properties, 'camunda:formRef')) {
 	        Object.assign(properties, {
 	          'camunda:formKey': undefined
 	        });
@@ -72526,23 +72434,23 @@
 	          });
 	        }
 
-	        if (!('camunda:formRefBinding' in properties) && isUndefined(businessObject.get('camunda:formRefBinding'))) {
+	        if (!has(properties, 'camunda:formRefBinding') && isUndefined(businessObject.get('camunda:formRefBinding'))) {
 	          Object.assign(properties, {
 	            'camunda:formRefBinding': 'latest'
 	          });
 	        }
 	      }
 
-	      if ('camunda:formRefBinding' in properties && properties[ 'camunda:formRefBinding' ] !== 'version') {
+	      if (has(properties, 'camunda:formRefBinding') && properties[ 'camunda:formRefBinding' ] !== 'version') {
 	        Object.assign(properties, {
 	          'camunda:formRefVersion': undefined
 	        });
 	      }
 	    }, true);
+
 	  }
 	}
 
-
 	UserTaskFormsBehavior.$inject = [ 'eventBus' ];
 
 	/**
@@ -85367,7 +85275,7 @@
 
 	  var constraints = property.constraints || {};
 
-	  if (constraints.notEmpty && isEmpty$3(value)) {
+	  if (constraints.notEmpty && isEmpty$2(value)) {
 	    return translate('Must not be empty');
 	  }
 
@@ -85444,7 +85352,7 @@
 	  return regexp.test(str);
 	}
 
-	function isEmpty$3(str) {
+	function isEmpty$2(str) {
 	  return !str || /^\s*$/.test(str);
 	}