@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/row-grouping/rowGrouping/groupStage.js

@@ -0,0 +1,814 @@
+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, 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 _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(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+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.gridOptionsWrapper.isTreeData();
+
+      if (this.usingTreeData) {
+        this.getDataPath = this.gridOptionsWrapper.getDataPathFunc();
+      }
+    }
+  }, {
+    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.positionLeafsAboveGroups(params.changedPath);
+      this.orderGroups(details.rootNode);
+      this.selectableService.updateSelectableAfterGrouping(details.rootNode);
+    }
+  }, {
+    key: "positionLeafsAboveGroups",
+    value: function positionLeafsAboveGroups(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 = [];
+          group.childrenAfterGroup.forEach(function (row) {
+            var _a;
+
+            if (!((_a = row.childrenAfterGroup) === null || _a === void 0 ? void 0 : _a.length)) {
+              leafNodes.push(row);
+            } else {
+              groupNodes.push(row);
+            }
+          });
+          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.gridOptionsWrapper.isSuppressParentsInRowNodes(),
+        expandByDefault: this.gridOptionsWrapper.getGroupDefaultExpanded(),
+        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.gridOptionsWrapper.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: "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); // 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.setSelected(false);
+            }
+          });
+        });
+        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.removeGroupsFromSelection();
+      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) {
+      var path = this.getGroupInfo(childNode, details);
+      var parentGroup = this.findParentForNode(childNode, path, details);
+
+      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) {
+      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
+
+        nextNode.allLeafChildren.push(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.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);
+      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.gridOptionsWrapper.getIsGroupOpenByDefaultFunc();
+
+      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; // 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.
+
+        if (details.pivotMode && !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 };