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
+
27696
+ var html = this._current.html;
27695
27697
 
27696
- var position = this._getPosition(this._current.target);
27698
+ var position = this._getPosition(this._current.target);
27697
27699
 
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
- }
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(element).isHorizontal) {
44926
+ getDi(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$5(bo, 'bpmn:Participant')) {
48618
+ var isHorizontalPool = di.isHorizontal === undefined || di.isHorizontal === true;
48606
48619
  if (isExpanded(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
 
@@ -104505,8 +104524,8 @@
104505
104524
  });
104506
104525
  const selectedElement = state.selectedElement;
104507
104526
 
104508
- /**
104509
- * @param {djs.model.Base | Array<djs.model.Base>} element
104527
+ /**
104528
+ * @param {djs.model.Base | Array<djs.model.Base>} element
104510
104529
  */
104511
104530
  const _update = element => {
104512
104531
  if (!element) {
@@ -104691,10 +104710,10 @@
104691
104710
 
104692
104711
  const DEFAULT_PRIORITY = 1000;
104693
104712
 
104694
- /**
104695
- * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
104696
- * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
104697
- * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
104713
+ /**
104714
+ * @typedef { import('@bpmn-io/properties-panel').GroupDefinition } GroupDefinition
104715
+ * @typedef { import('@bpmn-io/properties-panel').ListGroupDefinition } ListGroupDefinition
104716
+ * @typedef { { getGroups: (ModdleElement) => (Array{GroupDefinition|ListGroupDefinition}) => Array{GroupDefinition|ListGroupDefinition}) } PropertiesProvider
104698
104717
  */
104699
104718
 
104700
104719
  class BpmnPropertiesPanelRenderer {
@@ -104731,10 +104750,10 @@
104731
104750
  });
104732
104751
  }
104733
104752
 
104734
- /**
104735
- * Attach the properties panel to a parent node.
104736
- *
104737
- * @param {HTMLElement} container
104753
+ /**
104754
+ * Attach the properties panel to a parent node.
104755
+ *
104756
+ * @param {HTMLElement} container
104738
104757
  */
104739
104758
  attachTo(container) {
104740
104759
  if (!container) {
@@ -104759,8 +104778,8 @@
104759
104778
  this._eventBus.fire('propertiesPanel.attach');
104760
104779
  }
104761
104780
 
104762
- /**
104763
- * Detach the properties panel from its parent node.
104781
+ /**
104782
+ * Detach the properties panel from its parent node.
104764
104783
  */
104765
104784
  detach() {
104766
104785
  const parentNode = this._container.parentNode;
@@ -104770,11 +104789,11 @@
104770
104789
  }
104771
104790
  }
104772
104791
 
104773
- /**
104774
- * Register a new properties provider to the properties panel.
104775
- *
104776
- * @param {Number} [priority]
104777
- * @param {PropertiesProvider} provider
104792
+ /**
104793
+ * Register a new properties provider to the properties panel.
104794
+ *
104795
+ * @param {Number} [priority]
104796
+ * @param {PropertiesProvider} provider
104778
104797
  */
104779
104798
  registerProvider(priority, provider) {
104780
104799
  if (!provider) {
@@ -104791,9 +104810,9 @@
104791
104810
  this._eventBus.fire('propertiesPanel.providersChanged');
104792
104811
  }
104793
104812
 
104794
- /**
104795
- * Updates the layout of the properties panel.
104796
- * @param {Object} layout
104813
+ /**
104814
+ * Updates the layout of the properties panel.
104815
+ * @param {Object} layout
104797
104816
  */
104798
104817
  setLayout(layout) {
104799
104818
  this._eventBus.fire('propertiesPanel.setLayout', {
@@ -104843,12 +104862,12 @@
104843
104862
  return element && (element.isImplicit || element.id === '__implicitroot');
104844
104863
  }
104845
104864
 
104846
- /**
104847
- * Setup keyboard bindings (undo, redo) on the given container.
104848
- *
104849
- * @param {Element} container
104850
- * @param {EventBus} eventBus
104851
- * @param {CommandStack} commandStack
104865
+ /**
104866
+ * Setup keyboard bindings (undo, redo) on the given container.
104867
+ *
104868
+ * @param {Element} container
104869
+ * @param {EventBus} eventBus
104870
+ * @param {CommandStack} commandStack
104852
104871
  */
104853
104872
  function setupKeyboard(container, eventBus, commandStack) {
104854
104873
  function cancel(event) {
@@ -104873,14 +104892,14 @@
104873
104892
  });
104874
104893
  }
104875
104894
 
104876
- /**
104877
- * A handler that combines and executes multiple commands.
104878
- *
104879
- * All updates are bundled on the command stack and executed in one step.
104880
- * This also makes it possible to revert the changes in one step.
104881
- *
104882
- * Example use case: remove the camunda:formKey attribute and in addition
104883
- * add all form fields needed for the camunda:formData property.
104895
+ /**
104896
+ * A handler that combines and executes multiple commands.
104897
+ *
104898
+ * All updates are bundled on the command stack and executed in one step.
104899
+ * This also makes it possible to revert the changes in one step.
104900
+ *
104901
+ * Example use case: remove the camunda:formKey attribute and in addition
104902
+ * add all form fields needed for the camunda:formData property.
104884
104903
  */
104885
104904
  class MultiCommandHandler {
104886
104905
  constructor(commandStack) {
@@ -105007,12 +105026,12 @@
105007
105026
  return compensateEventDefinition && compensateEventDefinition.get('activityRef');
105008
105027
  }
105009
105028
 
105010
- /**
105011
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105029
+ /**
105030
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105012
105031
  */
105013
105032
 
105014
- /**
105015
- * @returns {Array<Entry>} entries
105033
+ /**
105034
+ * @returns {Array<Entry>} entries
105016
105035
  */
105017
105036
  function CompensationProps(props) {
105018
105037
  const {
@@ -105122,12 +105141,12 @@
105122
105141
  return getFlowElements(element, 'bpmn:BoundaryEvent');
105123
105142
  }
105124
105143
 
105125
- /**
105126
- * Checks whether an Activity is attaching a CompensateEvent of the parent container.
105127
- *
105128
- * @param {ModdleElement} activity
105129
- * @param {Array<ModdleElement>} boundaryEvents
105130
- * @returns {Boolean}
105144
+ /**
105145
+ * Checks whether an Activity is attaching a CompensateEvent of the parent container.
105146
+ *
105147
+ * @param {ModdleElement} activity
105148
+ * @param {Array<ModdleElement>} boundaryEvents
105149
+ * @returns {Boolean}
105131
105150
  */
105132
105151
  function hasCompensationEventAttached(activity, boundaryEvents) {
105133
105152
  const {
@@ -105142,15 +105161,15 @@
105142
105161
  });
105143
105162
  }
105144
105163
 
105145
- /**
105146
- * Checks whether an Activity can be compensated. That's the case when it is
105147
- * a) a CallActivity
105148
- * b) a SubProcess, when it is not event based and not a compensation
105149
- * c) any other Activity, when it is attaching a CompensateEvent of the parent container
105150
- *
105151
- * @param {ModdleElement} activity
105152
- * @param {Array<ModdleElement>} boundaryEvents
105153
- * @returns {Boolean}
105164
+ /**
105165
+ * Checks whether an Activity can be compensated. That's the case when it is
105166
+ * a) a CallActivity
105167
+ * b) a SubProcess, when it is not event based and not a compensation
105168
+ * c) any other Activity, when it is attaching a CompensateEvent of the parent container
105169
+ *
105170
+ * @param {ModdleElement} activity
105171
+ * @param {Array<ModdleElement>} boundaryEvents
105172
+ * @returns {Boolean}
105154
105173
  */
105155
105174
  function canBeCompensated(activity, boundaryEvents) {
105156
105175
  return is$5(activity, 'bpmn:CallActivity') || is$5(activity, 'bpmn:SubProcess') && !activity.triggeredByEvent && !activity.isForCompensation || hasCompensationEventAttached(activity, boundaryEvents);
@@ -105163,11 +105182,11 @@
105163
105182
  });
105164
105183
  }
105165
105184
 
105166
- /**
105167
- * Retrieves all possible activities to reference for a Compensation.
105168
- *
105169
- * @param {djs.model.Base} element
105170
- * @returns {Array<ModdleElement>}
105185
+ /**
105186
+ * Retrieves all possible activities to reference for a Compensation.
105187
+ *
105188
+ * @param {djs.model.Base} element
105189
+ * @returns {Array<ModdleElement>}
105171
105190
  */
105172
105191
  function findActivityRefs(element) {
105173
105192
  const businessObject = getBusinessObject$1(element);
@@ -105187,13 +105206,13 @@
105187
105206
  return activities;
105188
105207
  }
105189
105208
 
105190
- /**
105191
- * Retrieves an option label in the form
105192
- * a) with name: "my Task (id=Task_1)"
105193
- * b) without name: "(id=Task_1)"
105194
- *
105195
- * @param {ModdleElement} activity
105196
- * @returns {String}
105209
+ /**
105210
+ * Retrieves an option label in the form
105211
+ * a) with name: "my Task (id=Task_1)"
105212
+ * b) without name: "(id=Task_1)"
105213
+ *
105214
+ * @param {ModdleElement} activity
105215
+ * @returns {String}
105197
105216
  */
105198
105217
  function createOptionLabel(activity) {
105199
105218
  const {
@@ -105208,12 +105227,12 @@
105208
105227
 
105209
105228
  const DOCUMENTATION_TEXT_FORMAT = 'text/plain';
105210
105229
 
105211
- /**
105212
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105230
+ /**
105231
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105213
105232
  */
105214
105233
 
105215
- /**
105216
- * @returns {Array<Entry>} entries
105234
+ /**
105235
+ * @returns {Array<Entry>} entries
105217
105236
  */
105218
105237
  function DocumentationProps(props) {
105219
105238
  const {
@@ -105284,12 +105303,12 @@
105284
105303
  });
105285
105304
  }
105286
105305
 
105287
- /**
105288
- * Retrieves a documentation element from a given moddle element.
105289
- *
105290
- * @param {ModdleElement} businessObject
105291
- *
105292
- * @returns {ModdleElement} documentation element inside the given moddle element.
105306
+ /**
105307
+ * Retrieves a documentation element from a given moddle element.
105308
+ *
105309
+ * @param {ModdleElement} businessObject
105310
+ *
105311
+ * @returns {ModdleElement} documentation element inside the given moddle element.
105293
105312
  */
105294
105313
  function getDocumentation(businessObject) {
105295
105314
  return function () {
@@ -105298,10 +105317,10 @@
105298
105317
  };
105299
105318
  }
105300
105319
 
105301
- /**
105302
- * Sets a documentation element for a given moddle element.
105303
- *
105304
- * @param {ModdleElement} businessObject
105320
+ /**
105321
+ * Sets a documentation element for a given moddle element.
105322
+ *
105323
+ * @param {ModdleElement} businessObject
105305
105324
  */
105306
105325
  function setDocumentation(element, businessObject, bpmnFactory, commandStack) {
105307
105326
  return function (value) {
@@ -105344,15 +105363,15 @@
105344
105363
  };
105345
105364
  }
105346
105365
 
105347
- /**
105348
- * Create a new element and (optionally) set its parent.
105349
- *
105350
- * @param {string} type
105351
- * @param {Object} properties
105352
- * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
105353
- * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
105354
- *
105355
- * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
105366
+ /**
105367
+ * Create a new element and (optionally) set its parent.
105368
+ *
105369
+ * @param {string} type
105370
+ * @param {Object} properties
105371
+ * @param {import('bpmn-js/lib/model/Types').ModdleElement} parent
105372
+ * @param {import('bpmn-js/lib/features/modeling/BpmnFactory').default} bpmnFactory
105373
+ *
105374
+ * @returns {import('bpmn-js/lib/model/Types').ModdleElement}
105356
105375
  */
105357
105376
  function createElement(type, properties, parent, bpmnFactory) {
105358
105377
  const element = bpmnFactory.create(type, properties);
@@ -105362,8 +105381,8 @@
105362
105381
  return element;
105363
105382
  }
105364
105383
 
105365
- /**
105366
- * generate a semantic id with given prefix
105384
+ /**
105385
+ * generate a semantic id with given prefix
105367
105386
  */
105368
105387
  function nextId(prefix) {
105369
105388
  const ids = new Ids$1([32, 32, 1]);
@@ -105392,12 +105411,12 @@
105392
105411
  const EMPTY_OPTION$4 = '';
105393
105412
  const CREATE_NEW_OPTION$4 = 'create-new';
105394
105413
 
105395
- /**
105396
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105414
+ /**
105415
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105397
105416
  */
105398
105417
 
105399
- /**
105400
- * @returns {Array<Entry>} entries
105418
+ /**
105419
+ * @returns {Array<Entry>} entries
105401
105420
  */
105402
105421
  function ErrorProps$2(props) {
105403
105422
  const {
@@ -105573,12 +105592,12 @@
105573
105592
 
105574
105593
  const CREATE_NEW_OPTION$3 = 'create-new';
105575
105594
 
105576
- /**
105577
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105595
+ /**
105596
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105578
105597
  */
105579
105598
 
105580
- /**
105581
- * @returns {Array<Entry>} entries
105599
+ /**
105600
+ * @returns {Array<Entry>} entries
105582
105601
  */
105583
105602
  function EscalationProps$2(props) {
105584
105603
  const {
@@ -105751,12 +105770,12 @@
105751
105770
  return sortBy$1(elements, e => (e.name || '').toLowerCase());
105752
105771
  }
105753
105772
 
105754
- /**
105755
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105773
+ /**
105774
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105756
105775
  */
105757
105776
 
105758
- /**
105759
- * @returns {Array<Entry>} entries
105777
+ /**
105778
+ * @returns {Array<Entry>} entries
105760
105779
  */
105761
105780
  function ExecutableProps(props) {
105762
105781
  const {
@@ -105827,14 +105846,14 @@
105827
105846
  // for ID validation as per BPMN Schema (QName - Namespace)
105828
105847
  const ID_REGEX = /^[a-z_][\w-.]*$/i;
105829
105848
 
105830
- /**
105831
- * checks whether the id value is valid
105832
- *
105833
- * @param {ModdleElement} element
105834
- * @param {String} idValue
105835
- * @param {Function} translate
105836
- *
105837
- * @return {String} error message
105849
+ /**
105850
+ * checks whether the id value is valid
105851
+ *
105852
+ * @param {ModdleElement} element
105853
+ * @param {String} idValue
105854
+ * @param {Function} translate
105855
+ *
105856
+ * @return {String} error message
105838
105857
  */
105839
105858
  function isIdValid(element, idValue, translate) {
105840
105859
  const assigned = element.$model.ids.assigned(idValue);
@@ -105862,12 +105881,12 @@
105862
105881
  return SPACE_REGEX.test(value);
105863
105882
  }
105864
105883
 
105865
- /**
105866
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105884
+ /**
105885
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105867
105886
  */
105868
105887
 
105869
- /**
105870
- * @returns {Array<Entry>} entries
105888
+ /**
105889
+ * @returns {Array<Entry>} entries
105871
105890
  */
105872
105891
  function IdProps$1() {
105873
105892
  return [{
@@ -105909,12 +105928,12 @@
105909
105928
  });
105910
105929
  }
105911
105930
 
105912
- /**
105913
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105931
+ /**
105932
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105914
105933
  */
105915
105934
 
105916
- /**
105917
- * @returns {Array<Entry>} entries
105935
+ /**
105936
+ * @returns {Array<Entry>} entries
105918
105937
  */
105919
105938
  function LinkProps(props) {
105920
105939
  const {
@@ -105962,12 +105981,12 @@
105962
105981
  const EMPTY_OPTION$3 = '';
105963
105982
  const CREATE_NEW_OPTION$2 = 'create-new';
105964
105983
 
105965
- /**
105966
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105984
+ /**
105985
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
105967
105986
  */
105968
105987
 
105969
- /**
105970
- * @returns {Array<Entry>} entries
105988
+ /**
105989
+ * @returns {Array<Entry>} entries
105971
105990
  */
105972
105991
  function MessageProps$1(props) {
105973
105992
  const {
@@ -106110,12 +106129,12 @@
106110
106129
  return sortBy$1(elements, e => (e.name || '').toLowerCase());
106111
106130
  }
106112
106131
 
106113
- /**
106114
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106132
+ /**
106133
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106115
106134
  */
106116
106135
 
106117
- /**
106118
- * @returns {Array<Entry>} entries
106136
+ /**
106137
+ * @returns {Array<Entry>} entries
106119
106138
  */
106120
106139
  function MultiInstanceProps$2(props) {
106121
106140
  const {
@@ -106186,59 +106205,59 @@
106186
106205
 
106187
106206
  // generic ///////////////////////////
106188
106207
 
106189
- /**
106190
- * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
106191
- *
106192
- * @param {djs.model.Base} element
106193
- * @return {boolean}
106208
+ /**
106209
+ * isMultiInstanceSupported - check whether given element supports MultiInstanceLoopCharacteristics.
106210
+ *
106211
+ * @param {djs.model.Base} element
106212
+ * @return {boolean}
106194
106213
  */
106195
106214
  function isMultiInstanceSupported$1(element) {
106196
106215
  const loopCharacteristics = getLoopCharacteristics$2(element);
106197
106216
  return !!loopCharacteristics && is$5(loopCharacteristics, 'bpmn:MultiInstanceLoopCharacteristics');
106198
106217
  }
106199
106218
 
106200
- /**
106201
- * getBody - get the body of a given expression.
106202
- *
106203
- * @param {ModdleElement<bpmn:FormalExpression>} expression
106204
- * @return {string} the body (value) of the expression
106219
+ /**
106220
+ * getBody - get the body of a given expression.
106221
+ *
106222
+ * @param {ModdleElement<bpmn:FormalExpression>} expression
106223
+ * @return {string} the body (value) of the expression
106205
106224
  */
106206
106225
  function getBody(expression) {
106207
106226
  return expression && expression.get('body');
106208
106227
  }
106209
106228
 
106210
- /**
106211
- * getProperty - get a property value of the loop characteristics.
106212
- *
106213
- * @param {djs.model.Base} element
106214
- * @param {string} propertyName
106215
- *
106216
- * @return {any} the property value
106229
+ /**
106230
+ * getProperty - get a property value of the loop characteristics.
106231
+ *
106232
+ * @param {djs.model.Base} element
106233
+ * @param {string} propertyName
106234
+ *
106235
+ * @return {any} the property value
106217
106236
  */
106218
106237
  function getProperty$2(element, propertyName) {
106219
106238
  const loopCharacteristics = getLoopCharacteristics$2(element);
106220
106239
  return loopCharacteristics && loopCharacteristics.get(propertyName);
106221
106240
  }
106222
106241
 
106223
- /**
106224
- * getLoopCharacteristics - get loopCharacteristics of a given element.
106225
- *
106226
- * @param {djs.model.Base} element
106227
- * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
106242
+ /**
106243
+ * getLoopCharacteristics - get loopCharacteristics of a given element.
106244
+ *
106245
+ * @param {djs.model.Base} element
106246
+ * @return {ModdleElement<bpmn:MultiInstanceLoopCharacteristics> | undefined}
106228
106247
  */
106229
106248
  function getLoopCharacteristics$2(element) {
106230
106249
  const bo = getBusinessObject$1(element);
106231
106250
  return bo.loopCharacteristics;
106232
106251
  }
106233
106252
 
106234
- /**
106235
- * createFormalExpression - creates a 'bpmn:FormalExpression' element.
106236
- *
106237
- * @param {ModdleElement} parent
106238
- * @param {string} body
106239
- * @param {BpmnFactory} bpmnFactory
106240
- *
106241
- * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
106253
+ /**
106254
+ * createFormalExpression - creates a 'bpmn:FormalExpression' element.
106255
+ *
106256
+ * @param {ModdleElement} parent
106257
+ * @param {string} body
106258
+ * @param {BpmnFactory} bpmnFactory
106259
+ *
106260
+ * @result {ModdleElement<bpmn:FormalExpression>} a formal expression
106242
106261
  */
106243
106262
  function createFormalExpression$1(parent, body, bpmnFactory) {
106244
106263
  return createElement('bpmn:FormalExpression', {
@@ -106246,13 +106265,13 @@
106246
106265
  }, parent, bpmnFactory);
106247
106266
  }
106248
106267
 
106249
- /**
106250
- * updateFormalExpression - updates a specific formal expression of the loop characteristics.
106251
- *
106252
- * @param {djs.model.Base} element
106253
- * @param {string} propertyName
106254
- * @param {string} newValue
106255
- * @param {BpmnFactory} bpmnFactory
106268
+ /**
106269
+ * updateFormalExpression - updates a specific formal expression of the loop characteristics.
106270
+ *
106271
+ * @param {djs.model.Base} element
106272
+ * @param {string} propertyName
106273
+ * @param {string} newValue
106274
+ * @param {BpmnFactory} bpmnFactory
106256
106275
  */
106257
106276
  function updateFormalExpression(element, propertyName, newValue, bpmnFactory) {
106258
106277
  const loopCharacteristics = getLoopCharacteristics$2(element);
@@ -106289,23 +106308,23 @@
106289
106308
 
106290
106309
  // loopCardinality
106291
106310
 
106292
- /**
106293
- * getLoopCardinality - get the loop cardinality of the loop characteristics.
106294
- *
106295
- * @param {djs.model.Base} element
106296
- *
106297
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
106311
+ /**
106312
+ * getLoopCardinality - get the loop cardinality of the loop characteristics.
106313
+ *
106314
+ * @param {djs.model.Base} element
106315
+ *
106316
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the loop cardinality
106298
106317
  */
106299
106318
  function getLoopCardinality(element) {
106300
106319
  return getProperty$2(element, 'loopCardinality');
106301
106320
  }
106302
106321
 
106303
- /**
106304
- * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
106305
- *
106306
- * @param {djs.model.Base} element
106307
- *
106308
- * @return {string} the loop cardinality value
106322
+ /**
106323
+ * getLoopCardinalityValue - get the loop cardinality value of the loop characteristics.
106324
+ *
106325
+ * @param {djs.model.Base} element
106326
+ *
106327
+ * @return {string} the loop cardinality value
106309
106328
  */
106310
106329
  function getLoopCardinalityValue(element) {
106311
106330
  const loopCardinality = getLoopCardinality(element);
@@ -106314,35 +106333,35 @@
106314
106333
 
106315
106334
  // completionCondition /////////////////////
106316
106335
 
106317
- /**
106318
- * getCompletionCondition - get the completion condition of the loop characteristics.
106319
- *
106320
- * @param {djs.model.Base} element
106321
- *
106322
- * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
106336
+ /**
106337
+ * getCompletionCondition - get the completion condition of the loop characteristics.
106338
+ *
106339
+ * @param {djs.model.Base} element
106340
+ *
106341
+ * @return {ModdleElement<bpmn:FormalExpression>} an expression representing the completion condition
106323
106342
  */
106324
106343
  function getCompletionCondition$1(element) {
106325
106344
  return getProperty$2(element, 'completionCondition');
106326
106345
  }
106327
106346
 
106328
- /**
106329
- * getCompletionConditionValue - get the completion condition value of the loop characteristics.
106330
- *
106331
- * @param {djs.model.Base} element
106332
- *
106333
- * @return {string} the completion condition value
106347
+ /**
106348
+ * getCompletionConditionValue - get the completion condition value of the loop characteristics.
106349
+ *
106350
+ * @param {djs.model.Base} element
106351
+ *
106352
+ * @return {string} the completion condition value
106334
106353
  */
106335
106354
  function getCompletionConditionValue(element) {
106336
106355
  const completionCondition = getCompletionCondition$1(element);
106337
106356
  return getBody(completionCondition);
106338
106357
  }
106339
106358
 
106340
- /**
106341
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106359
+ /**
106360
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106342
106361
  */
106343
106362
 
106344
- /**
106345
- * @returns {Array<Entry>} entries
106363
+ /**
106364
+ * @returns {Array<Entry>} entries
106346
106365
  */
106347
106366
  function NameProps(props) {
106348
106367
  const {
@@ -106446,12 +106465,12 @@
106446
106465
  return categoryValue;
106447
106466
  }
106448
106467
 
106449
- /**
106450
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106468
+ /**
106469
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106451
106470
  */
106452
106471
 
106453
- /**
106454
- * @returns {Array<Entry>} entries
106472
+ /**
106473
+ * @returns {Array<Entry>} entries
106455
106474
  */
106456
106475
  function ProcessProps$1(props) {
106457
106476
  const {
@@ -106542,15 +106561,15 @@
106542
106561
  return is$5(element, 'bpmn:Participant') && element.businessObject.get('processRef');
106543
106562
  }
106544
106563
 
106545
- /**
106546
- * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106564
+ /**
106565
+ * @typedef { import('@bpmn-io/properties-panel').EntryDefinition } Entry
106547
106566
  */
106548
106567
 
106549
106568
  const EMPTY_OPTION$2 = '';
106550
106569
  const CREATE_NEW_OPTION$1 = 'create-new';
106551
106570
 
106552
- /**
106553
- * @returns {Entry[]}
106571
+ /**
106572
+ * @returns {Entry[]}
106554
106573
  */
106555
106574
  function SignalProps$1(props) {
106556
106575
  const {
@@ -106696,12 +106715,12 @@
106696
106715
  return isAny(element, ['bpmn:StartEvent', 'bpmn:IntermediateCatchEvent', 'bpmn:BoundaryEvent']) && !!getTimerEventDefinition(element);
106697
106716
  }
106698
106717
 
106699
- /**
106700
- * Get the timer definition type for a given timer event definition.
106701
- *
106702
- * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
106703
- *
106704
- * @return {string|undefined} the timer definition type
106718
+ /**
106719
+ * Get the timer definition type for a given timer event definition.
106720
+ *
106721
+ * @param {ModdleElement<bpmn:TimerEventDefinition>} timer
106722
+ *
106723
+ * @return {string|undefined} the timer definition type
106705
106724
  */
106706
106725
  function getTimerDefinitionType(timer) {
106707
106726
  if (!timer) {
@@ -106771,12 +106790,12 @@
106771
106790
  return entries;
106772
106791
  }
106773
106792
 
106774
- /**
106775
- * TimerEventDefinitionType - Generic select entry allowing to select a specific
106776
- * timerEventDefintionType. To be used together with timerEventDefinitionValue.
106777
- *
106778
- * @param {type} props
106779
- * @return {SelectEntry}
106793
+ /**
106794
+ * TimerEventDefinitionType - Generic select entry allowing to select a specific
106795
+ * timerEventDefintionType. To be used together with timerEventDefinitionValue.
106796
+ *
106797
+ * @param {type} props
106798
+ * @return {SelectEntry}
106780
106799
  */
106781
106800
  function TimerEventDefinitionType$2(props) {
106782
106801
  const {
@@ -106844,13 +106863,13 @@
106844
106863
  });
106845
106864
  }
106846
106865
 
106847
- /**
106848
- * TimerEventDefinitionValue - Generic textField entry allowing to specify the
106849
- * timerEventDefintionValue based on the set timerEventDefintionType. To be used
106850
- * together with timerEventDefinitionType.
106851
- *
106852
- * @param {type} props
106853
- * @return {TextFieldEntry}
106866
+ /**
106867
+ * TimerEventDefinitionValue - Generic textField entry allowing to specify the
106868
+ * timerEventDefintionValue based on the set timerEventDefintionType. To be used
106869
+ * together with timerEventDefinitionType.
106870
+ *
106871
+ * @param {type} props
106872
+ * @return {TextFieldEntry}
106854
106873
  */
106855
106874
  function TimerEventDefinitionValue$2(props) {
106856
106875
  const {