@lemon-fe/components 1.2.14 → 1.3.0-alpha.0

package/es/data-grid/modules/row-grouping/rowGrouping/groupStage.js

@@ -1,740 +0,0 @@
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
-  var c = arguments.length,
-    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
-    d;
-  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { _, Autowired, Bean, BeanStub, NumberSequence, PostConstruct, RowNode } from "@ag-grid-community/core";
-import { BatchRemover } from "./batchRemover";
-var GroupStage = /*#__PURE__*/function (_BeanStub) {
-  _inherits(GroupStage, _BeanStub);
-  var _super = _createSuper(GroupStage);
-  function GroupStage() {
-    var _this;
-    _classCallCheck(this, GroupStage);
-    _this = _super.apply(this, arguments);
-    // we use a sequence variable so that each time we do a grouping, we don't
-    // reuse the ids - otherwise the rowRenderer will confuse rowNodes between redraws
-    // when it tries to animate between rows.
-    _this.groupIdSequence = new NumberSequence();
-    return _this;
-  }
-  _createClass(GroupStage, [{
-    key: "postConstruct",
-    value: function postConstruct() {
-      this.usingTreeData = this.gridOptionsService.isTreeData();
-      if (this.usingTreeData) {
-        this.getDataPath = this.gridOptionsService.get('getDataPath');
-      }
-    }
-  }, {
-    key: "execute",
-    value: function execute(params) {
-      var details = this.createGroupingDetails(params);
-      if (details.transactions) {
-        this.handleTransaction(details);
-      } else {
-        var afterColsChanged = params.afterColumnsChanged === true;
-        this.shotgunResetEverything(details, afterColsChanged);
-      }
-      this.positionLeafsAndGroups(params.changedPath);
-      this.orderGroups(details.rootNode);
-      this.selectableService.updateSelectableAfterGrouping(details.rootNode);
-    }
-  }, {
-    key: "positionLeafsAndGroups",
-    value: function positionLeafsAndGroups(changedPath) {
-      // we don't do group sorting for tree data
-      if (this.usingTreeData) {
-        return;
-      }
-      changedPath.forEachChangedNodeDepthFirst(function (group) {
-        if (group.childrenAfterGroup) {
-          var leafNodes = [];
-          var groupNodes = [];
-          var unbalancedNode;
-          group.childrenAfterGroup.forEach(function (row) {
-            var _a;
-            if (!((_a = row.childrenAfterGroup) === null || _a === void 0 ? void 0 : _a.length)) {
-              leafNodes.push(row);
-            } else {
-              if (row.key === '' && !unbalancedNode) {
-                unbalancedNode = row;
-              } else {
-                groupNodes.push(row);
-              }
-            }
-          });
-          if (unbalancedNode) {
-            groupNodes.push(unbalancedNode);
-          }
-          group.childrenAfterGroup = [].concat(leafNodes, groupNodes);
-        }
-      }, false);
-    }
-  }, {
-    key: "createGroupingDetails",
-    value: function createGroupingDetails(params) {
-      var rowNode = params.rowNode,
-        changedPath = params.changedPath,
-        rowNodeTransactions = params.rowNodeTransactions,
-        rowNodeOrder = params.rowNodeOrder;
-      var groupedCols = this.usingTreeData ? null : this.columnModel.getRowGroupColumns();
-      var details = {
-        // someone complained that the parent attribute was causing some change detection
-        // to break is some angular add-on - which i never used. taking the parent out breaks
-        // a cyclic dependency, hence this flag got introduced.
-        includeParents: !this.gridOptionsService.is('suppressParentsInRowNodes'),
-        expandByDefault: this.gridOptionsService.getNum('groupDefaultExpanded'),
-        groupedCols: groupedCols,
-        rootNode: rowNode,
-        pivotMode: this.columnModel.isPivotMode(),
-        groupedColCount: this.usingTreeData || !groupedCols ? 0 : groupedCols.length,
-        rowNodeOrder: rowNodeOrder,
-        transactions: rowNodeTransactions,
-        // if no transaction, then it's shotgun, changed path would be 'not active' at this point anyway
-        changedPath: changedPath
-      };
-      return details;
-    }
-  }, {
-    key: "handleTransaction",
-    value: function handleTransaction(details) {
-      var _this2 = this;
-      details.transactions.forEach(function (tran) {
-        // we don't allow batch remover for tree data as tree data uses Filler Nodes,
-        // and creating/deleting filler nodes needs to be done alongside the node deleting
-        // and moving. if we want to Batch Remover working with tree data then would need
-        // to consider how Filler Nodes would be impacted (it's possible that it can be easily
-        // modified to work, however for now I don't have the brain energy to work it all out).
-        var batchRemover = !_this2.usingTreeData ? new BatchRemover() : undefined;
-        // the order here of [add, remove, update] needs to be the same as in ClientSideNodeManager,
-        // as the order is important when a record with the same id is added and removed in the same
-        // transaction.
-        if (_.existsAndNotEmpty(tran.remove)) {
-          _this2.removeNodes(tran.remove, details, batchRemover);
-        }
-        if (_.existsAndNotEmpty(tran.update)) {
-          _this2.moveNodesInWrongPath(tran.update, details, batchRemover);
-        }
-        if (_.existsAndNotEmpty(tran.add)) {
-          _this2.insertNodes(tran.add, details, false);
-        }
-        // must flush here, and not allow another transaction to be applied,
-        // as each transaction must finish leaving the data in a consistent state.
-        if (batchRemover) {
-          var parentsWithChildrenRemoved = batchRemover.getAllParents().slice();
-          batchRemover.flush();
-          _this2.removeEmptyGroups(parentsWithChildrenRemoved, details);
-        }
-      });
-      if (details.rowNodeOrder) {
-        this.sortChildren(details);
-      }
-    }
-    // this is used when doing delta updates, eg Redux, keeps nodes in right order
-  }, {
-    key: "sortChildren",
-    value: function sortChildren(details) {
-      details.changedPath.forEachChangedNodeDepthFirst(function (node) {
-        if (!node.childrenAfterGroup) {
-          return;
-        }
-        var didSort = _.sortRowNodesByOrder(node.childrenAfterGroup, details.rowNodeOrder);
-        if (didSort) {
-          details.changedPath.addParentNode(node);
-        }
-      }, false, true);
-    }
-  }, {
-    key: "orderGroups",
-    value: function orderGroups(rootNode) {
-      // we don't do group sorting for tree data
-      if (this.usingTreeData) {
-        return;
-      }
-      var comparator = this.getInitialGroupOrderComparator();
-      if (_.exists(comparator)) {
-        recursiveSort(rootNode);
-      }
-      function recursiveSort(rowNode) {
-        var doSort = _.exists(rowNode.childrenAfterGroup) &&
-        // we only want to sort groups, so we do not sort leafs (a leaf group has leafs as children)
-        !rowNode.leafGroup;
-        if (doSort) {
-          rowNode.childrenAfterGroup.sort(function (nodeA, nodeB) {
-            return comparator({
-              nodeA: nodeA,
-              nodeB: nodeB
-            });
-          });
-          rowNode.childrenAfterGroup.forEach(function (childNode) {
-            return recursiveSort(childNode);
-          });
-        }
-      }
-    }
-  }, {
-    key: "getInitialGroupOrderComparator",
-    value: function getInitialGroupOrderComparator() {
-      var initialGroupOrderComparator = this.gridOptionsService.getCallback('initialGroupOrderComparator');
-      if (initialGroupOrderComparator) {
-        return initialGroupOrderComparator;
-      }
-      // this is the deprecated way, so provide a proxy to make it compatible
-      var defaultGroupOrderComparator = this.gridOptionsService.get('defaultGroupOrderComparator');
-      if (defaultGroupOrderComparator) {
-        return function (params) {
-          return defaultGroupOrderComparator(params.nodeA, params.nodeB);
-        };
-      }
-    }
-  }, {
-    key: "getExistingPathForNode",
-    value: function getExistingPathForNode(node, details) {
-      var res = [];
-      // when doing tree data, the node is part of the path,
-      // but when doing grid grouping, the node is not part of the path so we start with the parent.
-      var pointer = this.usingTreeData ? node : node.parent;
-      while (pointer && pointer !== details.rootNode) {
-        res.push({
-          key: pointer.key,
-          rowGroupColumn: pointer.rowGroupColumn,
-          field: pointer.field
-        });
-        pointer = pointer.parent;
-      }
-      res.reverse();
-      return res;
-    }
-  }, {
-    key: "moveNodesInWrongPath",
-    value: function moveNodesInWrongPath(childNodes, details, batchRemover) {
-      var _this3 = this;
-      childNodes.forEach(function (childNode) {
-        // we add node, even if parent has not changed, as the data could have
-        // changed, hence aggregations will be wrong
-        if (details.changedPath.isActive()) {
-          details.changedPath.addParentNode(childNode.parent);
-        }
-        var infoToKeyMapper = function infoToKeyMapper(item) {
-          return item.key;
-        };
-        var oldPath = _this3.getExistingPathForNode(childNode, details).map(infoToKeyMapper);
-        var newPath = _this3.getGroupInfo(childNode, details).map(infoToKeyMapper);
-        var nodeInCorrectPath = _.areEqual(oldPath, newPath);
-        if (!nodeInCorrectPath) {
-          _this3.moveNode(childNode, details, batchRemover);
-        }
-      });
-    }
-  }, {
-    key: "moveNode",
-    value: function moveNode(childNode, details, batchRemover) {
-      this.removeNodesInStages([childNode], details, batchRemover);
-      this.insertOneNode(childNode, details, true, batchRemover);
-      // hack - if we didn't do this, then renaming a tree item (ie changing rowNode.key) wouldn't get
-      // refreshed into the gui.
-      // this is needed to kick off the event that rowComp listens to for refresh. this in turn
-      // then will get each cell in the row to refresh - which is what we need as we don't know which
-      // columns will be displaying the rowNode.key info.
-      childNode.setData(childNode.data);
-      // we add both old and new parents to changed path, as both will need to be refreshed.
-      // we already added the old parent (in calling method), so just add the new parent here
-      if (details.changedPath.isActive()) {
-        var newParent = childNode.parent;
-        details.changedPath.addParentNode(newParent);
-      }
-    }
-  }, {
-    key: "removeNodes",
-    value: function removeNodes(leafRowNodes, details, batchRemover) {
-      this.removeNodesInStages(leafRowNodes, details, batchRemover);
-      if (details.changedPath.isActive()) {
-        leafRowNodes.forEach(function (rowNode) {
-          return details.changedPath.addParentNode(rowNode.parent);
-        });
-      }
-    }
-  }, {
-    key: "removeNodesInStages",
-    value: function removeNodesInStages(leafRowNodes, details, batchRemover) {
-      this.removeNodesFromParents(leafRowNodes, details, batchRemover);
-      if (this.usingTreeData) {
-        this.postRemoveCreateFillerNodes(leafRowNodes, details);
-        // When not TreeData, then removeEmptyGroups is called just before the BatchRemover is flushed.
-        // However for TreeData, there is no BatchRemover, so we have to call removeEmptyGroups here.
-        var nodeParents = leafRowNodes.map(function (n) {
-          return n.parent;
-        });
-        this.removeEmptyGroups(nodeParents, details);
-      }
-    }
-  }, {
-    key: "forEachParentGroup",
-    value: function forEachParentGroup(details, group, callback) {
-      var pointer = group;
-      while (pointer && pointer !== details.rootNode) {
-        callback(pointer);
-        pointer = pointer.parent;
-      }
-    }
-  }, {
-    key: "removeNodesFromParents",
-    value: function removeNodesFromParents(nodesToRemove, details, provided) {
-      var _this4 = this;
-      // this method can be called with BatchRemover as optional. if it is missed, we created a local version
-      // and flush it at the end. if one is provided, we add to the provided one and it gets flushed elsewhere.
-      var batchRemoverIsLocal = provided == null;
-      var batchRemoverToUse = provided ? provided : new BatchRemover();
-      nodesToRemove.forEach(function (nodeToRemove) {
-        _this4.removeFromParent(nodeToRemove, batchRemoverToUse);
-        // remove from allLeafChildren. we clear down all parents EXCEPT the Root Node, as
-        // the ClientSideNodeManager is responsible for the Root Node.
-        _this4.forEachParentGroup(details, nodeToRemove.parent, function (parentNode) {
-          batchRemoverToUse.removeFromAllLeafChildren(parentNode, nodeToRemove);
-        });
-      });
-      if (batchRemoverIsLocal) {
-        batchRemoverToUse.flush();
-      }
-    }
-  }, {
-    key: "postRemoveCreateFillerNodes",
-    value: function postRemoveCreateFillerNodes(nodesToRemove, details) {
-      var _this5 = this;
-      nodesToRemove.forEach(function (nodeToRemove) {
-        // if not group, and children are present, need to move children to a group.
-        // otherwise if no children, we can just remove without replacing.
-        var replaceWithGroup = nodeToRemove.hasChildren();
-        if (replaceWithGroup) {
-          var oldPath = _this5.getExistingPathForNode(nodeToRemove, details);
-          // because we just removed the userGroup, this will always return new support group
-          var newGroupNode = _this5.findParentForNode(nodeToRemove, oldPath, details);
-          // these properties are the ones that will be incorrect in the newly created group,
-          // so copy them from the old childNode
-          newGroupNode.expanded = nodeToRemove.expanded;
-          newGroupNode.allLeafChildren = nodeToRemove.allLeafChildren;
-          newGroupNode.childrenAfterGroup = nodeToRemove.childrenAfterGroup;
-          newGroupNode.childrenMapped = nodeToRemove.childrenMapped;
-          newGroupNode.updateHasChildren();
-          newGroupNode.childrenAfterGroup.forEach(function (rowNode) {
-            return rowNode.parent = newGroupNode;
-          });
-        }
-      });
-    }
-  }, {
-    key: "removeEmptyGroups",
-    value: function removeEmptyGroups(possibleEmptyGroups, details) {
-      var _this6 = this;
-      // we do this multiple times, as when we remove groups, that means the parent of just removed
-      // group can then be empty. to get around this, if we remove, then we check everything again for
-      // newly emptied groups. the max number of times this will execute is the depth of the group tree.
-      var checkAgain = true;
-      var groupShouldBeRemoved = function groupShouldBeRemoved(rowNode) {
-        // because of the while loop below, it's possible we already moved the node,
-        // so double check before trying to remove again.
-        var mapKey = _this6.getChildrenMappedKey(rowNode.key, rowNode.rowGroupColumn);
-        var parentRowNode = rowNode.parent;
-        var groupAlreadyRemoved = parentRowNode && parentRowNode.childrenMapped ? !parentRowNode.childrenMapped[mapKey] : true;
-        if (groupAlreadyRemoved) {
-          // if not linked, then group was already removed
-          return false;
-        }
-        // if still not removed, then we remove if this group is empty
-        return !!rowNode.isEmptyRowGroupNode();
-      };
-      var _loop = function _loop() {
-        checkAgain = false;
-        var batchRemover = new BatchRemover();
-        possibleEmptyGroups.forEach(function (possibleEmptyGroup) {
-          // remove empty groups
-          _this6.forEachParentGroup(details, possibleEmptyGroup, function (rowNode) {
-            if (groupShouldBeRemoved(rowNode)) {
-              checkAgain = true;
-              _this6.removeFromParent(rowNode, batchRemover);
-              // we remove selection on filler nodes here, as the selection would not be removed
-              // from the RowNodeManager, as filler nodes don't exist on the RowNodeManager
-              rowNode.setSelectedParams({
-                newValue: false,
-                source: 'rowGroupChanged'
-              });
-            }
-          });
-        });
-        batchRemover.flush();
-      };
-      while (checkAgain) {
-        _loop();
-      }
-    }
-    // removes the node from the parent by:
-    // a) removing from childrenAfterGroup (using batchRemover if present, otherwise immediately)
-    // b) removing from childrenMapped (immediately)
-    // c) setRowTop(null) - as the rowRenderer uses this to know the RowNode is no longer needed
-    // d) setRowIndex(null) - as the rowNode will no longer be displayed.
-  }, {
-    key: "removeFromParent",
-    value: function removeFromParent(child, batchRemover) {
-      if (child.parent) {
-        if (batchRemover) {
-          batchRemover.removeFromChildrenAfterGroup(child.parent, child);
-        } else {
-          _.removeFromArray(child.parent.childrenAfterGroup, child);
-          child.parent.updateHasChildren();
-        }
-      }
-      var mapKey = this.getChildrenMappedKey(child.key, child.rowGroupColumn);
-      if (child.parent && child.parent.childrenMapped) {
-        child.parent.childrenMapped[mapKey] = undefined;
-      }
-      // this is important for transition, see rowComp removeFirstPassFuncs. when doing animation and
-      // remove, if rowTop is still present, the rowComp thinks it's just moved position.
-      child.setRowTop(null);
-      child.setRowIndex(null);
-    }
-  }, {
-    key: "addToParent",
-    value: function addToParent(child, parent) {
-      var mapKey = this.getChildrenMappedKey(child.key, child.rowGroupColumn);
-      if (parent) {
-        var children = parent.childrenMapped != null;
-        if (children) {
-          parent.childrenMapped[mapKey] = child;
-        }
-        parent.childrenAfterGroup.push(child);
-        parent.updateHasChildren();
-      }
-    }
-  }, {
-    key: "areGroupColsEqual",
-    value: function areGroupColsEqual(d1, d2) {
-      if (d1 == null || d2 == null || d1.pivotMode !== d2.pivotMode) {
-        return false;
-      }
-      return _.areEqual(d1.groupedCols, d2.groupedCols);
-    }
-  }, {
-    key: "checkAllGroupDataAfterColsChanged",
-    value: function checkAllGroupDataAfterColsChanged(details) {
-      var _this7 = this;
-      var recurse = function recurse(rowNodes) {
-        if (!rowNodes) {
-          return;
-        }
-        rowNodes.forEach(function (rowNode) {
-          var isLeafNode = !_this7.usingTreeData && !rowNode.group;
-          if (isLeafNode) {
-            return;
-          }
-          var groupInfo = {
-            field: rowNode.field,
-            key: rowNode.key,
-            rowGroupColumn: rowNode.rowGroupColumn
-          };
-          _this7.setGroupData(rowNode, groupInfo);
-          recurse(rowNode.childrenAfterGroup);
-        });
-      };
-      recurse(details.rootNode.childrenAfterGroup);
-    }
-  }, {
-    key: "shotgunResetEverything",
-    value: function shotgunResetEverything(details, afterColumnsChanged) {
-      if (this.noChangeInGroupingColumns(details, afterColumnsChanged)) {
-        return;
-      }
-      // groups are about to get disposed, so need to deselect any that are selected
-      this.selectionService.filterFromSelection(function (node) {
-        return node && !node.group;
-      });
-      var rootNode = details.rootNode,
-        groupedCols = details.groupedCols;
-      // because we are not creating the root node each time, we have the logic
-      // here to change leafGroup once.
-      // we set .leafGroup to false for tree data, as .leafGroup is only used when pivoting, and pivoting
-      // isn't allowed with treeData, so the grid never actually use .leafGroup when doing treeData.
-      rootNode.leafGroup = this.usingTreeData ? false : groupedCols.length === 0;
-      // we are doing everything from scratch, so reset childrenAfterGroup and childrenMapped from the rootNode
-      rootNode.childrenAfterGroup = [];
-      rootNode.childrenMapped = {};
-      rootNode.updateHasChildren();
-      var sibling = rootNode.sibling;
-      if (sibling) {
-        sibling.childrenAfterGroup = rootNode.childrenAfterGroup;
-        sibling.childrenMapped = rootNode.childrenMapped;
-      }
-      this.insertNodes(rootNode.allLeafChildren, details, false);
-    }
-  }, {
-    key: "noChangeInGroupingColumns",
-    value: function noChangeInGroupingColumns(details, afterColumnsChanged) {
-      var noFurtherProcessingNeeded = false;
-      var groupDisplayColumns = this.columnModel.getGroupDisplayColumns();
-      var newGroupDisplayColIds = groupDisplayColumns ? groupDisplayColumns.map(function (c) {
-        return c.getId();
-      }).join('-') : '';
-      if (afterColumnsChanged) {
-        // we only need to redo grouping if doing normal grouping (ie not tree data)
-        // and the group cols have changed.
-        noFurtherProcessingNeeded = this.usingTreeData || this.areGroupColsEqual(details, this.oldGroupingDetails);
-        // if the group display cols have changed, then we need to update rowNode.groupData
-        // (regardless of tree data or row grouping)
-        if (this.oldGroupDisplayColIds !== newGroupDisplayColIds) {
-          this.checkAllGroupDataAfterColsChanged(details);
-        }
-      }
-      this.oldGroupingDetails = details;
-      this.oldGroupDisplayColIds = newGroupDisplayColIds;
-      return noFurtherProcessingNeeded;
-    }
-  }, {
-    key: "insertNodes",
-    value: function insertNodes(newRowNodes, details, isMove) {
-      var _this8 = this;
-      newRowNodes.forEach(function (rowNode) {
-        _this8.insertOneNode(rowNode, details, isMove);
-        if (details.changedPath.isActive()) {
-          details.changedPath.addParentNode(rowNode.parent);
-        }
-      });
-    }
-  }, {
-    key: "insertOneNode",
-    value: function insertOneNode(childNode, details, isMove, batchRemover) {
-      var path = this.getGroupInfo(childNode, details);
-      var parentGroup = this.findParentForNode(childNode, path, details, batchRemover);
-      if (!parentGroup.group) {
-        console.warn("AG Grid: duplicate group keys for row data, keys should be unique", [parentGroup.data, childNode.data]);
-      }
-      if (this.usingTreeData) {
-        this.swapGroupWithUserNode(parentGroup, childNode, isMove);
-      } else {
-        childNode.parent = parentGroup;
-        childNode.level = path.length;
-        parentGroup.childrenAfterGroup.push(childNode);
-        parentGroup.updateHasChildren();
-      }
-    }
-  }, {
-    key: "findParentForNode",
-    value: function findParentForNode(childNode, path, details, batchRemover) {
-      var _this9 = this;
-      var nextNode = details.rootNode;
-      path.forEach(function (groupInfo, level) {
-        nextNode = _this9.getOrCreateNextNode(nextNode, groupInfo, level, details);
-        // node gets added to all group nodes.
-        // note: we do not add to rootNode here, as the rootNode is the master list of rowNodes
-        if (!(batchRemover === null || batchRemover === void 0 ? void 0 : batchRemover.isRemoveFromAllLeafChildren(nextNode, childNode))) {
-          nextNode.allLeafChildren.push(childNode);
-        } else {
-          // if this node is about to be removed, prevent that
-          batchRemover === null || batchRemover === void 0 ? void 0 : batchRemover.preventRemoveFromAllLeafChildren(nextNode, childNode);
-        }
-      });
-      return nextNode;
-    }
-  }, {
-    key: "swapGroupWithUserNode",
-    value: function swapGroupWithUserNode(fillerGroup, userGroup, isMove) {
-      userGroup.parent = fillerGroup.parent;
-      userGroup.key = fillerGroup.key;
-      userGroup.field = fillerGroup.field;
-      userGroup.groupData = fillerGroup.groupData;
-      userGroup.level = fillerGroup.level;
-      // AG-3441 - preserve the existing expanded status of the node if we're moving it, so that
-      // you can drag a sub tree from one parent to another without changing its expansion
-      if (!isMove) {
-        userGroup.expanded = fillerGroup.expanded;
-      }
-      // we set .leafGroup to false for tree data, as .leafGroup is only used when pivoting, and pivoting
-      // isn't allowed with treeData, so the grid never actually use .leafGroup when doing treeData.
-      userGroup.leafGroup = fillerGroup.leafGroup;
-      // always null for userGroups, as row grouping is not allowed when doing tree data
-      userGroup.rowGroupIndex = fillerGroup.rowGroupIndex;
-      userGroup.allLeafChildren = fillerGroup.allLeafChildren;
-      userGroup.childrenAfterGroup = fillerGroup.childrenAfterGroup;
-      userGroup.childrenMapped = fillerGroup.childrenMapped;
-      userGroup.sibling = fillerGroup.sibling;
-      userGroup.updateHasChildren();
-      this.removeFromParent(fillerGroup);
-      userGroup.childrenAfterGroup.forEach(function (rowNode) {
-        return rowNode.parent = userGroup;
-      });
-      this.addToParent(userGroup, fillerGroup.parent);
-    }
-  }, {
-    key: "getOrCreateNextNode",
-    value: function getOrCreateNextNode(parentGroup, groupInfo, level, details) {
-      var key = this.getChildrenMappedKey(groupInfo.key, groupInfo.rowGroupColumn);
-      var nextNode = parentGroup.childrenMapped ? parentGroup.childrenMapped[key] : undefined;
-      if (!nextNode) {
-        nextNode = this.createGroup(groupInfo, parentGroup, level, details);
-        // attach the new group to the parent
-        this.addToParent(nextNode, parentGroup);
-      }
-      return nextNode;
-    }
-  }, {
-    key: "createGroup",
-    value: function createGroup(groupInfo, parent, level, details) {
-      var groupNode = new RowNode(this.beans);
-      groupNode.group = true;
-      groupNode.field = groupInfo.field;
-      groupNode.rowGroupColumn = groupInfo.rowGroupColumn;
-      this.setGroupData(groupNode, groupInfo);
-      // we put 'row-group-' before the group id, so it doesn't clash with standard row id's. we also use 't-' and 'b-'
-      // for top pinned and bottom pinned rows.
-      groupNode.id = RowNode.ID_PREFIX_ROW_GROUP + this.groupIdSequence.next();
-      groupNode.key = groupInfo.key;
-      groupNode.level = level;
-      groupNode.leafGroup = this.usingTreeData ? false : level === details.groupedColCount - 1;
-      groupNode.allLeafChildren = [];
-      // why is this done here? we are not updating the children count as we go,
-      // i suspect this is updated in the filter stage
-      groupNode.setAllChildrenCount(0);
-      groupNode.rowGroupIndex = this.usingTreeData ? null : level;
-      groupNode.childrenAfterGroup = [];
-      groupNode.childrenMapped = {};
-      groupNode.updateHasChildren();
-      groupNode.parent = details.includeParents ? parent : null;
-      this.setExpandedInitialValue(details, groupNode);
-      if (this.gridOptionsService.is('groupIncludeFooter')) {
-        groupNode.createFooter();
-      }
-      return groupNode;
-    }
-  }, {
-    key: "setGroupData",
-    value: function setGroupData(groupNode, groupInfo) {
-      var _this10 = this;
-      groupNode.groupData = {};
-      var groupDisplayCols = this.columnModel.getGroupDisplayColumns();
-      groupDisplayCols.forEach(function (col) {
-        // newGroup.rowGroupColumn=null when working off GroupInfo, and we always display the group in the group column
-        // if rowGroupColumn is present, then it's grid row grouping and we only include if configuration says so
-        var displayGroupForCol = _this10.usingTreeData || (groupNode.rowGroupColumn ? col.isRowGroupDisplayed(groupNode.rowGroupColumn.getId()) : false);
-        if (displayGroupForCol) {
-          groupNode.groupData[col.getColId()] = groupInfo.key;
-        }
-      });
-    }
-  }, {
-    key: "getChildrenMappedKey",
-    value: function getChildrenMappedKey(key, rowGroupColumn) {
-      if (rowGroupColumn) {
-        // grouping by columns
-        return rowGroupColumn.getId() + '-' + key;
-      }
-      // tree data - we don't have rowGroupColumns
-      return key;
-    }
-  }, {
-    key: "setExpandedInitialValue",
-    value: function setExpandedInitialValue(details, groupNode) {
-      // if pivoting the leaf group is never expanded as we do not show leaf rows
-      if (details.pivotMode && groupNode.leafGroup) {
-        groupNode.expanded = false;
-        return;
-      }
-      // use callback if exists
-      var userCallback = this.gridOptionsService.getCallback('isGroupOpenByDefault');
-      if (userCallback) {
-        var params = {
-          rowNode: groupNode,
-          field: groupNode.field,
-          key: groupNode.key,
-          level: groupNode.level,
-          rowGroupColumn: groupNode.rowGroupColumn
-        };
-        groupNode.expanded = userCallback(params) == true;
-        return;
-      }
-      // use expandByDefault if exists
-      var expandByDefault = details.expandByDefault;
-      if (details.expandByDefault === -1) {
-        groupNode.expanded = true;
-        return;
-      }
-      // otherwise
-      groupNode.expanded = groupNode.level < expandByDefault;
-    }
-  }, {
-    key: "getGroupInfo",
-    value: function getGroupInfo(rowNode, details) {
-      if (this.usingTreeData) {
-        return this.getGroupInfoFromCallback(rowNode);
-      }
-      return this.getGroupInfoFromGroupColumns(rowNode, details);
-    }
-  }, {
-    key: "getGroupInfoFromCallback",
-    value: function getGroupInfoFromCallback(rowNode) {
-      var keys = this.getDataPath ? this.getDataPath(rowNode.data) : null;
-      if (keys === null || keys === undefined || keys.length === 0) {
-        _.doOnce(function () {
-          return console.warn("AG Grid: getDataPath() should not return an empty path for data", rowNode.data);
-        }, 'groupStage.getGroupInfoFromCallback');
-      }
-      var groupInfoMapper = function groupInfoMapper(key) {
-        return {
-          key: key,
-          field: null,
-          rowGroupColumn: null
-        };
-      };
-      return keys ? keys.map(groupInfoMapper) : [];
-    }
-  }, {
-    key: "getGroupInfoFromGroupColumns",
-    value: function getGroupInfoFromGroupColumns(rowNode, details) {
-      var _this11 = this;
-      var res = [];
-      details.groupedCols.forEach(function (groupCol) {
-        var key = _this11.valueService.getKeyForNode(groupCol, rowNode);
-        var keyExists = key !== null && key !== undefined && key !== '';
-        // unbalanced tree and pivot mode don't work together - not because of the grid, it doesn't make
-        // mathematical sense as you are building up a cube. so if pivot mode, we put in a blank key where missing.
-        // this keeps the tree balanced and hence can be represented as a group.
-        var createGroupForEmpty = details.pivotMode || !_this11.gridOptionsService.is('groupAllowUnbalanced');
-        if (createGroupForEmpty && !keyExists) {
-          key = '';
-          keyExists = true;
-        }
-        if (keyExists) {
-          var item = {
-            key: key,
-            field: groupCol.getColDef().field,
-            rowGroupColumn: groupCol
-          };
-          res.push(item);
-        }
-      });
-      return res;
-    }
-  }]);
-  return GroupStage;
-}(BeanStub);
-__decorate([Autowired('columnModel')], GroupStage.prototype, "columnModel", void 0);
-__decorate([Autowired('selectableService')], GroupStage.prototype, "selectableService", void 0);
-__decorate([Autowired('valueService')], GroupStage.prototype, "valueService", void 0);
-__decorate([Autowired('beans')], GroupStage.prototype, "beans", void 0);
-__decorate([Autowired('selectionService')], GroupStage.prototype, "selectionService", void 0);
-__decorate([PostConstruct], GroupStage.prototype, "postConstruct", null);
-GroupStage = __decorate([Bean('groupStage')], GroupStage);
-export { GroupStage };