camunda-bpmn-js 4.17.0 → 4.18.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.
@@ -27687,29 +27687,34 @@
27687
27687
  * Update context pad position.
27688
27688
  */
27689
27689
  ContextPad.prototype._updatePosition = function() {
27690
- if (!this.isOpen()) {
27691
- return;
27692
- }
27693
27690
 
27694
- var html = this._current.html;
27691
+ const updateFn = () => {
27692
+ if (!this.isOpen()) {
27693
+ return;
27694
+ }
27695
27695
 
27696
- var position = this._getPosition(this._current.target);
27696
+ var html = this._current.html;
27697
27697
 
27698
- if ('x' in position && 'y' in position) {
27699
- html.style.left = position.x + 'px';
27700
- html.style.top = position.y + 'px';
27701
- } else {
27702
- [
27703
- 'top',
27704
- 'right',
27705
- 'bottom',
27706
- 'left'
27707
- ].forEach(function(key) {
27708
- if (key in position) {
27709
- html.style[ key ] = position[ key ] + 'px';
27710
- }
27711
- });
27712
- }
27698
+ var position = this._getPosition(this._current.target);
27699
+
27700
+ if ('x' in position && 'y' in position) {
27701
+ html.style.left = position.x + 'px';
27702
+ html.style.top = position.y + 'px';
27703
+ } else {
27704
+ [
27705
+ 'top',
27706
+ 'right',
27707
+ 'bottom',
27708
+ 'left'
27709
+ ].forEach(function(key) {
27710
+ if (key in position) {
27711
+ html.style[ key ] = position[ key ] + 'px';
27712
+ }
27713
+ });
27714
+ }
27715
+ };
27716
+
27717
+ this._scheduler.schedule(updateFn, 'ContextPad#_updatePosition');
27713
27718
  };
27714
27719
 
27715
27720
  /**
@@ -44915,9 +44920,16 @@
44915
44920
  hints.moveChildren = false;
44916
44921
  }
44917
44922
 
44918
- // apply same width and default height
44919
- newElement.width = element.width;
44920
- newElement.height = elementFactory.getDefaultSize(newElement).height;
44923
+ // apply same directionality
44924
+ var isHorizontalPool = isHorizontal$3(element);
44925
+ if (!getDi$1(element).isHorizontal) {
44926
+ getDi$1(newElement).isHorizontal = isHorizontalPool;
44927
+ }
44928
+
44929
+ // keep the existing size of the pool's direction to
44930
+ // prevent dangling message flows
44931
+ newElement.width = isHorizontalPool ? element.width : elementFactory.getDefaultSize(newElement).width;
44932
+ newElement.height = isHorizontalPool ? elementFactory.getDefaultSize(newElement).height : element.height;
44921
44933
  }
44922
44934
 
44923
44935
  if (!rules.allowed('shape.resize', { shape: newBusinessObject })) {
@@ -48603,10 +48615,17 @@
48603
48615
  }
48604
48616
 
48605
48617
  if (is$6(bo, 'bpmn:Participant')) {
48618
+ var isHorizontalPool = di.isHorizontal === undefined || di.isHorizontal === true;
48606
48619
  if (isExpanded$1(bo, di)) {
48607
- return { width: 600, height: 250 };
48620
+ if (isHorizontalPool) {
48621
+ return { width: 600, height: 250 };
48622
+ }
48623
+ return { width: 250, height: 600 };
48608
48624
  } else {
48609
- return { width: 400, height: 60 };
48625
+ if (isHorizontalPool) {
48626
+ return { width: 400, height: 60 };
48627
+ }
48628
+ return { width: 60, height: 400 };
48610
48629
  }
48611
48630
  }
48612
48631
 
@@ -105193,8 +105212,8 @@
105193
105212
  });
105194
105213
  const selectedElement = state.selectedElement;
105195
105214
 
105196
- /**
105197
- * @param {djs.model.Base | Array<djs.model.Base>} element
105215
+ /**
105216
+ * @param {djs.model.Base | Array<djs.model.Base>} element
105198
105217
  */
105199
105218
  const _update = element => {
105200
105219
  if (!element) {
@@ -105379,10 +105398,10 @@
105379
105398
 
105380
105399
  const DEFAULT_PRIORITY$1 = 1000;
105381
105400
 
105382
- /**
105383
- * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
105384
- * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
105385
- * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
105401
+ /**
105402
+ * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
105403
+ * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
105404
+ * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
105386
105405
  */
105387
105406
 
105388
105407
  class BpmnPropertiesPanelRenderer {
@@ -105419,10 +105438,10 @@
105419
105438
  });
105420
105439
  }
105421
105440
 
105422
- /**
105423
- * Attach the properties panel to a parent node.
105424
- *
105425
- * @param {HTMLElement} container
105441
+ /**
105442
+ * Attach the properties panel to a parent node.
105443
+ *
105444
+ * @param {HTMLElement} container
105426
105445
  */
105427
105446
  attachTo(container) {
105428
105447
  if (!container) {
@@ -105447,8 +105466,8 @@
105447
105466
  this._eventBus.fire('propertiesPanel.attach');
105448
105467
  }
105449
105468
 
105450
- /**
105451
- * Detach the properties panel from its parent node.
105469
+ /**
105470
+ * Detach the properties panel from its parent node.
105452
105471
  */
105453
105472
  detach() {
105454
105473
  const parentNode = this._container.parentNode;
@@ -105458,11 +105477,11 @@
105458
105477
  }
105459
105478
  }
105460
105479
 
105461
- /**
105462
- * Register a new properties provider to the properties panel.
105463
- *
105464
- * @param {Number} [priority]
105465
- * @param {PropertiesProvider} provider
105480
+ /**
105481
+ * Register a new properties provider to the properties panel.
105482
+ *
105483
+ * @param {Number} [priority]
105484
+ * @param {PropertiesProvider} provider
105466
105485
  */
