camunda-bpmn-js 5.0.0 → 5.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2755,7 +2755,7 @@
2755
2755
  * @return {string}
2756
2756
  */
2757
2757
  function componentsToPath(elements) {
2758
- return elements.flat().join(',').replace(/,?([A-z]),?/g, '$1');
2758
+ return elements.flat().join(',').replace(/,?([A-Za-z]),?/g, '$1');
2759
2759
  }
2760
2760
 
2761
2761
  /**
@@ -25387,7 +25387,7 @@
25387
25387
  * `keyboard.bind=true|false` configuration option.
25388
25388
  *
25389
25389
  * @param {Object} config
25390
- * @param {EventTarget} [config.bindTo]
25390
+ * @param {boolean} [config.bind]
25391
25391
  * @param {EventBus} eventBus
25392
25392
  */
25393
25393
  function Keyboard(config, eventBus) {
@@ -25463,10 +25463,17 @@
25463
25463
  /**
25464
25464
  * Bind keyboard events to the given DOM node.
25465
25465
  *
25466
+ * @overlord
25467
+ * @deprecated No longer in use since version 15.0.0.
25468
+ *
25466
25469
  * @param {EventTarget} node
25467
25470
  */
25471
+ /**
25472
+ * Bind keyboard events to the canvas node.
25473
+ */
25468
25474
  Keyboard.prototype.bind = function(node) {
25469
25475
 
25476
+ // legacy <node> argument provided
25470
25477
  if (node) {
25471
25478
  console.error('unsupported argument <node>', new Error(compatMessage));
25472
25479
  }
@@ -104149,8 +104156,8 @@
104149
104156
  });
104150
104157
  const selectedElement = state.selectedElement;
104151
104158
 
104152
- /**
104153
- * @param {djs.model.Base | Array<djs.model.Base>} element
104159
+ /**
104160
+ * @param {djs.model.Base | Array<djs.model.Base>} element
104154
104161
  */
