bpmn-js 18.22.0 → 18.23.0

package/lib/features/modeling/behavior/UpdateCategoryValueRefsBehavior.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Synchronizes group category references after geometry changes.
+ *
+ */
+export default class UpdateCategoryValueRefsBehavior extends CommandInterceptor {
+    /**
+     * @param eventBus
+     * @param modeling
+     */
+    constructor(eventBus: EventBus, modeling: Modeling);
+}
+
+type EventBus = import("diagram-js/lib/core/EventBus").default;
+type Modeling = import("../Modeling").default;
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+//# sourceMappingURL=UpdateCategoryValueRefsBehavior.d.ts.map

package/lib/features/modeling/behavior/UpdateCategoryValueRefsBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateCategoryValueRefsBehavior.d.ts","mappings":";;;;AA8CAA;;;;;IAAAC;;;gBArCa,OAAO,8BAA8B,EAAE;gBACvC,OAAO,aAAa,EAAE;;+BARJ,2CAA2C","names":["UpdateCategoryValueRefsBehavior class","UpdateCategoryValueRefsBehavior constructor"],"ignoreList":[],"sources":["UpdateCategoryValueRefsBehavior.js"]}

package/lib/features/modeling/behavior/UpdateCategoryValueRefsBehavior.js

@@ -0,0 +1,169 @@
+import inherits from 'inherits-browser';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+import {
+  is
+} from '../../../util/ModelUtil';
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ * @typedef {import('../Modeling').default} Modeling
+ */
+
+var LOW_PRIORITY = 500,
+    HIGH_PRIORITY = 5000;
+
+// Commands that provide a shape or connection whose references must be updated.
+var categoryValueRefShapeAndConnectionEvents = [
+  'connection.create',
+  'connection.delete',
+  'connection.layout',
+  'connection.move',
+  'connection.reconnect',
+  'connection.updateWaypoints',
+  'shape.create',
+  'shape.delete',
+  'shape.move',
+  'shape.resize'
+];
+
+// Commands that bracket a complete reference update, including nested commands.
+var categoryValueRefUpdateEvents = [
+  ...categoryValueRefShapeAndConnectionEvents,
+  'elements.create',
+  'elements.delete',
+  'elements.move',
+  'label.create',
+  'spaceTool'
+];
+
+/**
+ * Synchronizes group category references after geometry changes.
+ *
+ * @param {EventBus} eventBus
+ * @param {Modeling} modeling
+ */
+export default function UpdateCategoryValueRefsBehavior(eventBus, modeling) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  var context;
+
+  function initContext() {
+    context = context || new UpdateContext();
+    context.enter();
+
+    return context;
+  }
+
+  function getContext() {
+    if (!context) {
+      throw new Error('out of bounds release');
+    }
+
+    return context;
+  }
+
+  function releaseContext() {
+    if (!context) {
+      throw new Error('out of bounds release');
+    }
+
+    var triggerUpdate = context.leave();
+
+    if (triggerUpdate) {
+      modeling.updateCategoryValueRefs(
+        Array.from(context.affectedFlowElements),
+        Array.from(context.affectedGroupEntries.values())
+      );
+
+      context = null;
+    }
+
+    return triggerUpdate;
+  }
+
+  /**
+   * Sets up the context for category value reference updates before executing
+   * commands that may affect them.
+   */
+  this.preExecute(categoryValueRefUpdateEvents, HIGH_PRIORITY, function() {
+    initContext();
+  });
+
+  /**
+   * Releases the context for category value reference updates after executing
+   * commands that may affect them.
+   */
+  this.postExecuted(categoryValueRefUpdateEvents, LOW_PRIORITY, function() {
+    releaseContext();
+  });
+
+  /**
+   * Handles updates to category value references for shapes and connections.
+   */
+  this.preExecute(categoryValueRefShapeAndConnectionEvents, function(event) {
+    var shape = event.context.connection || event.context.shape,
+        updateContext = getContext();
+
+    if (!shape || shape.labelTarget) {
+      return;
+    }
+
+    if (is(shape, 'bpmn:FlowElement')) {
+      updateContext.addFlowElement(shape);
+    }
+
+    if (is(shape, 'bpmn:Group')) {
+      updateContext.addGroup(shape);
+    }
+  });
+
+  this.preExecute('label.create', function(event) {
+    var labelTarget = event.context.labelTarget;
+
+    if (is(labelTarget, 'bpmn:Group')) {
+      getContext().addGroup(labelTarget);
+    }
+  });
+}
+
+UpdateCategoryValueRefsBehavior.$inject = [
+  'eventBus',
+  'modeling'
+];
+
+inherits(UpdateCategoryValueRefsBehavior, CommandInterceptor);
+
+
+function UpdateContext() {
+
+  this.affectedFlowElements = new Set();
+  this.affectedGroupEntries = new Map();
+
+  this.counter = 0;
+
+  this.addFlowElement = function(flowElement) {
+    this.affectedFlowElements.add(flowElement);
+  };
+
+  this.addGroup = function(group) {
+    if (!this.affectedGroupEntries.has(group)) {
+      this.affectedGroupEntries.set(group, {
+        categoryValue: group.businessObject.categoryValueRef,
+        groupShape: group
+      });
+    }
+  };
+
+  this.enter = function() {
+    this.counter++;
+  };
+
+  this.leave = function() {
+    this.counter--;
+
+    return !this.counter;
+  };
+}