105467
105486
  registerProvider(priority, provider) {
105468
105487
  if (!provider) {
@@ -105479,9 +105498,9 @@
105479
105498
  this._eventBus.fire('propertiesPanel.providersChanged');
105480
105499
  }
105481
105500
 
105482
- /**
105483
- * Updates the layout of the properties panel.
105484
- * @param {Object} layout
105501
+ /**
105502
+ * Updates the layout of the properties panel.
105503
+ * @param {Object} layout
105485
105504
  */
105486
105505
  setLayout(layout) {
105487
105506
  this._eventBus.fire('propertiesPanel.setLayout', {
@@ -105531,12 +105550,12 @@
105531
105550
  return element && (element.isImplicit || element.id === '__implicitroot');
105532
105551
  }
105533
105552
 
105534
- /**
105535
- * Setup keyboard bindings (undo, redo) on the given container.
105536
- *
105537
- * @param {Element} container
105538
- * @param {EventBus} eventBus
105539
- * @param {CommandStack} commandStack
105553
+ /**
105554
+ * Setup keyboard bindings (undo, redo) on the given container.
105555
+ *
105556
+ * @param {Element} container
105557
+ * @param {EventBus} eventBus
105558
+ * @param {CommandStack} commandStack
105540
105559
  */
105541
105560
  function setupKeyboard(container, eventBus, commandStack) {
105542
105561
  function cancel(event) {
@@ -105561,14 +105580,14 @@
105561
105580
  });
105562
105581
  }
105563
105582
 
105564
- /**
105565
- * A handler that combines and executes multiple commands.
105566
- *
105567
- * All updates are bundled on the command stack and executed in one step.
105568
- * This also makes it possible to revert the changes in one step.
105569
- *
105570
- * Example use case: remove the camunda:formKey attribute and in addition
105571
- * add all form fields needed for the camunda:formData property.
105583
+ /**
105584
+ * A handler that combines and executes multiple commands.
105585
+ *
105586
+ * All updates are bundled on the command stack and executed in one step.
105587
+ * This also makes it possible to revert the changes in one step.
105588
+ *
105589
+ * Example use case: remove the camunda:formKey attribute and in addition
105590
+ * add all form fields needed for the camunda:formData property.
105572
105591
  */
105573
105592
  let MultiCommandHandler$1 = class MultiCommandHandler {
105574
105593
  constructor(commandStack) {
@@ -105698,12 +105717,12 @@
105698
105717
  return compensateEventDefinition && compensateEventDefinition.get('activityRef');
105699
105718
  }
105700
105719
 
105701
- /**
105702
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105720
+ /**
105721
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105703
105722
  */
105704
105723
 
105705
- /**
105706
- * @returns {Array<Entry>} entries
105724
+ /**
105725
+ * @returns {Array<Entry>} entries
105707
105726
  */
105708
105727
  function CompensationProps(props) {
105709
105728
  const {
@@ -105813,12 +105832,12 @@
105813
105832
  return getFlowElements(element, 'bpmn:BoundaryEvent');
105814
105833
  }
105815
105834
 
105816
- /**
105817
- * Checks whether an Activity is attaching a CompensateEvent of the parent container.
105818
- *
105819
- * @param {ModdleElement} activity
105820
- * @param {Array<ModdleElement>} boundaryEvents
105821
- * @returns {Boolean}
105835
+ /**
105836
+ * Checks whether an Activity is attaching a CompensateEvent of the parent container.
105837
+ *
105838
+ * @param {ModdleElement} activity
105839
+ * @param {Array<ModdleElement>} boundaryEvents
105840
+ * @returns {Boolean}
105822
105841
  */
105823
105842
  function hasCompensationEventAttached(activity, boundaryEvents) {
105824
105843
  const {
@@ -105833,15 +105852,15 @@
105833
105852
  });
105834
105853
  }
105835
105854
 
105836
- /**
105837
- * Checks whether an Activity can be compensated. That's the case when it is
105838
- * a) a CallActivity
105839
- * b) a SubProcess, when it is not event based and not a compensation
105840
- * c) any other Activity, when it is attaching a CompensateEvent of the parent container
105841
- *
105842
- * @param {ModdleElement} activity
105843
- * @param {Array<ModdleElement>} boundaryEvents
105844
- * @returns {Boolean}
105855
+ /**
105856
+ * Checks whether an Activity can be compensated. That's the case when it is
105857
+ * a) a CallActivity
105858
+ * b) a SubProcess, when it is not event based and not a compensation
105859
+ * c) any other Activity, when it is attaching a CompensateEvent of the parent container
105860
+ *
105861
+ * @param {ModdleElement} activity
105862
+ * @param {Array<ModdleElement>} boundaryEvents
105863
+ * @returns {Boolean}
105845
105864
  */
105846
105865
  function canBeCompensated(activity, boundaryEvents) {
105847
105866
  return is$6(activity, 'bpmn:CallActivity') || is$6(activity, 'bpmn:SubProcess') && !activity.triggeredByEvent && !activity.isForCompensation || hasCompensationEventAttached(activity, boundaryEvents);
@@ -105854,11 +105873,11 @@
105854
105873
  });
105855
105874
  }
105856
105875
 
105857
- /**
105858
- * Retrieves all possible activities to reference for a Compensation.
105859
- *
105860
- * @param {djs.model.Base} element
105861
- * @returns {Array<ModdleElement>}
105876
+ /**
105877
+ * Retrieves all possible activities to reference for a Compensation.
105878
+ *
105879
+ * @param {djs.model.Base} element
105880
+ * @returns {Array<ModdleElement>}
105862
105881
  */
105863
105882
  function findActivityRefs(element) {
105864
105883
  const businessObject = getBusinessObject$2(element);
@@ -105878,13 +105897,13 @@
105878
105897
  return activities;
105879
105898
  }
105880
105899
 
105881
- /**
105882
- * Retrieves an option label in the form
105883
- * a) with name: "my Task (id=Task_1)"
105884
- * b) without name: "(id=Task_1)"
105885
- *
105886
- * @param {ModdleElement} activity
105887
- * @returns {String}
105900
+ /**
105901
+ * Retrieves an option label in the form
105902
+ * a) with name: "my Task (id=Task_1)"
105903
+ * b) without name: "(id=Task_1)"
105904
+ *
105905
+ * @param {ModdleElement} activity
105906
+ * @returns {String}
105888
105907
  */
105889
105908
  function createOptionLabel(activity) {
105890
105909
  const {
@@ -105899,12 +105918,12 @@
105899
105918
 
105900
105919
  const DOCUMENTATION_TEXT_FORMAT = 'text/plain';
105901
105920
 
105902
- /**
105903
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105921
+ /**
105922
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105904
105923
  */
105905
105924
 
105906
- /**
105907
- * @returns {Array<Entry>} entries
105925
+ /**
105926
+ * @returns {Array<Entry>} entries
105908
105927
  */
105909
105928
  function DocumentationProps(props) {
105910
105929
  const {
@@ -105975,12 +105994,12 @@
105975
105994
  });
105976
105995
  }
105977
105996
 
105978
- /**
105979
- * Retrieves a documentation element from a given moddle element.
105980
- *
105981
- * @param {ModdleElement} businessObject
105982
- *
105983
- * @returns {ModdleElement} documentation element inside the given moddle element.
105997
+ /**
105998
+ * Retrieves a documentation element from a given moddle element.
105999
+ *
106000
+ * @param {ModdleElement} businessObject
106001
+ *
106002
+ * @returns {ModdleElement} documentation element inside the given moddle element.
105984
106003
  */
105985
106004
  function getDocumentation(businessObject) {
105986
106005
  return function () {
@@ -105989,10 +106008,10 @@
105989
106008
  };
105990
106009
  }
105991
106010
 
105992
- /**
105993
- * Sets a documentation element for a given moddle element.
105994
- *
105995
- * @param {ModdleElement} businessObject
106011
+ /**
106012
+ * Sets a documentation element for a given moddle element.
106013
+ *
106014
+ * @param {ModdleElement} businessObject
105996
106015
  */
105997
106016
  function setDocumentation(element, businessObject, bpmnFactory, commandStack) {
105998
106017
  return function (value) {
@@ -106035,15 +106054,15 @@
106035
106054
  };
106036
106055
  }
106037
106056
 
106038
- /**
106039
- * Create a new element and (optionally) set its parent.
106040
- *
106041
- * @param {string} type
106042
- * @param {Object} properties
106043
- * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
106044
- * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
106045
- *
106046
- * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
106057
+ /**
106058
+ * Create a new element and (optionally) set its parent.
106059
+ *
106060
+ * @param {string} type
106061
+ * @param {Object} properties
106062
+ * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
106063
+ * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
106064
+ *
106065
+ * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
106047
106066
  */
106048
106067
  function createElement$1(type, properties, parent, bpmnFactory) {
106049
106068
  const element = bpmnFactory.create(type, properties);
@@ -106053,8 +106072,8 @@
106053
106072
  return element;
106054
106073
  }
106055
106074
 
106056
- /**
106057
- * generate a semantic id with given prefix
106075
+ /**
106076
+ * generate a semantic id with given prefix
106058
106077
  */
106059
106078
  function nextId$1(prefix) {
106060
106079
  const ids = new Ids$1([32, 32, 1]);
@@ -106083,12 +106102,12 @@
106083
106102
  const EMPTY_OPTION$4 = '';
106084
106103
  const CREATE_NEW_OPTION$4 = 'create-new';
106085
106104
 
106086
- /**
106087
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106105
+ /**
106106
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106088
106107
  */
106089
106108
 
106090
- /**
106091
- * @returns {Array<Entry>} entries
106109
+ /**
106110
+ * @returns {Array<Entry>} entries
106092
106111
  */
106093
106112
  function ErrorProps$2(props) {
106094
106113
  const {
@@ -106264,12 +106283,12 @@
106264
106283
 
106265
106284
  const CREATE_NEW_OPTION$3 = 'create-new';
106266
106285
 
106267
- /**
106268
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106286
+ /**
106287
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106269
106288
  */
106270
106289
 
106271
- /**
106272
- * @returns {Array<Entry>} entries
106290
+ /**
106291
+ * @returns {Array<Entry>} entries
106273
106292
  */
106274
106293
  function EscalationProps$2(props) {
106275
106294
  const {
@@ -106442,12 +106461,12 @@
106442
106461
  return sortBy$1(elements, e => (e.name || '').toLowerCase());
106443
106462
  }
106444
106463
 
106445
- /**
106446
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106464
+ /**
106465
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106447
106466
  */
106448
106467
 
106449
- /**
106450
- * @returns {Array<Entry>} entries
106468
+ /**
106469
+ * @returns {Array<Entry>} entries
106451
106470
  */
106452
106471
  function ExecutableProps(props) {
106453
106472
  const {
@@ -106518,14 +106537,14 @@
106518
106537
  // for ID validation as per BPMN Schema (QName - Namespace)
106519
106538
  const ID_REGEX = /^[a-z_][\w-.]*$/i;
106520
106539
 
106521
- /**
106522
- * checks whether the id value is valid
106523
- *
106524
- * @param {ModdleElement} element
106525
- * @param {String} idValue
106526
- * @param {Function} translate
106527
- *
106528
- * @return {String} error message
106540
+ /**
106541
+ * checks whether the id value is valid
106542
+ *
106543
+ * @param {ModdleElement} element
106544
+ * @param {String} idValue
106545
+ * @param {Function} translate
106546
+ *
106547
+ * @return {String} error message
106529
106548
  */
106530
106549
  function isIdValid(element, idValue, translate) {
106531
106550
  const assigned = element.$model.ids.assigned(idValue);
@@ -106553,12 +106572,12 @@
106553
106572
  return SPACE_REGEX$1.test(value);
106554
106573
  }
106555
106574
 
106556
- /**
106557
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106575
+ /**
106576
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106558
106577
  */
106559
106578
 
106560
- /**
106561
- * @returns {Array<Entry>} entries
106579
+ /**
106580
+ * @returns {Array<Entry>} entries
106562
106581
  */
106563
106582
  function IdProps$1() {
106564
106583
  return [{
@@ -106600,12 +106619,12 @@
106600
106619
  });
106601
106620
  }
106602
106621
 
106603
- /**
106604
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106622
+ /**
106623
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106605
106624
  */
106606
106625
 
106607
- /**
106608
- * @returns {Array<Entry>} entries
106626
+ /**
106627
+ * @returns {Array<Entry>} entries
106609
106628
  */
106610
106629
  function LinkProps(props) {
106611
106630
  const {
@@ -106653,12 +106672,12 @@
106653
106672
  const EMPTY_OPTION$3 = '';
106654
106673
  const CREATE_NEW_OPTION$2 = 'create-new';
106655
106674
 
106656
- /**
106657
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106675
+ /**
106676
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106658
106677
  */
106659
106678
 
106660
- /**
106661
- * @returns {Array<Entry>} entries
106679
+ /**
106680
+ * @returns {Array<Entry>} entries
106662
106681
  */
106663
106682
  function MessageProps$1(props) {
106664
106683
  const {
@@ -106801,12 +106820,12 @@
106801
106820
  return sortBy$1(elements, e => (e.name || '').toLowerCase());
106802
106821
  }
106803
106822
 
106804
- /**
106805
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106823
+ /**
106824
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106806
106825
  */
106807
106826
 
106808
- /**
106809
- * @returns {Array<Entry>} entries
106827
+ /**
106828
+ * @returns {Array<Entry>} entries
106810
106829
  */
106811
106830
  function MultiInstanceProps$2(props) {
106812
106831
  const {
@@ -106877,59 +106896,59 @@
106877
106896
 
106878
106897
  // generic ///////////////////////////
106879
106898
 
106880
- /**
106881
- * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
106882
- *
106883
- * @param {djs.model.Base} element
106884
- * @return {boolean}
106899
+ /**
106900
+ * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
106901
+ *
106902
+ * @param {djs.model.Base} element
106903
+ * @return {boolean}
106885
106904
  */
106886
106905
  function isMultiInstanceSupported$1(element) {
106887
106906
  const loopCharacteristics = getLoopCharacteristics$2(element);
106888
106907
  return !!loopCharacteristics && is$6(loopCharacteristics, 'bpmn:MultiInstanceLoopCharacteristics');
106889
106908
  }
106890
106909
 
106891
- /**
106892
- * getBody - get the body of a given expression.
106893
- *
106894
- * @param {ModdleElement<bpmn:FormalExpression>} expression
106895
- * @return {string} the body (value) of the expression
106910
+ /**
106911
+ * getBody - get the body of a given expression.
106912
+ *
106913
+ * @param {ModdleElement<bpmn:FormalExpression>} expression
106914
+ * @return {string} the body (value) of the expression
106896
106915
  */
106897
106916
  function getBody(expression) {
106898
106917
  return expression && expression.get('body');
106899
106918
  }
106900
106919
 
106901
- /**
106902
- * getProperty - get a property value of the loop characteristics.
106903
- *
106904
- * @param {djs.model.Base} element
106905
- * @param {string} propertyName
106906
- *
106907
- * @return {any} the property value
106920
+ /**
106921
+ * getProperty - get a property value of the loop characteristics.
106922
+ *
106923
+ * @param {djs.model.Base} element
106924
+ * @param {string} propertyName
106925
+ *
106926
+ * @return {any} the property value
106908
106927
  */
106909
106928
  function getProperty$2(element, propertyName) {
106910
106929
  const loopCharacteristics = getLoopCharacteristics$2(element);
106911
106930
  return loopCharacteristics && loopCharacteristics.get(propertyName);
106912
106931
  }
106913
106932
 
106914
- /**
106915
- * getLoopCharacteristics - get loopCharacteristics of a given element.
106916
- *
106917
- * @param {djs.model.Base} element
106918
- * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
106933
+ /**
106934
+ * getLoopCharacteristics - get loopCharacteristics of a given element.
106935
+ *
106936
+ * @param {djs.model.Base} element
106937
+ * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
106919
106938
  */
106920
106939
  function getLoopCharacteristics$2(element) {
106921
106940
  const bo = getBusinessObject$2(element);
106922
106941
  return bo.loopCharacteristics;
106923
106942
  }
106924
106943
 
106925
- /**
106926
- * createFormalExpression - creates a 'bpmn:FormalExpression' element.
106927
- *
106928
- * @param {ModdleElement} parent
106929
- * @param {string} body
106930
- * @param {BpmnFactory} bpmnFactory
106931
- *
106932
- * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
106944
+ /**
106945
+ * createFormalExpression - creates a 'bpmn:FormalExpression' element.
106946
+ *
106947
+ * @param {ModdleElement} parent
106948
+ * @param {string} body
106949
+ * @param {BpmnFactory} bpmnFactory
106950
+ *
106951
+ * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
106933
106952
  */
106934
106953
  function createFormalExpression$1(parent, body, bpmnFactory) {
106935
106954
  return createElement$1('bpmn:FormalExpression', {
@@ -106937,13 +106956,13 @@
106937
106956
  }, parent, bpmnFactory);
106938
106957
  }
106939
106958
 
106940
- /**
106941
- * updateFormalExpression - updates a specific formal expression of the loop characteristics.
106942
- *
106943
- * @param {djs.model.Base} element
106944
- * @param {string} propertyName
106945
- * @param {string} newValue
106946
- * @param {BpmnFactory} bpmnFactory
106959
+ /**
106960
+ * updateFormalExpression - updates a specific formal expression of the loop characteristics.
106961
+ *
106962
+ * @param {djs.model.Base} element
106963
+ * @param {string} propertyName
106964
+ * @param {string} newValue
106965
+ * @param {BpmnFactory} bpmnFactory
106947
106966
  */
106948
106967
  function updateFormalExpression(element, propertyName, newValue, bpmnFactory) {
106949
106968
  const loopCharacteristics = getLoopCharacteristics$2(element);
@@ -106980,23 +106999,23 @@
106980
106999
 
106981
107000
  // loopCardinality
106982
107001
 
106983
- /**
106984
- * getLoopCardinality - get the loop cardinality of the loop characteristics.
106985
- *
106986
- * @param {djs.model.Base} element
106987
- *
106988
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
107002
+ /**
107003
+ * getLoopCardinality - get the loop cardinality of the loop characteristics.
107004
+ *
107005
+ * @param {djs.model.Base} element
107006
+ *
107007
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
106989
107008
  */
106990
107009
  function getLoopCardinality(element) {
106991
107010
  return getProperty$2(element, 'loopCardinality');
106992
107011
  }
106993
107012
 
106994
- /**
106995
- * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
106996
- *
106997
- * @param {djs.model.Base} element
106998
- *
106999
- * @return {string} the loop cardinality value
107013
+ /**
107014
+ * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
107015
+ *
107016
+ * @param {djs.model.Base} element
107017
+ *
107018
+ * @return {string} the loop cardinality value
107000
107019
  */
107001
107020
  function getLoopCardinalityValue(element) {
107002
107021
  const loopCardinality = getLoopCardinality(element);
@@ -107005,35 +107024,35 @@
107005
107024
 
107006
107025
  // completionCondition /////////////////////
107007
107026
 
107008
- /**
107009
- * getCompletionCondition - get the completion condition of the loop characteristics.
107010
- *
107011
- * @param {djs.model.Base} element
107012
- *
107013
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
107027
+ /**
107028
+ * getCompletionCondition - get the completion condition of the loop characteristics.
107029
+ *
107030
+ * @param {djs.model.Base} element
107031
+ *
107032
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
107014
107033
  */
107015
107034
  function getCompletionCondition$1(element) {
107016
107035
  return getProperty$2(element, 'completionCondition');
107017
107036
  }
107018
107037
 
107019
- /**
107020
- * getCompletionConditionValue - get the completion condition value of the loop characteristics.
107021
- *
107022
- * @param {djs.model.Base} element
107023
- *
107024
- * @return {string} the completion condition value
107038
+ /**
107039
+ * getCompletionConditionValue - get the completion condition value of the loop characteristics.
107040
+ *
107041
+ * @param {djs.model.Base} element
107042
+ *
107043
+ * @return {string} the completion condition value
107025
107044
  */
107026
107045
  function getCompletionConditionValue(element) {
107027
107046
  const completionCondition = getCompletionCondition$1(element);
107028
107047
  return getBody(completionCondition);
107029
107048
  }
107030
107049
 
107031
- /**
107032
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107050
+ /**
107051
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107033
107052
  */
107034
107053
 
107035
- /**
107036
- * @returns {Array<Entry>} entries
107054
+ /**
107055
+ * @returns {Array<Entry>} entries
107037
107056
  */
107038
107057
  function NameProps(props) {
107039
107058
  const {
@@ -107137,12 +107156,12 @@
107137
107156
  return categoryValue;
107138
107157
  }
107139
107158
 
107140
- /**
107141
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107159
+ /**
107160
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107142
107161
  */
107143
107162
 
107144
- /**
107145
- * @returns {Array<Entry>} entries
107163
+ /**
107164
+ * @returns {Array<Entry>} entries
107146
107165
  */
107147
107166
  function ProcessProps$1(props) {
107148
107167
  const {
@@ -107233,15 +107252,15 @@
107233
107252
  return is$6(element, 'bpmn:Participant') && element.businessObject.get('processRef');
107234
107253
  }
107235
107254
 
107236
- /**
107237
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107255
+ /**
107256
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
107238
107257
  */
107239
107258
 
107240
107259
  const EMPTY_OPTION$2 = '';
107241
107260
  const CREATE_NEW_OPTION$1 = 'create-new';
107242
107261
 
107243
- /**
107244
- * @returns {Entry[]}
107262
+ /**
107263
+ * @returns {Entry[]}
107245
107264
  */
107246
107265
  function SignalProps$1(props) {
107247
107266
  const {
@@ -107387,12 +107406,12 @@
107387
107406
  return isAny$1(element, ['bpmn:StartEvent', 'bpmn:IntermediateCatchEvent', 'bpmn:BoundaryEvent']) && !!getTimerEventDefinition$2(element);
107388
107407
  }
107389
107408
 
107390
- /**
107391
- * Get the timer definition type for a given timer event definition.
107392
- *
107393
- * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
107394
- *
107395
- * @return {string|undefined} the timer definition type
107409
+ /**
107410
+ * Get the timer definition type for a given timer event definition.
107411
+ *
107412
+ * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
107413
+ *
107414
+ * @return {string|undefined} the timer definition type
107396
107415
  */
107397
107416
  function getTimerDefinitionType(timer) {
107398
107417
  if (!timer) {
@@ -107462,12 +107481,12 @@
107462
107481
  return entries;
107463
107482
  }
107464
107483
 
107465
- /**
107466
- * TimerEventDefinitionType - Generic select entry allowing to select a specific
107467
- * timerEventDefintionType. To be used together with timerEventDefinitionValue.
107468
- *
107469
- * @param {type} props
107470
- * @return {SelectEntry}
107484
+ /**
107485
+ * TimerEventDefinitionType - Generic select entry allowing to select a specific
107486
+ * timerEventDefintionType. To be used together with timerEventDefinitionValue.
107487
+ *
107488
+ * @param {type} props
107489
+ * @return {SelectEntry}
107471
107490
  */
107472
107491
  function TimerEventDefinitionType$2(props) {
107473
107492
  const {
@@ -107535,13 +107554,13 @@
107535
107554
  });
107536
107555
  }
107537
107556
 
107538
- /**
107539
- * TimerEventDefinitionValue - Generic textField entry allowing to specify the
107540
- * timerEventDefintionValue based on the set timerEventDefintionType. To be used
107541
- * together with timerEventDefinitionType.
107542
- *
107543
- * @param {type} props
107544
- * @return {TextFieldEntry}
107557
+ /**
107558
+ * TimerEventDefinitionValue - Generic textField entry allowing to specify the
107559
+ * timerEventDefintionValue based on the set timerEventDefintionType. To be used
107560
+ * together with timerEventDefinitionType.
107561
+ *
107562
+ * @param {type} props
107563
+ * @return {TextFieldEntry}
107545
107564
  */
107546
107565
  function TimerEventDefinitionValue$2(props) {
107547
107566
  const {
@@ -107826,12 +107845,12 @@
107826
107845
  bpmnPropertiesProvider: ['type', BpmnPropertiesProvider]
107827
107846
  };
107828
107847
 
107829
- /**
107830
- * Get extension elements of business object. Optionally filter by type.
107831
- *
107832
- * @param {ModdleElement} businessObject
107833
- * @param {string} [type=undefined]
107834
- * @returns {Array<ModdleElement>}
107848
+ /**
107849
+ * Get extension elements of business object. Optionally filter by type.
107850
+ *
107851
+ * @param {ModdleElement} businessObject
107852
+ * @param {string} [type=undefined]
107853
+ * @returns {Array<ModdleElement>}
107835
107854
  */
107836
107855
  function getExtensionElementsList$1(businessObject, type = undefined) {
107837
107856
  const extensionElements = businessObject.get('extensionElements');
@@ -107848,13 +107867,13 @@
107848
107867
  return values;
107849
107868
  }
107850
107869
 
107851
- /**
107852
- * Add one or more extension elements. Create bpmn:ExtensionElements if it doesn't exist.
107853
- *
107854
- * @param {ModdleElement} element
107855
- * @param {ModdleElement} businessObject
107856
- * @param {ModdleElement|Array<ModdleElement>} extensionElementsToAdd
107857
- * @param {CommandStack} commandStack
107870
+ /**
107871
+ * Add one or more extension elements. Create bpmn:ExtensionElements if it doesn't exist.
107872
+ *
107873
+ * @param {ModdleElement} element
107874
+ * @param {ModdleElement} businessObject
107875
+ * @param {ModdleElement|Array<ModdleElement>} extensionElementsToAdd
107876
+ * @param {CommandStack} commandStack
107858
107877
  */
107859
107878
  function addExtensionElements(element, businessObject, extensionElementToAdd, bpmnFactory, commandStack) {
107860
107879
  const commands = [];
@@ -107892,13 +107911,13 @@
107892
107911
  commandStack.execute('properties-panel.multi-command-executor', commands);
107893
107912
  }
107894
107913
 
107895
- /**
107896
- * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
107897
- *
107898
- * @param {ModdleElement} element
107899
- * @param {ModdleElement} businessObject
107900
- * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
107901
- * @param {CommandStack} commandStack
107914
+ /**
107915
+ * Remove one or more extension elements. Remove bpmn:ExtensionElements afterwards if it's empty.
107916
+ *
107917
+ * @param {ModdleElement} element
107918
+ * @param {ModdleElement} businessObject
107919
+ * @param {ModdleElement|Array<ModdleElement>} extensionElementsToRemove
107920
+ * @param {CommandStack} commandStack
107902
107921
  */
107903
107922
  function removeExtensionElements$1(element, businessObject, extensionElementsToRemove, commandStack) {
107904
107923
  if (!isArray$5(extensionElementsToRemove)) {
@@ -108291,37 +108310,37 @@
108291
108310
 
108292
108311
  // helper //////////////////
108293
108312
 
108294
- /**
108295
- * Returns true if the attribute 'camunda:asyncBefore' is set
108296
- * to true.
108297
- *
108298
- * @param {ModdleElement} bo
108299
- *
108300
- * @return {boolean} a boolean value
108313
+ /**
108314
+ * Returns true if the attribute 'camunda:asyncBefore' is set
108315
+ * to true.
108316
+ *
108317
+ * @param {ModdleElement} bo
108318
+ *
108319
+ * @return {boolean} a boolean value
108301
108320
  */
108302
108321
  function isAsyncBefore$2(bo) {
108303
108322
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
108304
108323
  }
108305
108324
 
108306
- /**
108307
- * Returns true if the attribute 'camunda:asyncAfter' is set
108308
- * to true.
108309
- *
108310
- * @param {ModdleElement} bo
108311
- *
108312
- * @return {boolean} a boolean value
108325
+ /**
108326
+ * Returns true if the attribute 'camunda:asyncAfter' is set
108327
+ * to true.
108328
+ *
108329
+ * @param {ModdleElement} bo
108330
+ *
108331
+ * @return {boolean} a boolean value
108313
108332
  */
108314
108333
  function isAsyncAfter$2(bo) {
108315
108334
  return !!bo.get('camunda:asyncAfter');
108316
108335
  }
108317
108336
 
108318
- /**
108319
- * Returns true if the attribute 'camunda:exclusive' is set
108320
- * to true.
108321
- *
108322
- * @param {ModdleElement} bo
108323
- *
108324
- * @return {boolean} a boolean value
108337
+ /**
108338
+ * Returns true if the attribute 'camunda:exclusive' is set
108339
+ * to true.
108340
+ *
108341
+ * @param {ModdleElement} bo
108342
+ *
108343
+ * @return {boolean} a boolean value
108325
108344
  */
108326
108345
  function isExclusive$1(bo) {
108327
108346
  return !!bo.get('camunda:exclusive');
@@ -109137,12 +109156,12 @@
109137
109156
 
109138
109157
  // helper //////////////////
109139
109158
 
109140
- /**
109141
- * getProcess - get the businessObject of the process referred to by a bpmn:Process
109142
- * or by a bpmn:Participant
109143
- *
109144
- * @param {ModdleElement} element either a bpmn:Process or a bpmn:Participant
109145
- * @return {BusinessObject}
109159
+ /**
109160
+ * getProcess - get the businessObject of the process referred to by a bpmn:Process
109161
+ * or by a bpmn:Participant
109162
+ *
109163
+ * @param {ModdleElement} element either a bpmn:Process or a bpmn:Participant
109164
+ * @return {BusinessObject}
109146
109165
  */
109147
109166
  function getProcess$3(element) {
109148
109167
  return is$6(element, 'bpmn:Process') ? getBusinessObject$2(element) : getBusinessObject$2(element).get('processRef');
@@ -109534,12 +109553,12 @@
109534
109553
  }
109535
109554
  }
109536
109555
 
109537
- /**
109538
- * getConditionExpression - get the body value of a condition expression for a given element
109539
- *
109540
- * @param {ModdleElement} element
109541
- *
109542
- * @return {string|undefined}
109556
+ /**
109557
+ * getConditionExpression - get the body value of a condition expression for a given element
109558
+ *
109559
+ * @param {ModdleElement} element
109560
+ *
109561
+ * @return {string|undefined}
109543
109562
  */
109544
109563
  function getConditionExpression(element) {
109545
109564
  const businessObject = getBusinessObject$2(element);
@@ -109585,8 +109604,8 @@
109585
109604
  return is$6(parent, 'bpmn:SubProcess') && parent.triggeredByEvent;
109586
109605
  }
109587
109606
 
109588
- /**
109589
- * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/scripting/
109607
+ /**
109608
+ * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/scripting/
109590
109609
  */
109591
109610
  function ScriptProps(props) {
109592
109611
  const {
@@ -109814,12 +109833,12 @@
109814
109833
  return inputOutput && inputOutput.get(prop) || [];
109815
109834
  }
109816
109835
 
109817
- /**
109818
- * Get a camunda:inputOutput from the business object
109819
- *
109820
- * @param {djs.model.Base | ModdleElement} element
109821
- *
109822
- * @return {ModdleElement} the inputOutput object
109836
+ /**
109837
+ * Get a camunda:inputOutput from the business object
109838
+ *
109839
+ * @param {djs.model.Base | ModdleElement} element
109840
+ *
109841
+ * @return {ModdleElement} the inputOutput object
109823
109842
  */
109824
109843
  function getInputOutput$1(element) {
109825
109844
  if (is$6(element, 'camunda:Connector')) {
@@ -109829,25 +109848,25 @@
109829
109848
  return (getElements(businessObject, 'camunda:InputOutput') || [])[0];
109830
109849
  }
109831
109850
 
109832
- /**
109833
- * Return all input parameters existing in the business object, and
109834
- * an empty array if none exist.
109835
- *
109836
- * @param {djs.model.Base} element
109837
- *
109838
- * @return {Array} a list of input parameter objects
109851
+ /**
109852
+ * Return all input parameters existing in the business object, and
109853
+ * an empty array if none exist.
109854
+ *
109855
+ * @param {djs.model.Base} element
109856
+ *
109857
+ * @return {Array} a list of input parameter objects
109839
109858
  */
109840
109859
  function getInputParameters$2(element) {
109841
109860
  return getParameters$1(element, 'inputParameters');
109842
109861
  }
109843
109862
 
109844
- /**
109845
- * Return all output parameters existing in the business object, and
109846
- * an empty array if none exist.
109847
- *
109848
- * @param {djs.model.Base} element
109849
- *
109850
- * @return {Array} a list of output parameter objects
109863
+ /**
109864
+ * Return all output parameters existing in the business object, and
109865
+ * an empty array if none exist.
109866
+ *
109867
+ * @param {djs.model.Base} element
109868
+ *
109869
+ * @return {Array} a list of output parameter objects
109851
109870
  */
109852
109871
  function getOutputParameters$2(element) {
109853
109872
  return getParameters$1(element, 'outputParameters');
@@ -110423,47 +110442,47 @@
110423
110442
  return is$6(parameter, 'camunda:InputParameter');
110424
110443
  }
110425
110444
 
110426
- /**
110427
- * Check whether an element is camunda:ServiceTaskLike
110428
- *
110429
- * @param {djs.model.Base} element
110430
- *
110431
- * @return {boolean} a boolean value
110445
+ /**
110446
+ * Check whether an element is camunda:ServiceTaskLike
110447
+ *
110448
+ * @param {djs.model.Base} element
110449
+ *
110450
+ * @return {boolean} a boolean value
110432
110451
  */
110433
110452
  function isServiceTaskLike(element) {
110434
110453
  return is$6(element, 'camunda:ServiceTaskLike');
110435
110454
  }
110436
110455
 
110437
- /**
110438
- * Returns 'true' if the given element is 'camunda:DmnCapable'
110439
- *
110440
- * @param {djs.model.Base} element
110441
- *
110442
- * @return {boolean} a boolean value
110456
+ /**
110457
+ * Returns 'true' if the given element is 'camunda:DmnCapable'
110458
+ *
110459
+ * @param {djs.model.Base} element
110460
+ *
110461
+ * @return {boolean} a boolean value
110443
110462
  */
110444
110463
  function isDmnCapable(element) {
110445
110464
  return is$6(element, 'camunda:DmnCapable');
110446
110465
  }
110447
110466
 
110448
- /**
110449
- * Returns 'true' if the given element is 'camunda:ExternalCapable'
110450
- *
110451
- * @param {djs.model.Base} element
110452
- *
110453
- * @return {boolean} a boolean value
110467
+ /**
110468
+ * Returns 'true' if the given element is 'camunda:ExternalCapable'
110469
+ *
110470
+ * @param {djs.model.Base} element
110471
+ *
110472
+ * @return {boolean} a boolean value
110454
110473
  */
110455
110474
  function isExternalCapable(element) {
110456
110475
  return is$6(element, 'camunda:ExternalCapable');
110457
110476
  }
110458
110477
 
110459
- /**
110460
- * getServiceTaskLikeBusinessObject - Get a 'camunda:ServiceTaskLike' business object.
110461
- *
110462
- * If the given element is not a 'camunda:ServiceTaskLike', then 'false'
110463
- * is returned.
110464
- *
110465
- * @param {djs.model.Base} element
110466
- * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object
110478
+ /**
110479
+ * getServiceTaskLikeBusinessObject - Get a 'camunda:ServiceTaskLike' business object.
110480
+ *
110481
+ * If the given element is not a 'camunda:ServiceTaskLike', then 'false'
110482
+ * is returned.
110483
+ *
110484
+ * @param {djs.model.Base} element
110485
+ * @return {ModdleElement} the 'camunda:ServiceTaskLike' business object
110467
110486
  */
110468
110487
  function getServiceTaskLikeBusinessObject(element) {
110469
110488
  if (is$6(element, 'bpmn:IntermediateThrowEvent') || is$6(element, 'bpmn:EndEvent')) {
@@ -110479,22 +110498,22 @@
110479
110498
  return isServiceTaskLike(element) && getBusinessObject$2(element);
110480
110499
  }
110481
110500
 
110482
- /**
110483
- * Returns the implementation type of the given element.
110484
- *
110485
- * Possible implementation types are:
110486
- * - dmn
110487
- * - connector
110488
- * - external
110489
- * - class
110490
- * - expression
110491
- * - delegateExpression
110492
- * - script
110493
- * - or undefined, when no matching implementation type is found
110494
- *
110495
- * @param {djs.model.Base} element
110496
- *
110497
- * @return {String} the implementation type
110501
+ /**
110502
+ * Returns the implementation type of the given element.
110503
+ *
110504
+ * Possible implementation types are:
110505
+ * - dmn
110506
+ * - connector
110507
+ * - external
110508
+ * - class
110509
+ * - expression
110510
+ * - delegateExpression
110511
+ * - script
110512
+ * - or undefined, when no matching implementation type is found
110513
+ *
110514
+ * @param {djs.model.Base} element
110515
+ *
110516
+ * @return {String} the implementation type
110498
110517
  */
110499
110518
  function getImplementationType(element) {
110500
110519
  const businessObject = getListenerBusinessObject(element) || getServiceTaskLikeBusinessObject(element);
@@ -111202,12 +111221,12 @@
111202
111221
  return name;
111203
111222
  }
111204
111223
 
111205
- /**
111206
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
111224
+ /**
111225
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
111207
111226
  */
111208
111227
 
111209
- /**
111210
- * @returns {Array<Entry>} entries
111228
+ /**
111229
+ * @returns {Array<Entry>} entries
111211
111230
  */
111212
111231
  function EscalationProps(props) {
111213
111232
  const {
@@ -111461,12 +111480,12 @@
111461
111480
 
111462
111481
  // helper ///////////////////
111463
111482
 
111464
- /**
111465
- * determineType - get the type of a fieldInjection based on the attributes
111466
- * set on it
111467
- *
111468
- * @param {ModdleElement} field
111469
- * @return {('string'|'expression')}
111483
+ /**
111484
+ * determineType - get the type of a fieldInjection based on the attributes
111485
+ * set on it
111486
+ *
111487
+ * @param {ModdleElement} field
111488
+ * @return {('string'|'expression')}
111470
111489
  */
111471
111490
  function determineType(field) {
111472
111491
  // string is the default type
@@ -113598,8 +113617,8 @@
113598
113617
  return is$6(element, 'camunda:Initiator') && !is$6(element.parent, 'bpmn:SubProcess');
113599
113618
  }
113600
113619
 
113601
- /**
113602
- * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
113620
+ /**
113621
+ * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
113603
113622
  */
113604
113623
  function InMappingPropagationProps(props) {
113605
113624
  const {
@@ -113941,8 +113960,8 @@
113941
113960
  return inOutType;
113942
113961
  }
113943
113962
 
113944
- /**
113945
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#in
113963
+ /**
113964
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#in
113946
113965
  */
113947
113966
  function InMappingProps({
113948
113967
  element,
@@ -114225,49 +114244,49 @@
114225
114244
 
114226
114245
  // helper //////////////////
114227
114246
 
114228
- /**
114229
- * @param {ModdleElement} bo
114230
- * @return {boolean} a boolean value
114247
+ /**
114248
+ * @param {ModdleElement} bo
114249
+ * @return {boolean} a boolean value
114231
114250
  */
114232
114251
  function isAsyncBefore$1$1(bo) {
114233
114252
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
114234
114253
  }
114235
114254
 
114236
- /**
114237
- * @param {ModdleElement} bo
114238
- * @return {boolean}
114255
+ /**
114256
+ * @param {ModdleElement} bo
114257
+ * @return {boolean}
114239
114258
  */
114240
114259
  function isAsyncAfter$1$1(bo) {
114241
114260
  return !!bo.get('camunda:asyncAfter');
114242
114261
  }
114243
114262
 
114244
- /**
114245
- * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
114246
- * is set to true.
114247
- *
114248
- * @param {ModdleElement} bo
114249
- * @return {boolean}
114263
+ /**
114264
+ * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
114265
+ * is set to true.
114266
+ *
114267
+ * @param {ModdleElement} bo
114268
+ * @return {boolean}
114250
114269
  */
114251
114270
  function isAsync$1(bo) {
114252
114271
  return isAsyncAfter$1$1(bo) || isAsyncBefore$1$1(bo);
114253
114272
  }
114254
114273
 
114255
- /**
114256
- * isTimerEvent - returns true if the element is a bpmn:Event with a timerEventDefinition
114257
- *
114258
- * @param {ModdleElement} element
114259
- * @return {boolean}
114274
+ /**
114275
+ * isTimerEvent - returns true if the element is a bpmn:Event with a timerEventDefinition
114276
+ *
114277
+ * @param {ModdleElement} element
114278
+ * @return {boolean}
114260
114279
  */
114261
114280
  function isTimerEvent(element) {
114262
114281
  return is$6(element, 'bpmn:Event') && getTimerEventDefinition$1(element);
114263
114282
  }
114264
114283
 
114265
- /**
114266
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
114284
+ /**
114285
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
114267
114286
  */
114268
114287
 
114269
- /**
114270
- * @returns {Array<Entry>} entries
114288
+ /**
114289
+ * @returns {Array<Entry>} entries
114271
114290
  */
114272
114291
  function MultiInstanceProps(props) {
114273
114292
  const {
@@ -114529,36 +114548,36 @@
114529
114548
 
114530
114549
  // generic ///////////////////////////
114531
114550
 
114532
- /**
114533
- * isMultiInstanceSupported - check whether given element supports camunda specific props
114534
- * for multiInstance (ref. <camunda:Cllectable>).
114535
- *
114536
- * @param {djs.model.Base} element
114537
- * @return {boolean}
114551
+ /**
114552
+ * isMultiInstanceSupported - check whether given element supports camunda specific props
114553
+ * for multiInstance (ref. <camunda:Cllectable>).
114554
+ *
114555
+ * @param {djs.model.Base} element
114556
+ * @return {boolean}
114538
114557
  */
114539
114558
  function isMultiInstanceSupported(element) {
114540
114559
  const loopCharacteristics = getLoopCharacteristics(element);
114541
114560
  return !!loopCharacteristics && is$6(loopCharacteristics, 'camunda:Collectable');
114542
114561
  }
114543
114562
 
114544
- /**
114545
- * getProperty - get a property value of the loop characteristics.
114546
- *
114547
- * @param {djs.model.Base} element
114548
- * @param {string} propertyName
114549
- *
114550
- * @return {any} the property value
114563
+ /**
114564
+ * getProperty - get a property value of the loop characteristics.
114565
+ *
114566
+ * @param {djs.model.Base} element
114567
+ * @param {string} propertyName
114568
+ *
114569
+ * @return {any} the property value
114551
114570
  */
114552
114571
  function getProperty(element, propertyName) {
114553
114572
  var loopCharacteristics = getLoopCharacteristics(element);
114554
114573
  return loopCharacteristics && loopCharacteristics.get(propertyName);
114555
114574
  }
114556
114575
 
114557
- /**
114558
- * getLoopCharacteristics - get loopCharacteristics of a given element.
114559
- *
114560
- * @param {djs.model.Base} element
114561
- * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
114576
+ /**
114577
+ * getLoopCharacteristics - get loopCharacteristics of a given element.
114578
+ *
114579
+ * @param {djs.model.Base} element
114580
+ * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
114562
114581
  */
114563
114582
  function getLoopCharacteristics(element) {
114564
114583
  const bo = getBusinessObject$2(element);
@@ -114567,12 +114586,12 @@
114567
114586
 
114568
114587
  // collection
114569
114588
 
114570
- /**
114571
- * getCollection - get the 'camunda:collection' attribute value of the loop characteristics.
114572
- *
114573
- * @param {djs.model.Base} element
114574
- *
114575
- * @return {string} the 'camunda:collection' value
114589
+ /**
114590
+ * getCollection - get the 'camunda:collection' attribute value of the loop characteristics.
114591
+ *
114592
+ * @param {djs.model.Base} element
114593
+ *
114594
+ * @return {string} the 'camunda:collection' value
114576
114595
  */
114577
114596
  function getCollection(element) {
114578
114597
  return getProperty(element, 'camunda:collection');
@@ -114580,12 +114599,12 @@
114580
114599
 
114581
114600
  // elementVariable
114582
114601
 
114583
- /**
114584
- * getElementVariable - get the 'camunda:elementVariable' attribute value of the loop characteristics.
114585
- *
114586
- * @param {djs.model.Base} element
114587
- *
114588
- * @return {string} the 'camunda:elementVariable' value
114602
+ /**
114603
+ * getElementVariable - get the 'camunda:elementVariable' attribute value of the loop characteristics.
114604
+ *
114605
+ * @param {djs.model.Base} element
114606
+ *
114607
+ * @return {string} the 'camunda:elementVariable' value
114589
114608
  */
114590
114609
  function getElementVariable(element) {
114591
114610
  return getProperty(element, 'camunda:elementVariable');
@@ -114593,48 +114612,48 @@
114593
114612
 
114594
114613
  // asyncBefore asyncAfter
114595
114614
 
114596
- /**
114597
- * Returns true if the attribute 'camunda:asyncBefore' is set
114598
- * to true.
114599
- *
114600
- * @param {ModdleElement} bo
114601
- *
114602
- * @return {boolean} a boolean value
114615
+ /**
114616
+ * Returns true if the attribute 'camunda:asyncBefore' is set
114617
+ * to true.
114618
+ *
114619
+ * @param {ModdleElement} bo
114620
+ *
114621
+ * @return {boolean} a boolean value
114603
114622
  */
114604
114623
  function isAsyncBefore$3(bo) {
114605
114624
  return !!(bo.get('camunda:asyncBefore') || bo.get('camunda:async'));
114606
114625
  }
114607
114626
 
114608
- /**
114609
- * Returns true if the attribute 'camunda:asyncAfter' is set
114610
- * to true.
114611
- *
114612
- * @param {ModdleElement} bo
114613
- *
114614
- * @return {boolean} a boolean value
114627
+ /**
114628
+ * Returns true if the attribute 'camunda:asyncAfter' is set
114629
+ * to true.
114630
+ *
114631
+ * @param {ModdleElement} bo
114632
+ *
114633
+ * @return {boolean} a boolean value
114615
114634
  */
114616
114635
  function isAsyncAfter$3(bo) {
114617
114636
  return !!bo.get('camunda:asyncAfter');
114618
114637
  }
114619
114638
 
114620
- /**
114621
- * Returns true if the attribute 'camunda:exclusive' is set
114622
- * to true.
114623
- *
114624
- * @param {ModdleElement} bo
114625
- *
114626
- * @return {boolean} a boolean value
114639
+ /**
114640
+ * Returns true if the attribute 'camunda:exclusive' is set
114641
+ * to true.
114642
+ *
114643
+ * @param {ModdleElement} bo
114644
+ *
114645
+ * @return {boolean} a boolean value
114627
114646
  */
114628
114647
  function isExclusive$2(bo) {
114629
114648
  return !!bo.get('camunda:exclusive');
114630
114649
  }
114631
114650
 
114632
- /**
114633
- * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
114634
- * is set to true.
114635
- *
114636
- * @param {ModdleElement} bo
114637
- * @return {boolean}
114651
+ /**
114652
+ * isAsync - returns true if the attribute 'camunda:asyncAfter' or 'camunda:asyncBefore'
114653
+ * is set to true.
114654
+ *
114655
+ * @param {ModdleElement} bo
114656
+ * @return {boolean}
114638
114657
  */
114639
114658
  function isAsync(bo) {
114640
114659
  return isAsyncAfter$3(bo) || isAsyncBefore$3(bo);
@@ -114646,8 +114665,8 @@
114646
114665
  return node && !node.checked;
114647
114666
  }
114648
114667
 
114649
- /**
114650
- * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
114668
+ /**
114669
+ * Cf. https://docs.camunda.org/manual/7.15/reference/bpmn20/subprocesses/call-activity/#passing-variables
114651
114670
  */
114652
114671
  function OutMappingPropagationProps(props) {
114653
114672
  const {
@@ -114755,8 +114774,8 @@
114755
114774
  return !!mappings.length;
114756
114775
  }
114757
114776
 
114758
- /**
114759
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#out
114777
+ /**
114778
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/custom-extensions/extension-elements/#out
114760
114779
  */
114761
114780
  function OutMappingProps({
114762
114781
  element,
@@ -114947,12 +114966,12 @@
114947
114966
  return entries;
114948
114967
  }
114949
114968
 
114950
- /**
114951
- * TimerEventDefinitionType - Generic select entry allowing to select a specific
114952
- * timerEventDefintionType. To be used together with timerEventDefinitionValue.
114953
- *
114954
- * @param {type} props
114955
- * @return {SelectEntry}
114969
+ /**
114970
+ * TimerEventDefinitionType - Generic select entry allowing to select a specific
114971
+ * timerEventDefintionType. To be used together with timerEventDefinitionValue.
114972
+ *
114973
+ * @param {type} props
114974
+ * @return {SelectEntry}
114956
114975
  */
114957
114976
  function TimerEventDefinitionType(props) {
114958
114977
  const {
@@ -115020,13 +115039,13 @@
115020
115039
  });
115021
115040
  }
115022
115041
 
115023
- /**
115024
- * TimerEventDefinitionValue - Generic textField entry allowing to specify the
115025
- * timerEventDefintionValue based on the set timerEventDefintionType. To be used
115026
- * together with timerEventDefinitionType.
115027
- *
115028
- * @param {type} props
115029
- * @return {TextFieldEntry}
115042
+ /**
115043
+ * TimerEventDefinitionValue - Generic textField entry allowing to specify the
115044
+ * timerEventDefintionValue based on the set timerEventDefintionType. To be used
115045
+ * together with timerEventDefinitionType.
115046
+ *
115047
+ * @param {type} props
115048
+ * @return {TextFieldEntry}
115030
115049
  */
115031
115050
  function TimerEventDefinitionValue(props) {
115032
115051
  const {
@@ -115188,8 +115207,8 @@
115188
115207
  timeout: 'Timeout'
115189
115208
  };
115190
115209
 
115191
- /**
115192
- * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/delegation-code/#execution-listener
115210
+ /**
115211
+ * Cf. https://docs.camunda.org/manual/latest/user-guide/process-engine/delegation-code/#execution-listener
115193
115212
  */
115194
115213
  function ExecutionListenerProps({
115195
115214
  element,
@@ -115601,11 +115620,11 @@
115601
115620
 
115602
115621
  // helper
115603
115622
 
115604
- /**
115605
- * Get a readable label for a listener.
115606
- *
115607
- * @param {ModdleElement} listener
115608
- * @param {string => string} [translate]
115623
+ /**
115624
+ * Get a readable label for a listener.
115625
+ *
115626
+ * @param {ModdleElement} listener
115627
+ * @param {string => string} [translate]
115609
115628
  */
115610
115629
  function getListenerLabel(listener, translate = value => value) {
115611
115630
  const event = listener.get('event');
@@ -115952,8 +115971,8 @@
115952
115971
  return is$6(element, 'bpmn:Process') ? getBusinessObject$2(element) : getBusinessObject$2(element).get('processRef');
115953
115972
  }
115954
115973
 
115955
- /**
115956
- * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/
115974
+ /**
115975
+ * Cf. https://docs.camunda.org/manual/latest/reference/bpmn20/tasks/user-task/
115957
115976
  */
115958
115977
  function UserAssignmentProps(props) {
115959
115978
  const {
@@ -116215,12 +116234,12 @@
116215
116234
  return is$6(element, 'bpmn:Process') ? getBusinessObject$2(element) : getBusinessObject$2(element).get('processRef');
116216
116235
  }
116217
116236
 
116218
- /**
116219
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
116237
+ /**
116238
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
116220
116239
  */
116221
116240
 
116222
- /**
116223
- * @returns {Array<Entry>} entries
116241
+ /**
116242
+ * @returns {Array<Entry>} entries
116224
116243
  */
116225
116244
  function IdProps() {
116226
116245
  return [{
@@ -116264,12 +116283,12 @@
116264
116283
  });
116265
116284
  }
116266
116285
 
116267
- /**
116268
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
116286
+ /**
116287
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
116269
116288
  */
116270
116289
 
116271
- /**
116272
- * @returns {Array<Entry>} entries
116290
+ /**
116291
+ * @returns {Array<Entry>} entries
116273
116292
  */
116274
116293
  function ProcessProps(props) {
116275
116294
  const {
@@ -116332,30 +116351,30 @@
116332
116351
  const LOW_PRIORITY$4 = 500;
116333
116352
  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];
116334
116353
 
116335
- /**
116336
- * Provides `camunda` namespace properties.
116337
- *
116338
- * @example
116339
- * ```javascript
116340
- * import BpmnModeler from 'bpmn-js/lib/Modeler';
116341
- * import {
116342
- * BpmnPropertiesPanelModule,
116343
- * BpmnPropertiesProviderModule,
116344
- * CamundaPlatformPropertiesProviderModule
116345
- * } from 'bpmn-js-properties-panel';
116346
- *
116347
- * const modeler = new BpmnModeler({
116348
- * container: '#canvas',
116349
- * propertiesPanel: {
116350
- * parent: '#properties'
116351
- * },
116352
- * additionalModules: [
116353
- * BpmnPropertiesPanelModule,
116354
- * BpmnPropertiesProviderModule,
116355
- * CamundaPlatformPropertiesProviderModule
116356
- * ]
116357
- * });
116358
- * ```
116354
+ /**
116355
+ * Provides `camunda` namespace properties.
116356
+ *
116357
+ * @example
116358
+ * ```javascript
116359
+ * import BpmnModeler from 'bpmn-js/lib/Modeler';
116360
+ * import {
116361
+ * BpmnPropertiesPanelModule,
116362
+ * BpmnPropertiesProviderModule,
116363
+ * CamundaPlatformPropertiesProviderModule
116364
+ * } from 'bpmn-js-properties-panel';
116365
+ *
116366
+ * const modeler = new BpmnModeler({
116367
+ * container: '#canvas',
116368
+ * propertiesPanel: {
116369
+ * parent: '#properties'
116370
+ * },
116371
+ * additionalModules: [
116372
+ * BpmnPropertiesPanelModule,
116373
+ * BpmnPropertiesProviderModule,
116374
+ * CamundaPlatformPropertiesProviderModule
116375
+ * ]
116376
+ * });
116377
+ * ```
116359
116378
  */
116360
116379
  class CamundaPlatformPropertiesProvider {
116361
116380
  constructor(propertiesPanel, injector) {
@@ -116388,8 +116407,8 @@
116388
116407
  }
116389
116408
  CamundaPlatformPropertiesProvider.$inject = ['propertiesPanel', 'injector'];
116390
116409
 
116391
- /**
116392
- * This ensures the <Implementation> group always locates after <Documentation>
116410
+ /**
116411
+ * This ensures the <Implementation> group always locates after <Documentation>
116393
116412
  */
116394
116413
  function moveImplementationGroup(groups) {
116395
116414
  const documentationGroupIdx = findGroupIndex(groups, 'documentation');
@@ -124273,6 +124292,9 @@
124273
124292
  if (notEmpty && isEmptyString(value)) {
124274
124293
  return translate('Must not be empty.');
124275
124294
  }
124295
+ if (property.feel && isFeel(value)) {
124296
+ return;
124297
+ }
124276
124298
  if (maxLength && value.length > maxLength) {
124277
124299
  return translate('Must have max length {maxLength}.', {
124278
124300
  maxLength
@@ -124337,6 +124359,9 @@
124337
124359
  function findCustomGroup(groups, id) {
124338
124360
  return find$3(groups, g => g.id === id);
124339
124361
  }
124362
+ function isFeel(value) {
124363
+ return isString$1(value) && value.trim().startsWith('=');
124364
+ }
124340
124365
 
124341
124366
  function ErrorProperties(props) {
124342
124367
  const {