104155
104162
  const _update = element => {
104156
104163
  if (!element) {
@@ -104324,8 +104331,7 @@
104324
104331
  // helpers //////////////////////////
104325
104332
 
104326
104333
  function isImplicitRoot$1(element) {
104327
- // Backwards compatibility for diagram-js<7.4.0, see https://github.com/bpmn-io/bpmn-properties-panel/pull/102
104328
- return element && (element.isImplicit || element.id === '__implicitroot');
104334
+ return element && element.isImplicit;
104329
104335
  }
104330
104336
  function findElement(elements, element) {
104331
104337
  return find$2(elements, e => e === element);
@@ -104336,10 +104342,10 @@
104336
104342
 
104337
104343
  const DEFAULT_PRIORITY$1 = 1000;
104338
104344
 
104339
- /**
104340
- * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
104341
- * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
104342
- * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
104345
+ /**
104346
+ * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
104347
+ * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
104348
+ * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
104343
104349
  */
104344
104350
 
104345
104351
  class BpmnPropertiesPanelRenderer {
@@ -104359,7 +104365,7 @@
104359
104365
  this._tooltipConfig = tooltipConfig;
104360
104366
  this._feelPopupContainer = feelPopupContainer;
104361
104367
  this._getFeelPopupLinks = getFeelPopupLinks;
104362
- this._container = domify$1('<div style="height: 100%" class="bio-properties-panel-container"></div>');
104368
+ this._container = domify$1('<div style="height: 100%" tabindex="-1" class="bio-properties-panel-container"></div>');
104363
104369
  var commandStack = injector.get('commandStack', false);
104364
104370
  commandStack && setupKeyboard(this._container, eventBus, commandStack);
104365
104371
  eventBus.on('diagram.init', () => {
@@ -104378,10 +104384,10 @@
104378
104384
  });
104379
104385
  }
104380
104386
 
104381
- /**
104382
- * Attach the properties panel to a parent node.
104383
- *
104384
- * @param {HTMLElement} container
104387
+ /**
104388
+ * Attach the properties panel to a parent node.
104389
+ *
104390
+ * @param {HTMLElement} container
104385
104391
  */
104386
104392
  attachTo(container) {
104387
104393
  if (!container) {
@@ -104406,8 +104412,8 @@
104406
104412
  this._eventBus.fire('propertiesPanel.attach');
104407
104413
  }
104408
104414
 
104409
- /**
104410
- * Detach the properties panel from its parent node.
104415
+ /**
104416
+ * Detach the properties panel from its parent node.
104411
104417
  */
104412
104418
  detach() {
104413
104419
  const parentNode = this._container.parentNode;
@@ -104417,11 +104423,11 @@
104417
104423
  }
104418
104424
  }
104419
104425
 
104420
- /**
104421
- * Register a new properties provider to the properties panel.
104422
- *
104423
- * @param {Number} [priority]
104424
- * @param {PropertiesProvider} provider
104426
+ /**
104427
+ * Register a new properties provider to the properties panel.
104428
+ *
104429
+ * @param {Number} [priority]
104430
+ * @param {PropertiesProvider} provider
104425
104431
  */
104426
104432
  registerProvider(priority, provider) {
104427
104433
  if (!provider) {
@@ -104438,9 +104444,9 @@
104438
104444
  this._eventBus.fire('propertiesPanel.providersChanged');
104439
104445
  }
104440
104446
 
104441
- /**
104442
- * Updates the layout of the properties panel.
104443
- * @param {Object} layout
104447
+ /**
104448
+ * Updates the layout of the properties panel.
104449
+ * @param {Object} layout
104444
104450
  */
104445
104451
  setLayout(layout) {
104446
104452
  this._eventBus.fire('propertiesPanel.setLayout', {
@@ -104487,16 +104493,15 @@
104487
104493
  // helpers ///////////////////////
104488
104494
 
104489
104495
  function isImplicitRoot(element) {
104490
- // Backwards compatibility for diagram-js<7.4.0, see https://github.com/bpmn-io/bpmn-properties-panel/pull/102
104491
- return element && (element.isImplicit || element.id === '__implicitroot');
104496
+ return element && element.isImplicit;
104492
104497
  }
104493
104498
 
104494
- /**
104495
- * Setup keyboard bindings (undo, redo) on the given container.
104496
- *
104497
- * @param {Element} container
104498
- * @param {EventBus} eventBus
104499
- * @param {CommandStack} commandStack
104499
+ /**
104500
+ * Setup keyboard bindings (undo, redo) on the given container.
104501
+ *
104502
+ * @param {Element} container
104503
+ * @param {EventBus} eventBus
104504
+ * @param {CommandStack} commandStack
104500
104505
  */
104501
104506
  function setupKeyboard(container, eventBus, commandStack) {
104502
104507
  function cancel(event) {
@@ -104521,14 +104526,14 @@
104521
104526
  });
104522
104527
  }
104523
104528
 
104524
- /**
104525
- * A handler that combines and executes multiple commands.
104526
- *
104527
- * All updates are bundled on the command stack and executed in one step.
104528
- * This also makes it possible to revert the changes in one step.
104529
- *
104530
- * Example use case: remove the camunda:formKey attribute and in addition
104531
- * add all form fields needed for the camunda:formData property.
104529
+ /**
104530
+ * A handler that combines and executes multiple commands.
104531
+ *
104532
+ * All updates are bundled on the command stack and executed in one step.
104533
+ * This also makes it possible to revert the changes in one step.
104534
+ *
104535
+ * Example use case: remove the camunda:formKey attribute and in addition
104536
+ * add all form fields needed for the camunda:formData property.
104532
104537
  */
104533
104538
  let MultiCommandHandler$1 = class MultiCommandHandler {
104534
104539
  constructor(commandStack) {
@@ -104658,12 +104663,12 @@
104658
104663
  return compensateEventDefinition && compensateEventDefinition.get('activityRef');
104659
104664
  }
104660
104665
 
104661
- /**
104662
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
104666
+ /**
104667
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
104663
104668
  */
104664
104669
 
104665
- /**
104666
- * @returns {Array<Entry>} entries
104670
+ /**
104671
+ * @returns {Array<Entry>} entries
104667
104672
  */
104668
104673
  function CompensationProps(props) {
104669
104674
  const {
@@ -104773,12 +104778,12 @@
104773
104778
  return getFlowElements(element, 'bpmn:BoundaryEvent');
104774
104779
  }
104775
104780
 
104776
- /**
104777
- * Checks whether an Activity is attaching a CompensateEvent of the parent container.
104778
- *
104779
- * @param {ModdleElement} activity
104780
- * @param {Array<ModdleElement>} boundaryEvents
104781
- * @returns {Boolean}
104781
+ /**
104782
+ * Checks whether an Activity is attaching a CompensateEvent of the parent container.
104783
+ *
104784
+ * @param {ModdleElement} activity
104785
+ * @param {Array<ModdleElement>} boundaryEvents
104786
+ * @returns {Boolean}
104782
104787
  */
104783
104788
  function hasCompensationEventAttached(activity, boundaryEvents) {
104784
104789
  const {
@@ -104793,15 +104798,15 @@
104793
104798
  });
104794
104799
  }
104795
104800
 
104796
- /**
104797
- * Checks whether an Activity can be compensated. That's the case when it is
104798
- * a) a CallActivity
104799
- * b) a SubProcess, when it is not event based and not a compensation
104800
- * c) any other Activity, when it is attaching a CompensateEvent of the parent container
104801
- *
104802
- * @param {ModdleElement} activity
104803
- * @param {Array<ModdleElement>} boundaryEvents
104804
- * @returns {Boolean}
104801
+ /**
104802
+ * Checks whether an Activity can be compensated. That's the case when it is
104803
+ * a) a CallActivity
104804
+ * b) a SubProcess, when it is not event based and not a compensation
104805
+ * c) any other Activity, when it is attaching a CompensateEvent of the parent container
104806
+ *
104807
+ * @param {ModdleElement} activity
104808
+ * @param {Array<ModdleElement>} boundaryEvents
104809
+ * @returns {Boolean}
104805
104810
  */
104806
104811
  function canBeCompensated(activity, boundaryEvents) {
104807
104812
  return is$5(activity, 'bpmn:CallActivity') || is$5(activity, 'bpmn:SubProcess') && !activity.triggeredByEvent && !activity.isForCompensation || hasCompensationEventAttached(activity, boundaryEvents);
@@ -104814,11 +104819,11 @@
104814
104819
  });
104815
104820
  }
104816
104821
 
104817
- /**
104818
- * Retrieves all possible activities to reference for a Compensation.
104819
- *
104820
- * @param {djs.model.Base} element
104821
- * @returns {Array<ModdleElement>}
104822
+ /**
104823
+ * Retrieves all possible activities to reference for a Compensation.
104824
+ *
104825
+ * @param {djs.model.Base} element
104826
+ * @returns {Array<ModdleElement>}
104822
104827
  */
104823
104828
  function findActivityRefs(element) {
104824
104829
  const businessObject = getBusinessObject$1(element);
@@ -104838,13 +104843,13 @@
104838
104843
  return activities;
104839
104844
  }
104840
104845
 
104841
- /**
104842
- * Retrieves an option label in the form
104843
- * a) with name: "my Task (id=Task_1)"
104844
- * b) without name: "(id=Task_1)"
104845
- *
104846
- * @param {ModdleElement} activity
104847
- * @returns {String}
104846
+ /**
104847
+ * Retrieves an option label in the form
104848
+ * a) with name: "my Task (id=Task_1)"
104849
+ * b) without name: "(id=Task_1)"
104850
+ *
104851
+ * @param {ModdleElement} activity
104852
+ * @returns {String}
104848
104853
  */
104849
104854
  function createOptionLabel(activity) {
104850
104855
  const {
@@ -104859,12 +104864,12 @@
104859
104864
 
104860
104865
  const DOCUMENTATION_TEXT_FORMAT = 'text/plain';
104861
104866
 
104862
- /**
104863
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
104867
+ /**
104868
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
104864
104869
  */
104865
104870
 
104866
- /**
104867
- * @returns {Array<Entry>} entries
104871
+ /**
104872
+ * @returns {Array<Entry>} entries
104868
104873
  */
104869
104874
  function DocumentationProps(props) {
104870
104875
  const {
@@ -104935,12 +104940,12 @@
104935
104940
  });
104936
104941
  }
104937
104942
 
104938
- /**
104939
- * Retrieves a documentation element from a given moddle element.
104940
- *
104941
- * @param {ModdleElement} businessObject
104942
- *
104943
- * @returns {ModdleElement} documentation element inside the given moddle element.
104943
+ /**
104944
+ * Retrieves a documentation element from a given moddle element.
104945
+ *
104946
+ * @param {ModdleElement} businessObject
104947
+ *
104948
+ * @returns {ModdleElement} documentation element inside the given moddle element.
104944
104949
  */
104945
104950
  function getDocumentation(businessObject) {
104946
104951
  return function () {
@@ -104949,10 +104954,10 @@
104949
104954
  };
104950
104955
  }
104951
104956
 
104952
- /**
104953
- * Sets a documentation element for a given moddle element.
104954
- *
104955
- * @param {ModdleElement} businessObject
104957
+ /**
104958
+ * Sets a documentation element for a given moddle element.
104959
+ *
104960
+ * @param {ModdleElement} businessObject
104956
104961
  */
104957
104962
  function setDocumentation(element, businessObject, bpmnFactory, commandStack) {
104958
104963
  return function (value) {
@@ -104995,15 +105000,15 @@
104995
105000
  };
104996
105001
  }
104997
105002
 
104998
- /**
104999
- * Create a new element and (optionally) set its parent.
105000
- *
105001
- * @param {string} type
105002
- * @param {Object} properties
105003
- * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
105004
- * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
105005
- *
105006
- * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
105003
+ /**
105004
+ * Create a new element and (optionally) set its parent.
105005
+ *
105006
+ * @param {string} type
105007
+ * @param {Object} properties
105008
+ * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
105009
+ * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
105010
+ *
105011
+ * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
105007
105012
  */
105008
105013
  function createElement$1(type, properties, parent, bpmnFactory) {
105009
105014
  const element = bpmnFactory.create(type, properties);
@@ -105013,8 +105018,8 @@
105013
105018
  return element;
105014
105019
  }
105015
105020
 
105016
- /**
105017
- * generate a semantic id with given prefix
105021
+ /**
105022
+ * generate a semantic id with given prefix
105018
105023
  */
105019
105024
  function nextId$1(prefix) {
105020
105025
  const ids = new Ids$1([32, 32, 1]);
@@ -105043,12 +105048,12 @@
105043
105048
  const EMPTY_OPTION$4 = '';
105044
105049
  const CREATE_NEW_OPTION$4 = 'create-new';
105045
105050
 
105046
- /**
105047
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105051
+ /**
105052
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105048
105053
  */
105049
105054
 
105050
- /**
105051
- * @returns {Array<Entry>} entries
105055
+ /**
105056
+ * @returns {Array<Entry>} entries
105052
105057
  */
105053
105058
  function ErrorProps$2(props) {
105054
105059
  const {
@@ -105224,12 +105229,12 @@
105224
105229
 
105225
105230
  const CREATE_NEW_OPTION$3 = 'create-new';
105226
105231
 
105227
- /**
105228
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105232
+ /**
105233
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105229
105234
  */
105230
105235
 
105231
- /**
105232
- * @returns {Array<Entry>} entries
105236
+ /**
105237
+ * @returns {Array<Entry>} entries
105233
105238
  */
105234
105239
  function EscalationProps$2(props) {
105235
105240
  const {
@@ -105402,12 +105407,12 @@
105402
105407
  return sortBy(elements, e => (e.name || '').toLowerCase());
105403
105408
  }
105404
105409
 
105405
- /**
105406
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105410
+ /**
105411
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105407
105412
  */
105408
105413
 
105409
- /**
105410
- * @returns {Array<Entry>} entries
105414
+ /**
105415
+ * @returns {Array<Entry>} entries
105411
105416
  */
105412
105417
  function ExecutableProps(props) {
105413
105418
  const {
@@ -105478,14 +105483,14 @@
105478
105483
  // for ID validation as per BPMN Schema (QName - Namespace)
105479
105484
  const ID_REGEX = /^[a-z_][\w-.]*$/i;
105480
105485
 
105481
- /**
105482
- * checks whether the id value is valid
105483
- *
105484
- * @param {ModdleElement} element
105485
- * @param {String} idValue
105486
- * @param {Function} translate
105487
- *
105488
- * @return {String} error message
105486
+ /**
105487
+ * checks whether the id value is valid
105488
+ *
105489
+ * @param {ModdleElement} element
105490
+ * @param {String} idValue
105491
+ * @param {Function} translate
105492
+ *
105493
+ * @return {String} error message
105489
105494
  */
105490
105495
  function isIdValid(element, idValue, translate) {
105491
105496
  const assigned = element.$model.ids.assigned(idValue);
@@ -105513,12 +105518,12 @@
105513
105518
  return SPACE_REGEX$1.test(value);
105514
105519
  }
105515
105520
 
105516
- /**
105517
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105521
+ /**
105522
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105518
105523
  */
105519
105524
 
105520
- /**
105521
- * @returns {Array<Entry>} entries
105525
+ /**
105526
+ * @returns {Array<Entry>} entries
105522
105527
  */
105523
105528
  function IdProps$1() {
105524
105529
  return [{
@@ -105560,12 +105565,12 @@
105560
105565
  });
105561
105566
  }
105562
105567
 
105563
- /**
105564
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105568
+ /**
105569
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105565
105570
  */
105566
105571
 
105567
- /**
105568
- * @returns {Array<Entry>} entries
105572
+ /**
105573
+ * @returns {Array<Entry>} entries
105569
105574
  */
105570
105575
  function LinkProps(props) {
105571
105576
  const {
@@ -105613,12 +105618,12 @@
105613
105618
  const EMPTY_OPTION$3 = '';
105614
105619
  const CREATE_NEW_OPTION$2 = 'create-new';
105615
105620
 
105616
- /**
105617
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105621
+ /**
105622
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105618
105623
  */
105619
105624
 
105620
- /**
105621
- * @returns {Array<Entry>} entries
105625
+ /**
105626
+ * @returns {Array<Entry>} entries
105622
105627
  */
105623
105628
  function MessageProps$1(props) {
105624
105629
  const {
@@ -105761,12 +105766,12 @@
105761
105766
  return sortBy(elements, e => (e.name || '').toLowerCase());
105762
105767
  }
105763
105768
 
105764
- /**
105765
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105769
+ /**
105770
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105766
105771
  */
105767
105772
 
105768
- /**
105769
- * @returns {Array<Entry>} entries
105773
+ /**
105774
+ * @returns {Array<Entry>} entries
105770
105775
  */
105771
105776
  function MultiInstanceProps$2(props) {
105772
105777
  const {
@@ -105837,59 +105842,59 @@
105837
105842
 
105838
105843
  // generic ///////////////////////////
105839
105844
 
105840
- /**
105841
- * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
105842
- *
105843
- * @param {djs.model.Base} element
105844
- * @return {boolean}
105845
+ /**
105846
+ * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
105847
+ *
105848
+ * @param {djs.model.Base} element
105849
+ * @return {boolean}
105845
105850
  */
105846
105851
  function isMultiInstanceSupported$1(element) {
105847
105852
  const loopCharacteristics = getLoopCharacteristics$2(element);
105848
105853
  return !!loopCharacteristics && is$5(loopCharacteristics, 'bpmn:MultiInstanceLoopCharacteristics');
105849
105854
  }
105850
105855
 
105851
- /**
105852
- * getBody - get the body of a given expression.
105853
- *
105854
- * @param {ModdleElement<bpmn:FormalExpression>} expression
105855
- * @return {string} the body (value) of the expression
105856
+ /**
105857
+ * getBody - get the body of a given expression.
105858
+ *
105859
+ * @param {ModdleElement<bpmn:FormalExpression>} expression
105860
+ * @return {string} the body (value) of the expression
105856
105861
  */
105857
105862
  function getBody(expression) {
105858
105863
  return expression && expression.get('body');
105859
105864
  }
105860
105865
 
105861
- /**
105862
- * getProperty - get a property value of the loop characteristics.
105863
- *
105864
- * @param {djs.model.Base} element
105865
- * @param {string} propertyName
105866
- *
105867
- * @return {any} the property value
105866
+ /**
105867
+ * getProperty - get a property value of the loop characteristics.
105868
+ *
105869
+ * @param {djs.model.Base} element
105870
+ * @param {string} propertyName
105871
+ *
105872
+ * @return {any} the property value
105868
105873
  */
105869
105874
  function getProperty$2(element, propertyName) {
105870
105875
  const loopCharacteristics = getLoopCharacteristics$2(element);
105871
105876
  return loopCharacteristics && loopCharacteristics.get(propertyName);
105872
105877
  }
105873
105878
 
105874
- /**
105875
- * getLoopCharacteristics - get loopCharacteristics of a given element.
105876
- *
105877
- * @param {djs.model.Base} element
105878
- * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
105879
+ /**
105880
+ * getLoopCharacteristics - get loopCharacteristics of a given element.
105881
+ *
105882
+ * @param {djs.model.Base} element
105883
+ * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
105879
105884
  */
105880
105885
  function getLoopCharacteristics$2(element) {
105881
105886
  const bo = getBusinessObject$1(element);
105882
105887
  return bo.loopCharacteristics;
105883
105888
  }
105884
105889
 
105885
- /**
105886
- * createFormalExpression - creates a 'bpmn:FormalExpression' element.
105887
- *
105888
- * @param {ModdleElement} parent
105889
- * @param {string} body
105890
- * @param {BpmnFactory} bpmnFactory
105891
- *
105892
- * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
105890
+ /**
105891
+ * createFormalExpression - creates a 'bpmn:FormalExpression' element.
105892
+ *
105893
+ * @param {ModdleElement} parent
105894
+ * @param {string} body
105895
+ * @param {BpmnFactory} bpmnFactory
105896
+ *
105897
+ * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
105893
105898
  */
105894
105899
  function createFormalExpression$1(parent, body, bpmnFactory) {
105895
105900
  return createElement$1('bpmn:FormalExpression', {
@@ -105897,13 +105902,13 @@
105897
105902
  }, parent, bpmnFactory);
105898
105903
  }
105899
105904
 
105900
- /**
105901
- * updateFormalExpression - updates a specific formal expression of the loop characteristics.
105902
- *
105903
- * @param {djs.model.Base} element
105904
- * @param {string} propertyName
105905
- * @param {string} newValue
105906
- * @param {BpmnFactory} bpmnFactory
105905
+ /**
105906
+ * updateFormalExpression - updates a specific formal expression of the loop characteristics.
105907
+ *
105908
+ * @param {djs.model.Base} element
105909
+ * @param {string} propertyName
105910
+ * @param {string} newValue
105911
+ * @param {BpmnFactory} bpmnFactory
105907
105912
  */
105908
105913
  function updateFormalExpression(element, propertyName, newValue, bpmnFactory) {
105909
105914
  const loopCharacteristics = getLoopCharacteristics$2(element);
@@ -105940,23 +105945,23 @@
105940
105945
 
105941
105946
  // loopCardinality
105942
105947
 
105943
- /**
105944
- * getLoopCardinality - get the loop cardinality of the loop characteristics.
105945
- *
105946
- * @param {djs.model.Base} element
105947
- *
105948
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
105948
+ /**
105949
+ * getLoopCardinality - get the loop cardinality of the loop characteristics.
105950
+ *
105951
+ * @param {djs.model.Base} element
105952
+ *
105953
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
105949
105954
  */
105950
105955
  function getLoopCardinality(element) {
105951
105956
  return getProperty$2(element, 'loopCardinality');
105952
105957
  }
105953
105958
 
105954
- /**
105955
- * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
105956
- *
105957
- * @param {djs.model.Base} element
105958
- *
105959
- * @return {string} the loop cardinality value
105959
+ /**
105960
+ * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
105961
+ *
105962
+ * @param {djs.model.Base} element
105963
+ *
105964
+ * @return {string} the loop cardinality value
105960
105965
  */
105961
105966
  function getLoopCardinalityValue(element) {
105962
105967
  const loopCardinality = getLoopCardinality(element);
@@ -105965,35 +105970,35 @@
105965
105970
 
105966
105971
  // completionCondition /////////////////////
105967
105972
 
105968
- /**
105969
- * getCompletionCondition - get the completion condition of the loop characteristics.
105970
- *
105971
- * @param {djs.model.Base} element
105972
- *
105973
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
105973
+ /**
105974
+ * getCompletionCondition - get the completion condition of the loop characteristics.
105975
+ *
105976
+ * @param {djs.model.Base} element
105977
+ *
105978
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
105974
105979
  */
105975
105980
  function getCompletionCondition$1(element) {
105976
105981
  return getProperty$2(element, 'completionCondition');
105977
105982
  }
105978
105983
 
105979
- /**
105980
- * getCompletionConditionValue - get the completion condition value of the loop characteristics.
105981
- *
105982
- * @param {djs.model.Base} element
105983
- *
105984
- * @return {string} the completion condition value
105984
+ /**
105985
+ * getCompletionConditionValue - get the completion condition value of the loop characteristics.
105986
+ *
105987
+ * @param {djs.model.Base} element
105988
+ *
105989
+ * @return {string} the completion condition value
105985
105990
  */
105986
105991
  function getCompletionConditionValue(element) {
105987
105992
  const completionCondition = getCompletionCondition$1(element);
105988
105993
  return getBody(completionCondition);
105989
105994
  }
105990
105995
 
105991
- /**
105992
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105996
+ /**
105997
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105993
105998
  */
105994
105999
 
105995
- /**
105996
- * @returns {Array<Entry>} entries
106000
+ /**
106001
+ * @returns {Array<Entry>} entries
105997
106002
  */
105998
106003
  function NameProps(props) {
105999
106004
  const {
@@ -106097,12 +106102,12 @@
106097
106102
  return categoryValue;
106098
106103
  }
106099
106104
 
106100
- /**
106101
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106105
+ /**
106106
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106102
106107
  */
106103
106108
 
106104
- /**
106105
- * @returns {Array<Entry>} entries
106109
+ /**
106110
+ * @returns {Array<Entry>} entries
106106
106111
  */
106107
106112
  function ProcessProps$1(props) {
106108
106113
  const {
@@ -106193,15 +106198,15 @@
106193
106198
  return is$5(element, 'bpmn:Participant') && element.businessObject.get('processRef');
106194
106199
  }
106195
106200
 
106196
- /**
106197
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106201
+ /**
106202
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106198
106203
  */
106199
106204
 
106200
106205
  const EMPTY_OPTION$2 = '';
106201
106206
  const CREATE_NEW_OPTION$1 = 'create-new';
106202
106207
 
106203
- /**
106204
- * @returns {Entry[]}
106208
+ /**
106209
+ * @returns {Entry[]}
106205
106210
  */
106206
106211
  function SignalProps$1(props) {
106207
106212
  const {
@@ -106347,12 +106352,12 @@
106347
106352
  return isAny$1(element, ['bpmn:StartEvent', 'bpmn:IntermediateCatchEvent', 'bpmn:BoundaryEvent']) && !!getTimerEventDefinition$2(element);
106348
106353
  }
106349
106354
 
106350
- /**
106351
- * Get the timer definition type for a given timer event definition.
106352
- *
106353
- * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
106354
- *
106355
- * @return {string|undefined} the timer definition type
106355
+ /**
106356
+ * Get the timer definition type for a given timer event definition.
106357
+ *
106358
+ * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
106359
+ *
106360
+ * @return {string|undefined} the timer definition type
106356
106361
  */
106357
106362
  function getTimerDefinitionType(timer) {
106358
106363
  if (!timer) {
@@ -106422,12 +106427,12 @@
106422
106427
  return entries;
106423
106428
  }
106424
106429
 
106425
- /**
106426
- * TimerEventDefinitionType - Generic select entry allowing to select a specific
106427
- * timerEventDefintionType. To be used together with timerEventDefinitionValue.
106428
- *
106429
- * @param {type} props
106430
- * @return {SelectEntry}
106430
+ /**
106431
+ * TimerEventDefinitionType - Generic select entry allowing to select a specific
106432
+ * timerEventDefintionType. To be used together with timerEventDefinitionValue.
106433
+ *
106434
+ * @param {type} props
106435
+ * @return {SelectEntry}
106431
106436
  */
106432
106437
  function TimerEventDefinitionType$2(props) {
106433
106438
  const {
@@ -106495,13 +106500,13 @@
106495
106500
  });
106496
106501
  }
106497
106502
 
106498
- /**
106499
- * TimerEventDefinitionValue - Generic textField entry allowing to specify the
106500
- * timerEventDefintionValue based on the set timerEventDefintionType. To be used
106501
- * together with timerEventDefinitionType.
106502
- *
106503
- * @param {type} props
106504
- * @return {TextFieldEntry}
106503
+ /**
106504
+ * TimerEventDefinitionValue - Generic textField entry allowing to specify the
106505
+ * timerEventDefintionValue based on the set timerEventDefintionType. To be used
106506
+ * together with timerEventDefinitionType.
106507
+ *
106508
+ * @param {type} props
106509
+ * @return {TextFieldEntry}
106505
106510
  */
106506
106511
  function TimerEventDefinitionValue$2(props) {
106507
106512
  const {
@@ -106786,12 +106791,12 @@
106786
106791
  bpmnPropertiesProvider: ['type', BpmnPropertiesProvider]
106787
106792
  };
106788
106793
 
106789
- /**
106790
- * Get extension elements of business object. Optionally filter by type.
106791
- *
106792
- * @param {ModdleElement} businessObject
106793
- * @param {string} [type=undefined]
106794
- * @returns {Array<ModdleElement>}
106794
+ /**
106795
+ * Get extension elements of business object. Optionally filter by type.
106796
+ *
106797
+ * @param {ModdleElement} businessObject
106798
+ * @param {string} [type=undefined]
106799
+ * @returns {Array<ModdleElement>}
106795
106800
  */
106796
106801
  function getExtensionElementsList$1(businessObject, type = undefined) {
106797
106802
  const extensionElements = businessObject.get('extensionElements');
@@ -106808,13 +106813,13 @@
106808
106813
  return values;
106809
106814
  }
106810
106815
 
106811
- /**
106812
- * Add one or more extension elements. Create bpmn:ExtensionElements if it doesn't exist.
106813
- *
106814
- * @param {ModdleElement} element
106815
- * @param {ModdleElement} businessObject
106816
- * @param {ModdleElement|Array<ModdleElement>} extensionElementsToAdd
106817
- * @param {CommandStack} commandStack
106816
+ /**
106817
+ * Add one or more extension elements. Create bpmn:ExtensionElements if it doesn't exist.
106818
+ *
106819
+ * @param {ModdleElement} element
106820
+ * @param {ModdleElement} businessObject
106821
+ * @param {ModdleElement|Array<ModdleElement>} extensionElementsToAdd
106822
+ * @param {CommandStack} commandStack
106818
106823
  */
106819
106824
  function addExtensionElements(element, businessObject, extensionElementToAdd, bpmnFactory, commandStack) {
106820
106825
  const commands = [];
@@ -106852,13 +106857,13 @@
106852
106857
  commandStack.execute('properties-panel.multi-command-executor', commands);
106853
106858
  }
106854
106859
 
106855
- /**
106856
- * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
106857
- *
106858
- * @param {ModdleElement} element
106859
- * @param {ModdleElement} businessObject
106860
- * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
106861
- * @param {CommandStack} commandStack
106860
+ /**
106861
+ * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
106862
+ *
106863
+ * @param {ModdleElement} element
106864
+ * @param {ModdleElement} businessObject
106865
+ * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
106866
+ * @param {CommandStack} commandStack
106862
106867
  */
106863
106868
  function removeExtensionElements$1(element, businessObject, extensionElementsToRemove, commandStack) {
106864
106869
  if (!isArray$4(extensionElementsToRemove)) {
@@ -107251,37 +107256,37 @@
107251
107256
 
107252
107257
  // helper //////////////////
107253
107258
 
107254
- /**
107255
- * Returns true if the attribute 'camunda:asyncBefore' is set
107256
- * to true.
107257
- *
107258
- * @param {ModdleElement} bo
107259
- *
107260
- * @return {boolean} a boolean value
107259
+ /**
107260
+ * Returns true if the attribute 'camunda:asyncBefore' is set
107261
+ * to true.
107262
+ *
107263
+ * @param {ModdleElement} bo
107264
+ *
107265
+ * @return {boolean} a boolean value
107261
107266
  */
107262
107267
  function isAsyncBefore$2(bo) {
107263
107268
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
107264
107269
  }
107265
107270
 
107266
- /**
107267
- * Returns true if the attribute 'camunda:asyncAfter' is set
107268
- * to true.
107269
- *
107270
- * @param {ModdleElement} bo
107271
- *
107272
- * @return {boolean} a boolean value
107271
+ /**
107272
+ * Returns true if the attribute 'camunda:asyncAfter' is set
107273
+ * to true.
107274
+ *
107275
+ * @param {ModdleElement} bo
107276
+ *
107277
+ * @return {boolean} a boolean value
107273
107278
  */
107274
107279
  function isAsyncAfter$2(bo) {
107275
107280
  return !!bo.get('camunda:asyncAfter');
107276
107281
  }
107277
107282
 
107278
- /**
107279
- * Returns true if the attribute 'camunda:exclusive' is set
107280
- * to true.
107281
- *
107282
- * @param {ModdleElement} bo
107283
- *
107284
- * @return {boolean} a boolean value
107283
+ /**
107284
+ * Returns true if the attribute 'camunda:exclusive' is set
107285
+ * to true.
107286
+ *
107287
+ * @param {ModdleElement} bo
107288
+ *
107289
+ * @return {boolean} a boolean value
107285
107290
  */
107286
107291
  function isExclusive$1(bo) {
107287
107292
  return !!bo.get('camunda:exclusive');
@@ -108097,12 +108102,12 @@
108097
108102
 
108098
108103
  // helper //////////////////
108099
108104
 
108100
- /**
108101
- * getProcess - get the businessObject of the process referred to by a bpmn:Process
108102
- * or by a bpmn:Participant
108103
- *
108104
- * @param {ModdleElement} element either a bpmn:Process or a bpmn:Participant
108105
- * @return {BusinessObject}
108105
+ /**
108106
+ * getProcess - get the businessObject of the process referred to by a bpmn:Process
108107
+ * or by a bpmn:Participant
108108
+ *
108109
+ * @param {ModdleElement} element either a bpmn:Process or a bpmn:Participant
108110
+ * @return {BusinessObject}
108106
108111
  */
108107
108112
  function getProcess$3(element) {
108108
108113
  return is$5(element, 'bpmn:Process') ? getBusinessObject$1(element) : getBusinessObject$1(element).get('processRef');
@@ -108494,12 +108499,12 @@
108494
108499
  }
108495
108500
  }
108496
108501
 
108497
- /**
108498
- * getConditionExpression - get the body value of a condition expression for a given element
108499
- *
108500
- * @param {ModdleElement} element
108501
- *
108502
- * @return {string|undefined}
108502
+ /**
108503
+ * getConditionExpression - get the body value of a condition expression for a given element
108504
+ *
108505
+ * @param {ModdleElement} element
108506
+ *
108507
+ * @return {string|undefined}
108503
108508
  */
108504
108509
  function getConditionExpression(element) {
108505
108510
  const businessObject = getBusinessObject$1(element);
@@ -108545,8 +108550,8 @@
108545
108550
  return is$5(parent, 'bpmn:SubProcess') && parent.triggeredByEvent;
108546
108551
  }
108547
108552
 
108548
- /**
108549
- * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/scripting/
108553
+ /**
108554
+ * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/scripting/
108550
108555
  */
108551
108556
  function ScriptProps(props) {
108552
108557
  const {
@@ -108774,12 +108779,12 @@
108774
108779
  return inputOutput && inputOutput.get(prop) || [];
108775
108780
  }
108776
108781
 
108777
- /**
108778
- * Get a camunda:inputOutput from the business object
108779
- *
108780
- * @param {djs.model.Base | ModdleElement} element
108781
- *
108782
- * @return {ModdleElement} the inputOutput object
108782
+ /**
108783
+ * Get a camunda:inputOutput from the business object
108784
+ *
108785
+ * @param {djs.model.Base | ModdleElement} element
108786
+ *
108787
+ * @return {ModdleElement} the inputOutput object
108783
108788
  */
108784
108789
  function getInputOutput$1(element) {
108785
108790
  if (is$5(element, 'camunda:Connector')) {
@@ -108789,25 +108794,25 @@
108789
108794
  return (getElements(businessObject, 'camunda:InputOutput') || [])[0];
108790
108795
  }
108791
108796
 
108792
- /**
108793
- * Return all input parameters existing in the business object, and
108794
- * an empty array if none exist.
108795
- *
108796
- * @param {djs.model.Base} element
108797
- *
108798
- * @return {Array} a list of input parameter objects
108797
+ /**
108798
+ * Return all input parameters existing in the business object, and
108799
+ * an empty array if none exist.
108800
+ *
108801
+ * @param {djs.model.Base} element
108802
+ *
108803
+ * @return {Array} a list of input parameter objects
108799
108804
  */
108800
108805
  function getInputParameters$2(element) {
108801
108806
  return getParameters$1(element, 'inputParameters');
108802
108807
  }
108803
108808
 
108804
- /**
108805
- * Return all output parameters existing in the business object, and
108806
- * an empty array if none exist.
108807
- *
108808
- * @param {djs.model.Base} element
108809
- *
108810
- * @return {Array} a list of output parameter objects
108809
+ /**
108810
+ * Return all output parameters existing in the business object, and
108811
+ * an empty array if none exist.
108812
+ *
108813
+ * @param {djs.model.Base} element
108814
+ *
108815
+ * @return {Array} a list of output parameter objects
108811
108816
  */
108812
108817
  function getOutputParameters$2(element) {
108813
108818
  return getParameters$1(element, 'outputParameters');
@@ -109383,47 +109388,47 @@
109383
109388
  return is$5(parameter, 'camunda:InputParameter');
109384
109389
  }
109385
109390
 
109386
- /**
109387
- * Check whether an element is camunda:ServiceTaskLike
109388
- *
109389
- * @param {djs.model.Base} element
109390
- *
109391
- * @return {boolean} a boolean value
109391
+ /**
109392
+ * Check whether an element is camunda:ServiceTaskLike
109393
+ *
109394
+ * @param {djs.model.Base} element
109395
+ *
109396
+ * @return {boolean} a boolean value
109392
109397
  */
109393
109398
  function isServiceTaskLike(element) {
109394
109399
  return is$5(element, 'camunda:ServiceTaskLike');
109395
109400
  }
109396
109401
 
109397
- /**
109398
- * Returns 'true' if the given element is 'camunda:DmnCapable'
109399
- *
109400
- * @param {djs.model.Base} element
109401
- *
109402
- * @return {boolean} a boolean value
109402
+ /**
109403
+ * Returns 'true' if the given element is 'camunda:DmnCapable'
109404
+ *
109405
+ * @param {djs.model.Base} element
109406
+ *
109407
+ * @return {boolean} a boolean value
109403
109408
  */
109404
109409
  function isDmnCapable(element) {
109405
109410
  return is$5(element, 'camunda:DmnCapable');
109406
109411
  }
109407
109412
 
109408
- /**
109409
- * Returns 'true' if the given element is 'camunda:ExternalCapable'
109410
- *
109411
- * @param {djs.model.Base} element
109412
- *
109413
- * @return {boolean} a boolean value
109413
+ /**
109414
+ * Returns 'true' if the given element is 'camunda:ExternalCapable'
109415
+ *
109416
+ * @param {djs.model.Base} element
109417
+ *
109418
+ * @return {boolean} a boolean value
109414
109419
  */
109415
109420
  function isExternalCapable(element) {
109416
109421
  return is$5(element, 'camunda:ExternalCapable');
109417
109422
  }
109418
109423
 
109419
- /**
109420
- * getServiceTaskLikeBusinessObject - Get a 'camunda:ServiceTaskLike' business object.
109421
- *
109422
- * If the given element is not a 'camunda:ServiceTaskLike', then 'false'
109423
- * is returned.
109424
- *
109425
- * @param {djs.model.Base} element
109426
- * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object
109424
+ /**
109425
+ * getServiceTaskLikeBusinessObject - Get a 'camunda:ServiceTaskLike' business object.
109426
+ *
109427
+ * If the given element is not a 'camunda:ServiceTaskLike', then 'false'
109428
+ * is returned.
109429
+ *
109430
+ * @param {djs.model.Base} element
109431
+ * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object
109427
109432
  */
109428
109433
  function getServiceTaskLikeBusinessObject(element) {
109429
109434
  if (is$5(element, 'bpmn:IntermediateThrowEvent') || is$5(element, 'bpmn:EndEvent')) {
@@ -109439,22 +109444,22 @@
109439
109444
  return isServiceTaskLike(element) && getBusinessObject$1(element);
109440
109445
  }
109441
109446
 
109442
- /**
109443
- * Returns the implementation type of the given element.
109444
- *
109445
- * Possible implementation types are:
109446
- * - dmn
109447
- * - connector
109448
- * - external
109449
- * - class
109450
- * - expression
109451
- * - delegateExpression
109452
- * - script
109453
- * - or undefined, when no matching implementation type is found
109454
- *
109455
- * @param {djs.model.Base} element
109456
- *
109457
- * @return {String} the implementation type
109447
+ /**
109448
+ * Returns the implementation type of the given element.
109449
+ *
109450
+ * Possible implementation types are:
109451
+ * - dmn
109452
+ * - connector
109453
+ * - external
109454
+ * - class
109455
+ * - expression
109456
+ * - delegateExpression
109457
+ * - script
109458
+ * - or undefined, when no matching implementation type is found
109459
+ *
109460
+ * @param {djs.model.Base} element
109461
+ *
109462
+ * @return {String} the implementation type
109458
109463
  */
109459
109464
  function getImplementationType(element) {
109460
109465
  const businessObject = getListenerBusinessObject(element) || getServiceTaskLikeBusinessObject(element);
@@ -110162,12 +110167,12 @@
110162
110167
  return name;
110163
110168
  }
110164
110169
 
110165
- /**
110166
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
110170
+ /**
110171
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
110167
110172
  */
110168
110173
 
110169
- /**
110170
- * @returns {Array<Entry>} entries
110174
+ /**
110175
+ * @returns {Array<Entry>} entries
110171
110176
  */
110172
110177
  function EscalationProps(props) {
110173
110178
  const {
@@ -110421,12 +110426,12 @@
110421
110426
 
110422
110427
  // helper ///////////////////
110423
110428
 
110424
- /**
110425
- * determineType - get the type of a fieldInjection based on the attributes
110426
- * set on it
110427
- *
110428
- * @param {ModdleElement} field
110429
- * @return {('string'|'expression')}
110429
+ /**
110430
+ * determineType - get the type of a fieldInjection based on the attributes
110431
+ * set on it
110432
+ *
110433
+ * @param {ModdleElement} field
110434
+ * @return {('string'|'expression')}
110430
110435
  */
110431
110436
  function determineType(field) {
110432
110437
  // string is the default type
@@ -112558,8 +112563,8 @@
112558
112563
  return is$5(element, 'camunda:Initiator') && !is$5(element.parent, 'bpmn:SubProcess');
112559
112564
  }
112560
112565
 
112561
- /**
112562
- * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
112566
+ /**
112567
+ * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
112563
112568
  */
112564
112569
  function InMappingPropagationProps(props) {
112565
112570
  const {
@@ -112901,8 +112906,8 @@
112901
112906
  return inOutType;
112902
112907
  }
112903
112908
 
112904
- /**
112905
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#in
112909
+ /**
112910
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#in
112906
112911
  */
112907
112912
  function InMappingProps({
112908
112913
  element,
@@ -113185,49 +113190,49 @@
113185
113190
 
113186
113191
  // helper //////////////////
113187
113192
 
113188
- /**
113189
- * @param {ModdleElement} bo
113190
- * @return {boolean} a boolean value
113193
+ /**
113194
+ * @param {ModdleElement} bo
113195
+ * @return {boolean} a boolean value
113191
113196
  */
113192
113197
  function isAsyncBefore$1$1(bo) {
113193
113198
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
113194
113199
  }
113195
113200
 
113196
- /**
113197
- * @param {ModdleElement} bo
113198
- * @return {boolean}
113201
+ /**
113202
+ * @param {ModdleElement} bo
113203
+ * @return {boolean}
113199
113204
  */
113200
113205
  function isAsyncAfter$1$1(bo) {
113201
113206
  return !!bo.get('camunda:asyncAfter');
113202
113207
  }
113203
113208
 
113204
- /**
113205
- * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
113206
- * is set to true.
113207
- *
113208
- * @param {ModdleElement} bo
113209
- * @return {boolean}
113209
+ /**
113210
+ * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
113211
+ * is set to true.
113212
+ *
113213
+ * @param {ModdleElement} bo
113214
+ * @return {boolean}
113210
113215
  */
113211
113216
  function isAsync$1(bo) {
113212
113217
  return isAsyncAfter$1$1(bo) || isAsyncBefore$1$1(bo);
113213
113218
  }
113214
113219
 
113215
- /**
113216
- * isTimerEvent - returns true if the element is a bpmn:Event with a timerEventDefinition
113217
- *
113218
- * @param {ModdleElement} element
113219
- * @return {boolean}
113220
+ /**
113221
+ * isTimerEvent - returns true if the element is a bpmn:Event with a timerEventDefinition
113222
+ *
113223
+ * @param {ModdleElement} element
113224
+ * @return {boolean}
113220
113225
  */
113221
113226
  function isTimerEvent(element) {
113222
113227
  return is$5(element, 'bpmn:Event') && getTimerEventDefinition$1(element);
113223
113228
  }
113224
113229
 
113225
- /**
113226
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
113230
+ /**
113231
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
113227
113232
  */
113228
113233
 
113229
- /**
113230
- * @returns {Array<Entry>} entries
113234
+ /**
113235
+ * @returns {Array<Entry>} entries
113231
113236
  */
113232
113237
  function MultiInstanceProps(props) {
113233
113238
  const {
@@ -113489,36 +113494,36 @@
113489
113494
 
113490
113495
  // generic ///////////////////////////
113491
113496
 
113492
- /**
113493
- * isMultiInstanceSupported - check whether given element supports camunda specific props
113494
- * for multiInstance (ref. <camunda:Cllectable>).
113495
- *
113496
- * @param {djs.model.Base} element
113497
- * @return {boolean}
113497
+ /**
113498
+ * isMultiInstanceSupported - check whether given element supports camunda specific props
113499
+ * for multiInstance (ref. <camunda:Cllectable>).
113500
+ *
113501
+ * @param {djs.model.Base} element
113502
+ * @return {boolean}
113498
113503
  */
113499
113504
  function isMultiInstanceSupported(element) {
113500
113505
  const loopCharacteristics = getLoopCharacteristics(element);
113501
113506
  return !!loopCharacteristics && is$5(loopCharacteristics, 'camunda:Collectable');
113502
113507
  }
113503
113508
 
113504
- /**
113505
- * getProperty - get a property value of the loop characteristics.
113506
- *
113507
- * @param {djs.model.Base} element
113508
- * @param {string} propertyName
113509
- *
113510
- * @return {any} the property value
113509
+ /**
113510
+ * getProperty - get a property value of the loop characteristics.
113511
+ *
113512
+ * @param {djs.model.Base} element
113513
+ * @param {string} propertyName
113514
+ *
113515
+ * @return {any} the property value
113511
113516
  */
113512
113517
  function getProperty(element, propertyName) {
113513
113518
  var loopCharacteristics = getLoopCharacteristics(element);
113514
113519
  return loopCharacteristics && loopCharacteristics.get(propertyName);
113515
113520
  }
113516
113521
 
113517
- /**
113518
- * getLoopCharacteristics - get loopCharacteristics of a given element.
113519
- *
113520
- * @param {djs.model.Base} element
113521
- * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
113522
+ /**
113523
+ * getLoopCharacteristics - get loopCharacteristics of a given element.
113524
+ *
113525
+ * @param {djs.model.Base} element
113526
+ * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
113522
113527
  */
113523
113528
  function getLoopCharacteristics(element) {
113524
113529
  const bo = getBusinessObject$1(element);
@@ -113527,12 +113532,12 @@
113527
113532
 
113528
113533
  // collection
113529
113534
 
113530
- /**
113531
- * getCollection - get the 'camunda:collection' attribute value of the loop characteristics.
113532
- *
113533
- * @param {djs.model.Base} element
113534
- *
113535
- * @return {string} the 'camunda:collection' value
113535
+ /**
113536
+ * getCollection - get the 'camunda:collection' attribute value of the loop characteristics.
113537
+ *
113538
+ * @param {djs.model.Base} element
113539
+ *
113540
+ * @return {string} the 'camunda:collection' value
113536
113541
  */
113537
113542
  function getCollection(element) {
113538
113543
  return getProperty(element, 'camunda:collection');
@@ -113540,12 +113545,12 @@
113540
113545
 
113541
113546
  // elementVariable
113542
113547
 
113543
- /**
113544
- * getElementVariable - get the 'camunda:elementVariable' attribute value of the loop characteristics.
113545
- *
113546
- * @param {djs.model.Base} element
113547
- *
113548
- * @return {string} the 'camunda:elementVariable' value
113548
+ /**
113549
+ * getElementVariable - get the 'camunda:elementVariable' attribute value of the loop characteristics.
113550
+ *
113551
+ * @param {djs.model.Base} element
113552
+ *
113553
+ * @return {string} the 'camunda:elementVariable' value
113549
113554
  */
113550
113555
  function getElementVariable(element) {
113551
113556
  return getProperty(element, 'camunda:elementVariable');
@@ -113553,48 +113558,48 @@
113553
113558
 
113554
113559
  // asyncBefore asyncAfter
113555
113560
 
113556
- /**
113557
- * Returns true if the attribute 'camunda:asyncBefore' is set
113558
- * to true.
113559
- *
113560
- * @param {ModdleElement} bo
113561
- *
113562
- * @return {boolean} a boolean value
113561
+ /**
113562
+ * Returns true if the attribute 'camunda:asyncBefore' is set
113563
+ * to true.
113564
+ *
113565
+ * @param {ModdleElement} bo
113566
+ *
113567
+ * @return {boolean} a boolean value
113563
113568
  */
113564
113569
  function isAsyncBefore$3(bo) {
113565
113570
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
113566
113571
  }
113567
113572
 
113568
- /**
113569
- * Returns true if the attribute 'camunda:asyncAfter' is set
113570
- * to true.
113571
- *
113572
- * @param {ModdleElement} bo
113573
- *
113574
- * @return {boolean} a boolean value
113573
+ /**
113574
+ * Returns true if the attribute 'camunda:asyncAfter' is set
113575
+ * to true.
113576
+ *
113577
+ * @param {ModdleElement} bo
113578
+ *
113579
+ * @return {boolean} a boolean value
113575
113580
  */
113576
113581
  function isAsyncAfter$3(bo) {
113577
113582
  return !!bo.get('camunda:asyncAfter');
113578
113583
  }
113579
113584
 
113580
- /**
113581
- * Returns true if the attribute 'camunda:exclusive' is set
113582
- * to true.
113583
- *
113584
- * @param {ModdleElement} bo
113585
- *
113586
- * @return {boolean} a boolean value
113585
+ /**
113586
+ * Returns true if the attribute 'camunda:exclusive' is set
113587
+ * to true.
113588
+ *
113589
+ * @param {ModdleElement} bo
113590
+ *
113591
+ * @return {boolean} a boolean value
113587
113592
  */
113588
113593
  function isExclusive$2(bo) {
113589
113594
  return !!bo.get('camunda:exclusive');
113590
113595
  }
113591
113596
 
113592
- /**
113593
- * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
113594
- * is set to true.
113595
- *
113596
- * @param {ModdleElement} bo
113597
- * @return {boolean}
113597
+ /**
113598
+ * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
113599
+ * is set to true.
113600
+ *
113601
+ * @param {ModdleElement} bo
113602
+ * @return {boolean}
113598
113603
  */
113599
113604
  function isAsync(bo) {
113600
113605
  return isAsyncAfter$3(bo) || isAsyncBefore$3(bo);
@@ -113606,8 +113611,8 @@
113606
113611
  return node && !node.checked;
113607
113612
  }
113608
113613
 
113609
- /**
113610
- * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
113614
+ /**
113615
+ * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
113611
113616
  */
113612
113617
  function OutMappingPropagationProps(props) {
113613
113618
  const {
@@ -113715,8 +113720,8 @@
113715
113720
  return !!mappings.length;
113716
113721
  }
113717
113722
 
113718
- /**
113719
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#out
113723
+ /**
113724
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#out
113720
113725
  */
113721
113726
  function OutMappingProps({
113722
113727
  element,
@@ -113907,12 +113912,12 @@
113907
113912
  return entries;
113908
113913
  }
113909
113914
 
113910
- /**
113911
- * TimerEventDefinitionType - Generic select entry allowing to select a specific
113912
- * timerEventDefintionType. To be used together with timerEventDefinitionValue.
113913
- *
113914
- * @param {type} props
113915
- * @return {SelectEntry}
113915
+ /**
113916
+ * TimerEventDefinitionType - Generic select entry allowing to select a specific
113917
+ * timerEventDefintionType. To be used together with timerEventDefinitionValue.
113918
+ *
113919
+ * @param {type} props
113920
+ * @return {SelectEntry}
113916
113921
  */
113917
113922
  function TimerEventDefinitionType(props) {
113918
113923
  const {
@@ -113980,13 +113985,13 @@
113980
113985
  });
113981
113986
  }
113982
113987
 
113983
- /**
113984
- * TimerEventDefinitionValue - Generic textField entry allowing to specify the
113985
- * timerEventDefintionValue based on the set timerEventDefintionType. To be used
113986
- * together with timerEventDefinitionType.
113987
- *
113988
- * @param {type} props
113989
- * @return {TextFieldEntry}
113988
+ /**
113989
+ * TimerEventDefinitionValue - Generic textField entry allowing to specify the
113990
+ * timerEventDefintionValue based on the set timerEventDefintionType. To be used
113991
+ * together with timerEventDefinitionType.
113992
+ *
113993
+ * @param {type} props
113994
+ * @return {TextFieldEntry}
113990
113995
  */
113991
113996
  function TimerEventDefinitionValue(props) {
113992
113997
  const {
@@ -114148,8 +114153,8 @@
114148
114153
  timeout: 'Timeout'
114149
114154
  };
114150
114155
 
114151
- /**
114152
- * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/delegation-code/#execution-listener
114156
+ /**
114157
+ * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/delegation-code/#execution-listener
114153
114158
  */
114154
114159
  function ExecutionListenerProps({
114155
114160
  element,
@@ -114561,11 +114566,11 @@
114561
114566
 
114562
114567
  // helper
114563
114568
 
114564
- /**
114565
- * Get a readable label for a listener.
114566
- *
114567
- * @param {ModdleElement} listener
114568
- * @param {string => string} [translate]
114569
+ /**
114570
+ * Get a readable label for a listener.
114571
+ *
114572
+ * @param {ModdleElement} listener
114573
+ * @param {string => string} [translate]
114569
114574
  */
114570
114575
  function getListenerLabel(listener, translate = value => value) {
114571
114576
  const event = listener.get('event');
@@ -114912,8 +114917,8 @@
114912
114917
  return is$5(element, 'bpmn:Process') ? getBusinessObject$1(element) : getBusinessObject$1(element).get('processRef');
114913
114918
  }
114914
114919
 
114915
- /**
114916
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/
114920
+ /**
114921
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/
114917
114922
  */
114918
114923
  function UserAssignmentProps(props) {
114919
114924
  const {
@@ -115175,12 +115180,12 @@
115175
115180
  return is$5(element, 'bpmn:Process') ? getBusinessObject$1(element) : getBusinessObject$1(element).get('processRef');
115176
115181
  }
115177
115182
 
115178
- /**
115179
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
115183
+ /**
115184
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
115180
115185
  */
115181
115186
 
115182
- /**
115183
- * @returns {Array<Entry>} entries
115187
+ /**
115188
+ * @returns {Array<Entry>} entries
115184
115189
  */
115185
115190
  function IdProps() {
115186
115191
  return [{
@@ -115224,12 +115229,12 @@
115224
115229
  });
115225
115230
  }
115226
115231
 
115227
- /**
115228
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
115232
+ /**
115233
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
115229
115234
  */
115230
115235
 
115231
- /**
115232
- * @returns {Array<Entry>} entries
115236
+ /**
115237
+ * @returns {Array<Entry>} entries
115233
115238
  */
115234
115239
  function ProcessProps(props) {
115235
115240
  const {
@@ -115292,30 +115297,30 @@
115292
115297
  const LOW_PRIORITY$4 = 500;
115293
115298
  const CAMUNDA_PLATFORM_GROUPS = [HistoryCleanupGroup, TasklistGroup, CandidateStarterGroup, ImplementationGroup, ExternalTaskGroup, ProcessVariablesGroup, ErrorsGroup, UserAssignmentGroup, FormGroup, FormDataGroup, TaskListenerGroup, StartInitiatorGroup, ScriptGroup, ConditionGroup, CallActivityGroup, AsynchronousContinuationsGroup, JobExecutionGroup, InMappingPropagationGroup, InMappingGroup, InputGroup, ConnectorInputGroup, OutMappingPropagationGroup, OutMappingGroup, OutputGroup, ConnectorOutputGroup, ExecutionListenerGroup, ExtensionPropertiesGroup, FieldInjectionGroup, BusinessKeyGroup];
115294
115299
 
115295
- /**
115296
- * Provides `camunda` namespace properties.
115297
- *
115298
- * @example
115299
- * ```javascript
115300
- * import BpmnModeler from 'bpmn-js/lib/Modeler';
115301
- * import {
115302
- * BpmnPropertiesPanelModule,
115303
- * BpmnPropertiesProviderModule,
115304
- * CamundaPlatformPropertiesProviderModule
115305
- * } from 'bpmn-js-properties-panel';
115306
- *
115307
- * const modeler = new BpmnModeler({
115308
- * container: '#canvas',
115309
- * propertiesPanel: {
115310
- * parent: '#properties'
115311
- * },
115312
- * additionalModules: [
115313
- * BpmnPropertiesPanelModule,
115314
- * BpmnPropertiesProviderModule,
115315
- * CamundaPlatformPropertiesProviderModule
115316
- * ]
115317
- * });
115318
- * ```
115300
+ /**
115301
+ * Provides `camunda` namespace properties.
115302
+ *
115303
+ * @example
115304
+ * ```javascript
115305
+ * import BpmnModeler from 'bpmn-js/lib/Modeler';
115306
+ * import {
115307
+ * BpmnPropertiesPanelModule,
115308
+ * BpmnPropertiesProviderModule,
115309
+ * CamundaPlatformPropertiesProviderModule
115310
+ * } from 'bpmn-js-properties-panel';
115311
+ *
115312
+ * const modeler = new BpmnModeler({
115313
+ * container: '#canvas',
115314
+ * propertiesPanel: {
115315
+ * parent: '#properties'
115316
+ * },
115317
+ * additionalModules: [
115318
+ * BpmnPropertiesPanelModule,
115319
+ * BpmnPropertiesProviderModule,
115320
+ * CamundaPlatformPropertiesProviderModule
115321
+ * ]
115322
+ * });
115323
+ * ```
115319
115324
  */
115320
115325
  class CamundaPlatformPropertiesProvider {
115321
115326
  constructor(propertiesPanel, injector) {
@@ -115348,8 +115353,8 @@
115348
115353
  }
115349
115354
  CamundaPlatformPropertiesProvider.$inject = ['propertiesPanel', 'injector'];
115350
115355
 
115351
- /**
115352
- * This ensures the <Implementation> group always locates after <Documentation>
115356
+ /**
115357
+ * This ensures the <Implementation> group always locates after <Documentation>
115353
115358
  */
115354
115359
  function moveImplementationGroup(groups) {
115355
115360
  const documentationGroupIdx = findGroupIndex(groups, 'documentation');