package/lib/features/modeling/behavior/UpdateFlowNodeRefsBehavior.d.ts

@@ -1,5 +1,5 @@
 /**
- * BPMN specific delete lane behavior.
+ * Synchronizes lane flow node references after geometry changes.
  *
  */
 export default class UpdateFlowNodeRefsBehavior extends CommandInterceptor {

package/lib/features/modeling/behavior/UpdateFlowNodeRefsBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UpdateFlowNodeRefsBehavior.d.ts","mappings":";;;;AAuBAA;;;;;IAAAC;;;gBAda,OAAO,8BAA8B,EAAE;gBACvC,OAAO,aAAa,EAAE;;+BARJ,2CAA2C","names":["UpdateFlowNodeRefsBehavior class","UpdateFlowNodeRefsBehavior constructor"],"ignoreList":[],"sources":["UpdateFlowNodeRefsBehavior.js"]}
+{"version":3,"file":"UpdateFlowNodeRefsBehavior.d.ts","mappings":";;;;AA0CAA;;;;;IAAAC;;;gBAjCa,OAAO,8BAA8B,EAAE;gBACvC,OAAO,aAAa,EAAE;;+BARJ,2CAA2C","names":["UpdateFlowNodeRefsBehavior class","UpdateFlowNodeRefsBehavior constructor"],"ignoreList":[],"sources":["UpdateFlowNodeRefsBehavior.js"]}

package/lib/features/modeling/behavior/UpdateFlowNodeRefsBehavior.js

@@ -14,9 +14,28 @@ import {
 var LOW_PRIORITY = 500,
     HIGH_PRIORITY = 5000;
 
+// Commands that provide a shape whose lane references must be updated.
+var laneRefShapeEvents = [
+  'shape.create',
+  'shape.delete',
+  'shape.move',
+  'shape.resize'
+];
+
+// Commands that bracket a complete lane reference update, including nested commands.
+var laneRefUpdateEvents = [
+  ...laneRefShapeEvents,
+  'spaceTool',
+  'lane.add',
+  'lane.resize',
+  'lane.split',
+  'elements.create',
+  'elements.delete',
+  'elements.move'
+];
 
 /**
- * BPMN specific delete lane behavior.
+ * Synchronizes lane flow node references after geometry changes.
  *
  * @param {EventBus} eventBus
  * @param {Modeling} modeling
@@ -25,13 +44,6 @@ export default function UpdateFlowNodeRefsBehavior(eventBus, modeling) {
 
   CommandInterceptor.call(this, eventBus);
 
-  /**
-   * Update Lane#flowNodeRefs and FlowNode#lanes with every flow node
-   * move/resize and lane move/resize. Groups elements to recompute containments
-   * as efficient as possible.
-   */
-
-  // the update context
   var context;
 
 
@@ -68,40 +80,26 @@ export default function UpdateFlowNodeRefsBehavior(eventBus, modeling) {
   }
 
 
-  var laneRefUpdateEvents = [
-    'spaceTool',
-    'lane.add',
-    'lane.resize',
-    'lane.split',
-    'elements.create',
-    'elements.delete',
-    'elements.move',
-    'shape.create',
-    'shape.delete',
-    'shape.move',
-    'shape.resize'
-  ];
-
-
-  // listen to a lot of stuff to group lane updates
-
-  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY, function(event) {
+  /**
+   * Sets up the context for lane reference updates before executing commands
+   * that may affect them.
+   */
+  this.preExecute(laneRefUpdateEvents, HIGH_PRIORITY, function() {
     initContext();
   });
 
-  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY, function(event) {
+  /**
+   * Releases the context for lane reference updates after executing commands
+   * that may affect them.
+   */
+  this.postExecuted(laneRefUpdateEvents, LOW_PRIORITY, function() {
     releaseContext();
   });
 
-
-  // Mark flow nodes + lanes that need an update
-
-  this.preExecute([
-    'shape.create',
-    'shape.move',
-    'shape.delete',
-    'shape.resize'
-  ], function(event) {
+  /**
+   * Handles updates to lane references for shapes.
+   */
+  this.preExecute(laneRefShapeEvents, function(event) {
 
     var context = event.context,
         shape = context.shape;
@@ -109,7 +107,7 @@ export default function UpdateFlowNodeRefsBehavior(eventBus, modeling) {
     var updateContext = getContext();
 
     // no need to update labels
-    if (shape.labelTarget) {
+    if (!shape || shape.labelTarget) {
       return;
     }
 

package/lib/features/modeling/behavior/index.d.ts

@@ -5,6 +5,7 @@ declare const _default: {
   attachEventBehavior: (string | typeof AttachEventBehavior)[];
   artifactBehavior: (string | typeof ArtifactBehavior)[];
   boundaryEventBehavior: (string | typeof BoundaryEventBehavior)[];
+  categoryRootElementReferenceBehavior: (string | typeof CategoryRootElementReferenceBehavior)[];
   compensateBoundaryEventBehaviour: (string | typeof CompensateBoundaryEventBehavior)[];
   createBehavior: (string | typeof CreateBehavior)[];
   createDataObjectBehavior: (string | typeof CreateDataObjectBehavior)[];
@@ -40,6 +41,7 @@ declare const _default: {
   unclaimIdBehavior: (string | typeof UnclaimIdBehavior)[];
   unsetDefaultFlowBehavior: (string | typeof UnsetDefaultFlowBehavior)[];
   updateFlowNodeRefsBehavior: (string | typeof UpdateFlowNodeRefsBehavior)[];
+  updateCategoryValueRefsBehavior: (string | typeof UpdateCategoryValueRefsBehavior)[];
   setCompensationActivityAfterPasteBehavior: (string | typeof SetCompensationActivityAfterPasteBehavior)[];
 };
 export default _default;
@@ -49,6 +51,7 @@ import AssociationBehavior from './AssociationBehavior';
 import AttachEventBehavior from './AttachEventBehavior';
 import ArtifactBehavior from './ArtifactBehavior';
 import BoundaryEventBehavior from './BoundaryEventBehavior';
+import CategoryRootElementReferenceBehavior from './CategoryRootElementReferenceBehavior';
 import CompensateBoundaryEventBehavior from './CompensateBoundaryEventBehavior';
 import CreateBehavior from './CreateBehavior';
 import CreateDataObjectBehavior from './CreateDataObjectBehavior';
@@ -84,5 +87,6 @@ import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
 import UnclaimIdBehavior from './UnclaimIdBehavior';
 import UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';
 import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
+import UpdateCategoryValueRefsBehavior from './UpdateCategoryValueRefsBehavior';
 import SetCompensationActivityAfterPasteBehavior from './SetCompensationActivityAfterPasteBehavior';
 //# sourceMappingURL=index.d.ts.map

package/lib/features/modeling/behavior/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAA6C,oCAAoC;2BACtD,kBAAkB;gCAEb,uBAAuB;gCACvB,uBAAuB;6BAF1B,oBAAoB;kCAGf,yBAAyB;4CACf,mCAAmC;2BACpD,kBAAkB;qCACR,4BAA4B;sCAC3B,6BAA6B;yCAC1B,gCAAgC;8BAC3C,qBAAqB;+BACpB,sBAAsB;gCACrB,uBAAuB;+BACxB,sBAAsB;sCACf,6BAA6B;6BACtC,oBAAoB;0BACvB,iBAAiB;6BACd,oBAAoB;4BACrB,mBAAmB;0BACrB,iBAAiB;qCACN,4BAA4B;gCACjC,uBAAuB;oCACnB,2BAA2B;kCAE7B,yBAAyB;8CADb,qCAAqC;sCAE7C,6BAA6B;sCAC7B,6BAA6B;oCAC/B,2BAA2B;2BACpC,kBAAkB;+BACd,sBAAsB;yCACZ,gCAAgC;8BAC3C,qBAAqB;oCACf,2BAA2B;yCACtB,gCAAgC;mCACtC,0BAA0B;8CACf,qCAAqC;2CACxC,kCAAkC;8BAC/C,qBAAqB;qCACd,4BAA4B;uCAC1B,8BAA8B;sDACf,6CAA6C","names":[],"ignoreList":[],"sources":["index.js"]}
+{"version":3,"file":"index.d.ts","mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAA6C,oCAAoC;2BACtD,kBAAkB;gCAEb,uBAAuB;gCACvB,uBAAuB;6BAF1B,oBAAoB;kCAGf,yBAAyB;iDACV,wCAAwC;4CAC7C,mCAAmC;2BACpD,kBAAkB;qCACR,4BAA4B;sCAC3B,6BAA6B;yCAC1B,gCAAgC;8BAC3C,qBAAqB;+BACpB,sBAAsB;gCACrB,uBAAuB;+BACxB,sBAAsB;sCACf,6BAA6B;6BACtC,oBAAoB;0BACvB,iBAAiB;6BACd,oBAAoB;4BACrB,mBAAmB;0BACrB,iBAAiB;qCACN,4BAA4B;gCACjC,uBAAuB;oCACnB,2BAA2B;kCAE7B,yBAAyB;8CADb,qCAAqC;sCAE7C,6BAA6B;sCAC7B,6BAA6B;oCAC/B,2BAA2B;2BACpC,kBAAkB;+BACd,sBAAsB;yCACZ,gCAAgC;8BAC3C,qBAAqB;oCACf,2BAA2B;yCACtB,gCAAgC;mCACtC,0BAA0B;8CACf,qCAAqC;2CACxC,kCAAkC;8BAC/C,qBAAqB;qCACd,4BAA4B;uCAC1B,8BAA8B;4CACzB,mCAAmC;sDACzB,6CAA6C","names":[],"ignoreList":[],"sources":["index.js"]}

package/lib/features/modeling/behavior/index.js

@@ -4,6 +4,7 @@ import ArtifactBehavior from './ArtifactBehavior';
 import AssociationBehavior from './AssociationBehavior';
 import AttachEventBehavior from './AttachEventBehavior';
 import BoundaryEventBehavior from './BoundaryEventBehavior';
+import CategoryRootElementReferenceBehavior from './CategoryRootElementReferenceBehavior';
 import CompensateBoundaryEventBehavior from './CompensateBoundaryEventBehavior';
 import CreateBehavior from './CreateBehavior';
 import CreateDataObjectBehavior from './CreateDataObjectBehavior';
@@ -39,6 +40,7 @@ import ToggleElementCollapseBehaviour from './ToggleElementCollapseBehaviour';
 import UnclaimIdBehavior from './UnclaimIdBehavior';
 import UnsetDefaultFlowBehavior from './UnsetDefaultFlowBehavior';
 import UpdateFlowNodeRefsBehavior from './UpdateFlowNodeRefsBehavior';
+import UpdateCategoryValueRefsBehavior from './UpdateCategoryValueRefsBehavior';
 import SetCompensationActivityAfterPasteBehavior from './SetCompensationActivityAfterPasteBehavior';
 
 /**
@@ -52,6 +54,7 @@ export default {
     'associationBehavior',
     'attachEventBehavior',
     'boundaryEventBehavior',
+    'categoryRootElementReferenceBehavior',
     'compensateBoundaryEventBehaviour',
     'createBehavior',
     'createDataObjectBehavior',
@@ -86,6 +89,7 @@ export default {
     'toggleElementCollapseBehaviour',
     'unclaimIdBehavior',
     'updateFlowNodeRefsBehavior',
+    'updateCategoryValueRefsBehavior',
     'unsetDefaultFlowBehavior',
     'setCompensationActivityAfterPasteBehavior'
   ],
@@ -95,6 +99,7 @@ export default {
   attachEventBehavior: [ 'type', AttachEventBehavior ],
   artifactBehavior: [ 'type', ArtifactBehavior ],
   boundaryEventBehavior: [ 'type', BoundaryEventBehavior ],
+  categoryRootElementReferenceBehavior: [ 'type', CategoryRootElementReferenceBehavior ],
   compensateBoundaryEventBehaviour: [ 'type', CompensateBoundaryEventBehavior ],
   createBehavior: [ 'type', CreateBehavior ],
   createDataObjectBehavior: [ 'type', CreateDataObjectBehavior ],
@@ -130,5 +135,6 @@ export default {
   unclaimIdBehavior: [ 'type', UnclaimIdBehavior ],
   unsetDefaultFlowBehavior: [ 'type', UnsetDefaultFlowBehavior ],
   updateFlowNodeRefsBehavior: [ 'type', UpdateFlowNodeRefsBehavior ],
+  updateCategoryValueRefsBehavior: [ 'type', UpdateCategoryValueRefsBehavior ],
   setCompensationActivityAfterPasteBehavior: [ 'type', SetCompensationActivityAfterPasteBehavior ]
 };

package/lib/features/modeling/behavior/util/CategoryUtil.d.ts

@@ -16,6 +16,17 @@ export function createCategory(bpmnFactory: BpmnFactory): ModdleElement;
  */
 export function createCategoryValue(bpmnFactory: BpmnFactory): ModdleElement;
 
+/**
+ * Returns a group's category value, creating one (including a
+ * category) if needed.
+ *
+ * @param bpmnFactory
+ * @param groupBo
+ *
+ * @return
+ */
+export function getOrCreateCategoryValueForGroup(bpmnFactory: BpmnFactory, groupBo: ModdleElement): ModdleElement;
+
 /**
  * Adds category value to definitions
  *
@@ -46,6 +57,4 @@ export function unlinkCategoryValue(categoryValue: ModdleElement): ModdleElement
 export function unlinkCategory(category: ModdleElement): ModdleElement;
 
 type BpmnFactory = import("../../BpmnFactory").default;
-
-export type ModdleElement = any;
-//# sourceMappingURL=CategoryUtil.d.ts.map
+type ModdleElement = import("../../../../model/Types").ModdleElement;

package/lib/features/modeling/behavior/util/CategoryUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CategoryUtil.d.ts","mappings":";;;;;;;gBAkBA,4BAJW,YAAW,EAEV;;;;;;;;;AAaZ,iDAJW,WAAW,GAEV,aAAa;;;;;;;;;;;AAezB,iDANW,aAAa,YACb,aAAa,eACb,aAAa,GAEZ,aAAa;;;;;;;;;AAmBzB,mDAJW,aAAa,GAEZ,aAAa;;;;;;;;;AAoBzB,yCAJW,aAAa,GAEZ,aAAa;;mBArEZ,OAAO,mBAAmB,EAAE","names":[],"ignoreList":[],"sources":["CategoryUtil.js"]}
+{"version":3,"file":"CategoryUtil.d.ts","mappings":";;;;;;;gBAkBA,4BAJW,YAAW,EAEV;;;;;;;;;AAaZ,iDAJW,WAAW,GAEV,aAAa;;;;;;;;;;;AAezB,8DALW,WAAW,WACX,aAAa,GAEZ,aAAa;;;;;;;;;;;AAyBzB,iDANW,aAAa,YACb,aAAa,eACb,aAAa,GAEZ,aAAa;;;;;;;;;AAmBzB,mDAJW,aAAa,GAEZ,aAAa;;;;;;;;;AAoBzB,yCAJW,aAAa,GAEZ,aAAa;;mBA5FZ,OAAO,mBAAmB,EAAE;qBAE5B,OAAO,yBAAyB,EAAE","names":[],"ignoreList":[],"sources":["CategoryUtil.js"]}

package/lib/features/modeling/behavior/util/CategoryUtil.js

@@ -6,7 +6,7 @@ import {
 /**
  * @typedef {import('../../BpmnFactory').default} BpmnFactory
  *
- * @typedef {import('../../../model/Types').ModdleElement} ModdleElement
+ * @typedef {import('../../../../model/Types').ModdleElement} ModdleElement
  */
 
 /**
@@ -31,6 +31,29 @@ export function createCategoryValue(bpmnFactory) {
   return bpmnFactory.create('bpmn:CategoryValue');
 }
 
+/**
+ * Returns a group's category value, creating one (including a
+ * category) if needed.
+ *
+ * @param {BpmnFactory} bpmnFactory
+ * @param {ModdleElement} groupBo
+ *
+ * @return {ModdleElement}
+ */
+export function getOrCreateCategoryValueForGroup(bpmnFactory, groupBo) {
+  var categoryValue = groupBo.get('categoryValueRef');
+
+  if (!categoryValue) {
+    categoryValue = groupBo.categoryValueRef = createCategoryValue(bpmnFactory);
+  }
+
+  if (!categoryValue.$parent) {
+    categoryValue.$parent = createCategory(bpmnFactory);
+  }
+
+  return categoryValue;
+}
+
 /**
  * Adds category value to definitions
  *
@@ -84,4 +107,4 @@ export function unlinkCategory(category) {
   }
 
   return category;
-}
+}

package/lib/features/modeling/cmd/UpdateCategoryValueRefsHandler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Updates category value references for flow elements visually enclosed by groups.
+ *
+ * A flow element is grouped only when it shares the group's diagram root and
+ * is geometrically enclosed by the group. Consequently, visible children of an
+ * expanded subprocess are grouped, while children of a collapsed subprocess
+ * are not.
+ *
+ * Groups without a category value are auto-healed: if such a group visually
+ * encloses an affected flow element a category value is created for it on the
+ * fly, so that legacy diagrams (groups modeled without a category value) start
+ * to categorize their contents as soon as they are interacted with.
+ *
+ * @implements {CommandHandler}
+ *
+ */
+export default class UpdateCategoryValueRefsHandler implements CommandHandler {
+  static $inject: string[];
+
+  /**
+   * @param bpmnFactory
+   * @param elementRegistry
+   */
+  constructor(bpmnFactory: BpmnFactory, elementRegistry: ElementRegistry);
+
+  execute(context: any): any[];
+  revert(context: any): any[];
+}
+
+type CommandHandler = import("diagram-js/lib/command/CommandHandler").default;
+type ElementRegistry = import("diagram-js/lib/core/ElementRegistry").default;
+type BpmnFactory = import("../BpmnFactory").default;
+type Element = import("../../../model/Types").Element;
+type ModdleElement = import("../../../model/Types").ModdleElement;
+
+export type CategoryGroupEntry = {
+    categoryValue: ModdleElement;
+    root?: Element;
+};
+//# sourceMappingURL=UpdateCategoryValueRefsHandler.d.ts.map

package/lib/features/modeling/cmd/UpdateCategoryValueRefsHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateCategoryValueRefsHandler.d.ts","mappings":";;;;;;;;;;;;;;;;AAyDAA;EAKAC;;;;;;EALAC;;EAqRyC;EAqBA;;;sBA5U5B,OAAO,uCAAuC,EAAE;uBAChD,OAAO,qCAAqC,EAAE;mBAC9C,OAAO,gBAAgB,EAAE;eAEzB,OAAO,sBAAsB,EAAE;qBAC/B,OAAO,sBAAsB,EAAE;;iCAE9B;IACT,aAAa,EAAE,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO;CAChB","names":["UpdateCategoryValueRefsHandler class","UpdateCategoryValueRefsHandler#$inject","UpdateCategoryValueRefsHandler constructor"],"ignoreList":[],"sources":["UpdateCategoryValueRefsHandler.js"]}