@eo-sdk/client 10.7.0-rc.5 → 11.0.0-beta.1

package/esm2022/app/eo-framework/grid/row-grouping/group-stage.mjs

@@ -0,0 +1,623 @@
+import { __decorate } from "tslib";
+import { _, Autowired, Bean, BeanStub, RowNode } from "@ag-grid-community/core";
+import { BatchRemover } from "./batchRemover";
+let GroupStage = class GroupStage extends BeanStub {
+    execute(params) {
+        const details = this.createGroupingDetails(params);
+        if (details.transactions) {
+            this.handleTransaction(details);
+        }
+        else {
+            const afterColsChanged = params.afterColumnsChanged === true;
+            this.shotgunResetEverything(details, afterColsChanged);
+        }
+        if (!details.usingTreeData) {
+            // we don't do group sorting for tree data
+            this.positionLeafsAndGroups(params.changedPath);
+            this.orderGroups(details);
+        }
+        this.selectableService.updateSelectableAfterGrouping();
+    }
+    positionLeafsAndGroups(changedPath) {
+        changedPath.forEachChangedNodeDepthFirst(group => {
+            if (group.childrenAfterGroup) {
+                const leafNodes = [];
+                const groupNodes = [];
+                let unbalancedNode;
+                group.childrenAfterGroup.forEach(row => {
+                    if (!row.childrenAfterGroup?.length) {
+                        leafNodes.push(row);
+                    }
+                    else {
+                        if (row.key === '' && !unbalancedNode) {
+                            unbalancedNode = row;
+                        }
+                        else {
+                            groupNodes.push(row);
+                        }
+                    }
+                });
+                if (unbalancedNode) {
+                    groupNodes.push(unbalancedNode);
+                }
+                group.childrenAfterGroup = [...leafNodes, ...groupNodes];
+            }
+        }, false);
+    }
+    createGroupingDetails(params) {
+        const { rowNode, changedPath, rowNodeTransactions, rowNodeOrder } = params;
+        const usingTreeData = this.gridOptionsService.get('treeData');
+        const groupedCols = usingTreeData ? null : this.columnModel.getRowGroupColumns();
+        const details = {
+            // someone complained that the parent attribute was causing some change detection
+            // to break in an angular add-on.  Taking the parent out breaks a cyclic dependency, hence this flag got introduced.
+            includeParents: !this.gridOptionsService.get('suppressParentsInRowNodes'),
+            expandByDefault: this.gridOptionsService.get('groupDefaultExpanded'),
+            groupedCols: groupedCols,
+            rootNode: rowNode,
+            pivotMode: this.columnModel.isPivotMode(),
+            groupedColCount: 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,
+            groupAllowUnbalanced: this.gridOptionsService.get('groupAllowUnbalanced'),
+            isGroupOpenByDefault: this.gridOptionsService.getCallback('isGroupOpenByDefault'),
+            initialGroupOrderComparator: this.gridOptionsService.getCallback('initialGroupOrderComparator'),
+            usingTreeData: usingTreeData,
+            suppressGroupMaintainValueType: this.gridOptionsService.get('suppressGroupMaintainValueType'),
+            getDataPath: usingTreeData ? this.gridOptionsService.get('getDataPath') : undefined,
+            keyCreators: groupedCols?.map(column => column.getColDef().keyCreator) ?? []
+        };
+        return details;
+    }
+    handleTransaction(details) {
+        details.transactions.forEach(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).
+            const batchRemover = !details.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)) {
+                this.removeNodes(tran.remove, details, batchRemover);
+            }
+            if (_.existsAndNotEmpty(tran.update)) {
+                this.moveNodesInWrongPath(tran.update, details, batchRemover);
+            }
+            if (_.existsAndNotEmpty(tran.add)) {
+                this.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) {
+                const parentsWithChildrenRemoved = batchRemover.getAllParents().slice();
+                batchRemover.flush();
+                this.removeEmptyGroups(parentsWithChildrenRemoved, details);
+            }
+        });
+        if (details.rowNodeOrder) {
+            this.sortChildren(details);
+        }
+    }
+    // this is used when doing delta updates, eg Redux, keeps nodes in right order
+    sortChildren(details) {
+        details.changedPath.forEachChangedNodeDepthFirst(node => {
+            if (!node.childrenAfterGroup) {
+                return;
+            }
+            const didSort = _.sortRowNodesByOrder(node.childrenAfterGroup, details.rowNodeOrder);
+            if (didSort) {
+                details.changedPath.addParentNode(node);
+            }
+        }, false, true);
+    }
+    orderGroups(details) {
+        const comparator = details.initialGroupOrderComparator;
+        if (_.exists(comparator)) {
+            recursiveSort(details.rootNode);
+        }
+        function recursiveSort(rowNode) {
+            const 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((nodeA, nodeB) => comparator({ nodeA, nodeB }));
+                rowNode.childrenAfterGroup.forEach((childNode) => recursiveSort(childNode));
+            }
+        }
+    }
+    getExistingPathForNode(node, details) {
+        const 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.
+        let pointer = details.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;
+    }
+    moveNodesInWrongPath(childNodes, details, batchRemover) {
+        childNodes.forEach(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);
+            }
+            const infoToKeyMapper = (item) => item.key;
+            const oldPath = this.getExistingPathForNode(childNode, details).map(infoToKeyMapper);
+            const newPath = this.getGroupInfo(childNode, details).map(infoToKeyMapper);
+            const nodeInCorrectPath = _.areEqual(oldPath, newPath);
+            if (!nodeInCorrectPath) {
+                this.moveNode(childNode, details, batchRemover);
+            }
+        });
+    }
+    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()) {
+            const newParent = childNode.parent;
+            details.changedPath.addParentNode(newParent);
+        }
+    }
+    removeNodes(leafRowNodes, details, batchRemover) {
+        this.removeNodesInStages(leafRowNodes, details, batchRemover);
+        if (details.changedPath.isActive()) {
+            leafRowNodes.forEach(rowNode => details.changedPath.addParentNode(rowNode.parent));
+        }
+    }
+    removeNodesInStages(leafRowNodes, details, batchRemover) {
+        this.removeNodesFromParents(leafRowNodes, details, batchRemover);
+        if (details.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.
+            const nodeParents = leafRowNodes.map(n => n.parent);
+            this.removeEmptyGroups(nodeParents, details);
+        }
+    }
+    forEachParentGroup(details, group, callback) {
+        let pointer = group;
+        while (pointer && pointer !== details.rootNode) {
+            callback(pointer);
+            pointer = pointer.parent;
+        }
+    }
+    removeNodesFromParents(nodesToRemove, details, provided) {
+        // 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.
+        const batchRemoverIsLocal = provided == null;
+        const batchRemoverToUse = provided ? provided : new BatchRemover();
+        nodesToRemove.forEach(nodeToRemove => {
+            this.removeFromParent(nodeToRemove, batchRemoverToUse);
+            // remove from allLeafChildren. we clear down all parents EXCEPT the Root Node, as
+            // the ClientSideNodeManager is responsible for the Root Node.
+            this.forEachParentGroup(details, nodeToRemove.parent, parentNode => {
+                batchRemoverToUse.removeFromAllLeafChildren(parentNode, nodeToRemove);
+            });
+        });
+        if (batchRemoverIsLocal) {
+            batchRemoverToUse.flush();
+        }
+    }
+    postRemoveCreateFillerNodes(nodesToRemove, details) {
+        nodesToRemove.forEach(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.
+            const replaceWithGroup = nodeToRemove.hasChildren();
+            if (replaceWithGroup) {
+                const oldPath = this.getExistingPathForNode(nodeToRemove, details);
+                // because we just removed the userGroup, this will always return new support group
+                const newGroupNode = this.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(rowNode => rowNode.parent = newGroupNode);
+            }
+        });
+    }
+    removeEmptyGroups(possibleEmptyGroups, details) {
+        // 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.
+        let checkAgain = true;
+        const groupShouldBeRemoved = (rowNode) => {
+            // because of the while loop below, it's possible we already moved the node,
+            // so double check before trying to remove again.
+            const mapKey = this.getChildrenMappedKey(rowNode.key, rowNode.rowGroupColumn);
+            const parentRowNode = rowNode.parent;
+            const 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();
+        };
+        while (checkAgain) {
+            checkAgain = false;
+            const batchRemover = new BatchRemover();
+            possibleEmptyGroups.forEach(possibleEmptyGroup => {
+                // remove empty groups
+                this.forEachParentGroup(details, possibleEmptyGroup, rowNode => {
+                    if (groupShouldBeRemoved(rowNode)) {
+                        checkAgain = true;
+                        this.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();
+        }
+    }
+    // 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.
+    removeFromParent(child, batchRemover) {
+        if (child.parent) {
+            if (batchRemover) {
+                batchRemover.removeFromChildrenAfterGroup(child.parent, child);
+            }
+            else {
+                _.removeFromArray(child.parent.childrenAfterGroup, child);
+                child.parent.updateHasChildren();
+            }
+        }
+        const 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);
+    }
+    addToParent(child, parent) {
+        const mapKey = this.getChildrenMappedKey(child.key, child.rowGroupColumn);
+        if (parent) {
+            const children = parent.childrenMapped != null;
+            if (children) {
+                parent.childrenMapped[mapKey] = child;
+            }
+            parent.childrenAfterGroup.push(child);
+            parent.updateHasChildren();
+        }
+    }
+    areGroupColsEqual(d1, d2) {
+        if (d1 == null || d2 == null || d1.pivotMode !== d2.pivotMode) {
+            return false;
+        }
+        return _.areEqual(d1.groupedCols, d2.groupedCols) && _.areEqual(d1.keyCreators, d2.keyCreators);
+    }
+    checkAllGroupDataAfterColsChanged(details) {
+        const recurse = (rowNodes) => {
+            if (!rowNodes) {
+                return;
+            }
+            rowNodes.forEach(rowNode => {
+                const isLeafNode = !details.usingTreeData && !rowNode.group;
+                if (isLeafNode) {
+                    return;
+                }
+                const groupInfo = {
+                    field: rowNode.field,
+                    key: rowNode.key,
+                    rowGroupColumn: rowNode.rowGroupColumn,
+                    leafNode: rowNode.allLeafChildren[0],
+                };
+                this.setGroupData(rowNode, groupInfo, details);
+                recurse(rowNode.childrenAfterGroup);
+            });
+        };
+        recurse(details.rootNode.childrenAfterGroup);
+    }
+    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((node) => node && !node.group);
+        const { rootNode, groupedCols } = details;
+        // 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 = details.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();
+        const sibling = rootNode.sibling;
+        if (sibling) {
+            sibling.childrenAfterGroup = rootNode.childrenAfterGroup;
+            sibling.childrenMapped = rootNode.childrenMapped;
+        }
+        this.insertNodes(rootNode.allLeafChildren, details, false);
+    }
+    noChangeInGroupingColumns(details, afterColumnsChanged) {
+        let noFurtherProcessingNeeded = false;
+        const groupDisplayColumns = this.columnModel.getGroupDisplayColumns();
+        const newGroupDisplayColIds = groupDisplayColumns ?
+            groupDisplayColumns.map(c => 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 = details.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;
+    }
+    insertNodes(newRowNodes, details, isMove) {
+        newRowNodes.forEach(rowNode => {
+            this.insertOneNode(rowNode, details, isMove);
+            if (details.changedPath.isActive()) {
+                details.changedPath.addParentNode(rowNode.parent);
+            }
+        });
+    }
+    insertOneNode(childNode, details, isMove, batchRemover) {
+        const path = this.getGroupInfo(childNode, details);
+        const 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 (details.usingTreeData) {
+            this.swapGroupWithUserNode(parentGroup, childNode, isMove);
+        }
+        else {
+            childNode.parent = parentGroup;
+            childNode.level = path.length;
+            parentGroup.childrenAfterGroup.push(childNode);
+            parentGroup.updateHasChildren();
+        }
+    }
+    findParentForNode(childNode, path, details, batchRemover) {
+        let nextNode = details.rootNode;
+        path.forEach((groupInfo, level) => {
+            nextNode = this.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?.isRemoveFromAllLeafChildren(nextNode, childNode)) {
+                nextNode.allLeafChildren.push(childNode);
+            }
+            else {
+                // if this node is about to be removed, prevent that
+                batchRemover?.preventRemoveFromAllLeafChildren(nextNode, childNode);
+            }
+        });
+        return nextNode;
+    }
+    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((rowNode) => rowNode.parent = userGroup);
+        this.addToParent(userGroup, fillerGroup.parent);
+    }
+    getOrCreateNextNode(parentGroup, groupInfo, level, details) {
+        const key = this.getChildrenMappedKey(groupInfo.key, groupInfo.rowGroupColumn);
+        let 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;
+    }
+    createGroup(groupInfo, parent, level, details) {
+        const groupNode = new RowNode(this.beans);
+        groupNode.group = true;
+        groupNode.field = groupInfo.field;
+        groupNode.rowGroupColumn = groupInfo.rowGroupColumn;
+        this.setGroupData(groupNode, groupInfo, details);
+        groupNode.key = groupInfo.key;
+        groupNode.id = this.createGroupId(groupNode, parent, details.usingTreeData, level);
+        groupNode.level = level;
+        groupNode.leafGroup = details.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 = details.usingTreeData ? null : level;
+        groupNode.childrenAfterGroup = [];
+        groupNode.childrenMapped = {};
+        groupNode.updateHasChildren();
+        groupNode.parent = details.includeParents ? parent : null;
+        this.setExpandedInitialValue(details, groupNode);
+        return groupNode;
+    }
+    createGroupId(node, parent, usingTreeData, level) {
+        let createGroupId;
+        if (usingTreeData) {
+            createGroupId = (node, parent, level) => {
+                if (level < 0) {
+                    return null;
+                } // root node
+                const parentId = parent ? createGroupId(parent, parent.parent, level - 1) : null;
+                return `${parentId == null ? '' : parentId + '-'}${level}-${node.key}`;
+            };
+        }
+        else {
+            createGroupId = (node, parent) => {
+                if (!node.rowGroupColumn) {
+                    return null;
+                } // root node
+                const parentId = parent ? createGroupId(parent, parent.parent, 0) : null;
+                return `${parentId == null ? '' : parentId + '-'}${node.rowGroupColumn.getColId()}-${node.key}`;
+            };
+        }
+        // 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.
+        return RowNode.ID_PREFIX_ROW_GROUP + createGroupId(node, parent, level);
+    }
+    setGroupData(groupNode, groupInfo, details) {
+        groupNode.groupData = {};
+        const groupDisplayCols = this.columnModel.getGroupDisplayColumns();
+        groupDisplayCols.forEach(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
+            const isTreeData = details.usingTreeData;
+            if (isTreeData) {
+                groupNode.groupData[col.getColId()] = groupInfo.key;
+                return;
+            }
+            const groupColumn = groupNode.rowGroupColumn;
+            const isRowGroupDisplayed = groupColumn !== null && col.isRowGroupDisplayed(groupColumn.getId());
+            if (isRowGroupDisplayed) {
+                if (details.suppressGroupMaintainValueType) {
+                    groupNode.groupData[col.getColId()] = groupInfo.key;
+                }
+                else {
+                    // if maintain group value type, get the value from any leaf node.
+                    groupNode.groupData[col.getColId()] = this.valueService.getValue(groupColumn, groupInfo.leafNode);
+                }
+            }
+        });
+    }
+    getChildrenMappedKey(key, rowGroupColumn) {
+        if (rowGroupColumn) {
+            // grouping by columns
+            return rowGroupColumn.getId() + '-' + key;
+        }
+        // tree data - we don't have rowGroupColumns
+        return key;
+    }
+    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
+        const userCallback = details.isGroupOpenByDefault;
+        if (userCallback) {
+            const 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
+        const { expandByDefault } = details;
+        if (details.expandByDefault === -1) {
+            groupNode.expanded = true;
+            return;
+        }
+        // otherwise
+        groupNode.expanded = groupNode.level < expandByDefault;
+    }
+    getGroupInfo(rowNode, details) {
+        if (details.usingTreeData) {
+            return this.getGroupInfoFromCallback(rowNode, details);
+        }
+        return this.getGroupInfoFromGroupColumns(rowNode, details);
+    }
+    getGroupInfoFromCallback(rowNode, details) {
+        const keys = details.getDataPath ? details.getDataPath(rowNode.data) : null;
+        if (keys === null || keys === undefined || keys.length === 0) {
+            _.warnOnce(`getDataPath() should not return an empty path for data ${rowNode.data}`);
+        }
+        const groupInfoMapper = (key) => ({ key, field: null, rowGroupColumn: null });
+        return keys ? keys.map(groupInfoMapper) : [];
+    }
+    getGroupInfoFromGroupColumns(rowNode, details) {
+        const res = [];
+        details.groupedCols.forEach(groupCol => {
+            let key = this.valueService.getKeyForNode(groupCol, rowNode);
+            let 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.
+            const createGroupForEmpty = details.pivotMode || !details.groupAllowUnbalanced;
+            if (createGroupForEmpty && !keyExists) {
+                key = '';
+                keyExists = true;
+            }
+            if (keyExists) {
+                const item = {
+                    key: key,
+                    field: groupCol.getColDef().field,
+                    rowGroupColumn: groupCol,
+                    leafNode: rowNode,
+                };
+                res.push(item);
+            }
+        });
+        return res;
+    }
+};
+__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);
+GroupStage = __decorate([
+    Bean('groupStage')
+], GroupStage);
+export { GroupStage };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"group-stage.js","sourceRoot":"","sources":["../../../../../../../../src/app/eo-framework/grid/row-grouping/group-stage.ts"],"names":[],"mappings":";AAAA,OAAO,EACH,CAAC,EACD,SAAS,EACT,IAAI,EACJ,QAAQ,EAOR,OAAO,EAWV,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA+BvC,IAAM,UAAU,GAAhB,MAAM,UAAW,SAAQ,QAAQ;IAiB7B,OAAO,CAAC,MAA0B;QAErC,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAEnD,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YACvB,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;aAAM,CAAC;YACJ,MAAM,gBAAgB,GAAG,MAAM,CAAC,mBAAmB,KAAK,IAAI,CAAC;YAC7D,IAAI,CAAC,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAC3D,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;YACzB,0CAA0C;YAC1C,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,WAAY,CAAC,CAAC;YACjD,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;QAED,IAAI,CAAC,iBAAiB,CAAC,6BAA6B,EAAE,CAAC;IAC3D,CAAC;IAEO,sBAAsB,CAAC,WAAwB;QACnD,WAAW,CAAC,4BAA4B,CAAC,KAAK,CAAC,EAAE;YAC7C,IAAI,KAAK,CAAC,kBAAkB,EAAE,CAAC;gBAC3B,MAAM,SAAS,GAAc,EAAE,CAAC;gBAChC,MAAM,UAAU,GAAc,EAAE,CAAC;gBACjC,IAAI,cAAmC,CAAC;gBAExC,KAAK,CAAC,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;oBACnC,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,MAAM,EAAE,CAAC;wBAClC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACxB,CAAC;yBAAM,CAAC;wBACJ,IAAI,GAAG,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC;4BACpC,cAAc,GAAG,GAAG,CAAC;wBACzB,CAAC;6BAAM,CAAC;4BACJ,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wBACzB,CAAC;oBACL,CAAC;gBACL,CAAC,CAAC,CAAC;gBAEH,IAAI,cAAc,EAAE,CAAC;oBACjB,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBACpC,CAAC;gBAED,KAAK,CAAC,kBAAkB,GAAG,CAAC,GAAG,SAAS,EAAE,GAAG,UAAU,CAAC,CAAC;YAC7D,CAAC;QACL,CAAC,EAAE,KAAK,CAAC,CAAC;IACd,CAAC;IAEO,qBAAqB,CAAC,MAA0B;QACpD,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;QAE3E,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAE9D,MAAM,WAAW,GAAG,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;QAEjF,MAAM,OAAO,GAAoB;YAC7B,iFAAiF;YACjF,oHAAoH;YACpH,cAAc,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,2BAA2B,CAAC;YACzE,eAAe,EAAE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,sBAAsB,CAAC;YACpE,WAAW,EAAE,WAAY;YACzB,QAAQ,EAAE,OAAO;YACjB,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE;YACzC,eAAe,EAAE,aAAa,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM;YACvE,YAAY,EAAE,YAAa;YAC3B,YAAY,EAAE,mBAAoB;YAClC,gGAAgG;YAChG,WAAW,EAAE,WAAY;YACzB,oBAAoB,EAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,sBAAsB,CAAC;YAC1E,oBAAoB,EAAE,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,sBAAsB,CAAQ;YACxF,2BAA2B,EAAE,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,6BAA6B,CAAQ;YACtG,aAAa,EAAE,aAAa;YAC5B,8BAA8B,EAAE,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,gCAAgC,CAAC;YAC7F,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,SAAS;YACnF,WAAW,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,IAAI,EAAE;SAC/E,CAAC;QAEF,OAAO,OAAO,CAAC;IACnB,CAAC;IAEO,iBAAiB,CAAC,OAAwB;QAE9C,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YAChC,6EAA6E;YAC7E,kFAAkF;YAClF,iFAAiF;YACjF,sFAAsF;YACtF,uFAAuF;YACvF,MAAM,YAAY,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,YAAY,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;YAE7E,4FAA4F;YAC5F,4FAA4F;YAC5F,eAAe;YACf,IAAI,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACnC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAmB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACnC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAmB,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;YAC/E,CAAC;YACD,IAAI,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAChC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,GAAgB,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;YAC5D,CAAC;YACD,oEAAoE;YACpE,0EAA0E;YAC1E,IAAI,YAAY,EAAE,CAAC;gBACf,MAAM,0BAA0B,GAAG,YAAY,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,CAAC;gBACxE,YAAY,CAAC,KAAK,EAAE,CAAC;gBACrB,IAAI,CAAC,iBAAiB,CAAC,0BAA0B,EAAE,OAAO,CAAC,CAAC;YAChE,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YACvB,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;IACL,CAAC;IAED,8EAA8E;IACtE,YAAY,CAAC,OAAwB;QACzC,OAAO,CAAC,WAAW,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE;YACpD,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC3B,OAAO;YACX,CAAC;YAED,MAAM,OAAO,GAAG,CAAC,CAAC,mBAAmB,CAAC,IAAI,CAAC,kBAAmB,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;YACtF,IAAI,OAAO,EAAE,CAAC;gBACV,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC5C,CAAC;QACL,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACpB,CAAC;IAEO,WAAW,CAAC,OAAwB;QACxC,MAAM,UAAU,GAAG,OAAO,CAAC,2BAA2B,CAAC;QACvD,IAAI,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;YAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAAC,CAAC;QAE9D,SAAS,aAAa,CAAC,OAAgB;YACnC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,kBAAkB,CAAC;gBAC/C,4FAA4F;gBAC5F,CAAC,OAAO,CAAC,SAAS,CAAC;YAEvB,IAAI,MAAM,EAAE,CAAC;gBACT,OAAO,CAAC,kBAAmB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,UAAW,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;gBAClF,OAAO,CAAC,kBAAmB,CAAC,OAAO,CAAC,CAAC,SAAkB,EAAE,EAAE,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;YAC1F,CAAC;QACL,CAAC;IACL,CAAC;IAEO,sBAAsB,CAAC,IAAa,EAAE,OAAwB;QAClE,MAAM,GAAG,GAAgB,EAAE,CAAC;QAE5B,sDAAsD;QACtD,8FAA8F;QAC9F,IAAI,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;QACzD,OAAO,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC7C,GAAG,CAAC,IAAI,CAAC;gBACL,GAAG,EAAE,OAAO,CAAC,GAAI;gBACjB,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,KAAK,EAAE,OAAO,CAAC,KAAK;aACvB,CAAC,CAAC;YACH,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,CAAC;QACD,GAAG,CAAC,OAAO,EAAE,CAAC;QACd,OAAO,GAAG,CAAC;IACf,CAAC;IAEO,oBAAoB,CAAC,UAAqB,EAAE,OAAwB,EAAE,YAAsC;QAChH,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YAE3B,sEAAsE;YACtE,4CAA4C;YAC5C,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACjC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACxD,CAAC;YAED,MAAM,eAAe,GAAG,CAAC,IAAe,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;YACtD,MAAM,OAAO,GAAa,IAAI,CAAC,sBAAsB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAC/F,MAAM,OAAO,GAAa,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAErF,MAAM,iBAAiB,GAAG,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAEvD,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACrB,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,QAAQ,CAAC,SAAkB,EAAE,OAAwB,EAAE,YAAsC;QAEjG,IAAI,CAAC,mBAAmB,CAAC,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QAC7D,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;QAE3D,gGAAgG;QAChG,0BAA0B;QAC1B,yFAAyF;QACzF,+FAA+F;QAC/F,mDAAmD;QACnD,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAElC,sFAAsF;QACtF,uFAAuF;QACvF,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjC,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC;YACnC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QACjD,CAAC;IACL,CAAC;IAEO,WAAW,CAAC,YAAuB,EAAE,OAAwB,EAAE,YAAsC;QACzG,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QAC9D,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QACvF,CAAC;IACL,CAAC;IAEO,mBAAmB,CAAC,YAAuB,EAAE,OAAwB,EAAE,YAAsC;QACjH,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QACjE,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,2BAA2B,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;YAExD,+FAA+F;YAC/F,6FAA6F;YAC7F,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAO,CAAC,CAAC;YACrD,IAAI,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,OAAwB,EAAE,KAAc,EAAE,QAAmC;QACpG,IAAI,OAAO,GAAmB,KAAK,CAAC;QACpC,OAAO,OAAO,IAAI,OAAO,KAAK,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC7C,QAAQ,CAAC,OAAO,CAAC,CAAC;YAClB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,CAAC;IACL,CAAC;IAEO,sBAAsB,CAAC,aAAwB,EAAE,OAAwB,EAAE,QAAkC;QACjH,uGAAuG;QACvG,yGAAyG;QACzG,MAAM,mBAAmB,GAAG,QAAQ,IAAI,IAAI,CAAC;QAC7C,MAAM,iBAAiB,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,YAAY,EAAE,CAAC;QAEnE,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YACjC,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC;YAEvD,kFAAkF;YAClF,8DAA8D;YAC9D,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,YAAY,CAAC,MAAO,EAAE,UAAU,CAAC,EAAE;gBAChE,iBAAiB,CAAC,yBAAyB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;YAC1E,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,IAAI,mBAAmB,EAAE,CAAC;YACtB,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAC9B,CAAC;IACL,CAAC;IAEO,2BAA2B,CAAC,aAAwB,EAAE,OAAwB;QAClF,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;YAEjC,4EAA4E;YAC5E,kEAAkE;YAClE,MAAM,gBAAgB,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;YACpD,IAAI,gBAAgB,EAAE,CAAC;gBACnB,MAAM,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;gBACnE,mFAAmF;gBACnF,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;gBAE5E,mFAAmF;gBACnF,sCAAsC;gBACtC,YAAY,CAAC,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;gBAC9C,YAAY,CAAC,eAAe,GAAG,YAAY,CAAC,eAAe,CAAC;gBAC5D,YAAY,CAAC,kBAAkB,GAAG,YAAY,CAAC,kBAAkB,CAAC;gBAClE,YAAY,CAAC,cAAc,GAAG,YAAY,CAAC,cAAc,CAAC;gBAC1D,YAAY,CAAC,iBAAiB,EAAE,CAAC;gBAEjC,YAAY,CAAC,kBAAmB,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;YACvF,CAAC;QAEL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,iBAAiB,CAAC,mBAA8B,EAAE,OAAwB;QAC9E,6FAA6F;QAC7F,gGAAgG;QAChG,kGAAkG;QAClG,IAAI,UAAU,GAAG,IAAI,CAAC;QAEtB,MAAM,oBAAoB,GAAG,CAAC,OAAgB,EAAW,EAAE;YAEvD,4EAA4E;YAC5E,iDAAiD;YACjD,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAI,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;YAC/E,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;YACrC,MAAM,mBAAmB,GAAG,CAAC,aAAa,IAAI,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC;gBACzE,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAEjD,IAAI,mBAAmB,EAAE,CAAC;gBACtB,gDAAgD;gBAChD,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,8DAA8D;YAC9D,OAAO,CAAC,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;QAC3C,CAAC,CAAC;QAEF,OAAO,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,KAAK,CAAC;YACnB,MAAM,YAAY,GAAiB,IAAI,YAAY,EAAE,CAAC;YACtD,mBAAmB,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE;gBAC7C,sBAAsB;gBACtB,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE;oBAC3D,IAAI,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;wBAChC,UAAU,GAAG,IAAI,CAAC;wBAClB,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;wBAC7C,kFAAkF;wBAClF,6EAA6E;wBAC7E,OAAO,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;oBAC9E,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;YACH,YAAY,CAAC,KAAK,EAAE,CAAC;QACzB,CAAC;IACL,CAAC;IAED,uCAAuC;IACvC,6FAA6F;IAC7F,gDAAgD;IAChD,4FAA4F;IAC5F,qEAAqE;IAC7D,gBAAgB,CAAC,KAAc,EAAE,YAA2B;QAChE,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACf,IAAI,YAAY,EAAE,CAAC;gBACf,YAAY,CAAC,4BAA4B,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACnE,CAAC;iBAAM,CAAC;gBACJ,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,kBAAmB,EAAE,KAAK,CAAC,CAAC;gBAC3D,KAAK,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;YACrC,CAAC;QACL,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QAC3E,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;YAC9C,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;QACpD,CAAC;QACD,+FAA+F;QAC/F,mFAAmF;QACnF,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACtB,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAEO,WAAW,CAAC,KAAc,EAAE,MAAsB;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QAC3E,IAAI,MAAM,EAAE,CAAC;YACT,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,IAAI,IAAI,CAAC;YAC/C,IAAI,QAAQ,EAAE,CAAC;gBACX,MAAM,CAAC,cAAe,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC;YAC3C,CAAC;YACD,MAAM,CAAC,kBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACvC,MAAM,CAAC,iBAAiB,EAAE,CAAC;QAC/B,CAAC;IACL,CAAC;IAEO,iBAAiB,CAAC,EAAmB,EAAE,EAAmB;QAC9D,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS,EAAE,CAAC;YAAC,OAAO,KAAK,CAAC;QAAC,CAAC;QAEhF,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC;IACpG,CAAC;IAEO,iCAAiC,CAAC,OAAwB;QAE9D,MAAM,OAAO,GAAG,CAAC,QAA0B,EAAE,EAAE;YAC3C,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAAC,OAAO;YAAC,CAAC;YAC1B,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;gBACvB,MAAM,UAAU,GAAG,CAAC,OAAO,CAAC,aAAa,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC5D,IAAI,UAAU,EAAE,CAAC;oBAAC,OAAO;gBAAC,CAAC;gBAC3B,MAAM,SAAS,GAAc;oBACzB,KAAK,EAAE,OAAO,CAAC,KAAK;oBACpB,GAAG,EAAE,OAAO,CAAC,GAAI;oBACjB,cAAc,EAAE,OAAO,CAAC,cAAc;oBACtC,QAAQ,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC;iBACvC,CAAC;gBACF,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;gBAC/C,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;YACxC,CAAC,CAAC,CAAC;QACP,CAAC,CAAC;QAEF,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;IACjD,CAAC;IAEO,sBAAsB,CAAC,OAAwB,EAAE,mBAA4B;QAEjF,IAAI,IAAI,CAAC,yBAAyB,CAAC,OAAO,EAAE,mBAAmB,CAAC,EAAE,CAAC;YAC/D,OAAO;QACX,CAAC;QAED,8EAA8E;QAC9E,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAElF,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;QAC1C,yEAAyE;QACzE,iCAAiC;QACjC,mGAAmG;QACnG,8FAA8F;QAC9F,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC;QAE9E,yGAAyG;QACzG,QAAQ,CAAC,kBAAkB,GAAG,EAAE,CAAC;QACjC,QAAQ,CAAC,cAAc,GAAG,EAAE,CAAC;QAC7B,QAAQ,CAAC,iBAAiB,EAAE,CAAC;QAE7B,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC;QACjC,IAAI,OAAO,EAAE,CAAC;YACV,OAAO,CAAC,kBAAkB,GAAG,QAAQ,CAAC,kBAAkB,CAAC;YACzD,OAAO,CAAC,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC;QACrD,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,yBAAyB,CAAC,OAAwB,EAAE,mBAA4B;QACpF,IAAI,yBAAyB,GAAG,KAAK,CAAC;QAEtC,MAAM,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC,sBAAsB,EAAE,CAAC;QACtE,MAAM,qBAAqB,GAAG,mBAAmB,CAAC,CAAC;YAC/C,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAE3D,IAAI,mBAAmB,EAAE,CAAC;YACtB,4EAA4E;YAC5E,mCAAmC;YACnC,yBAAyB,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAE9G,mFAAmF;YACnF,4CAA4C;YAC5C,IAAI,IAAI,CAAC,qBAAqB,KAAK,qBAAqB,EAAE,CAAC;gBACvD,IAAI,CAAC,iCAAiC,CAAC,OAAO,CAAC,CAAC;YACpD,CAAC;QACL,CAAC;QAED,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC;QAClC,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QAEnD,OAAO,yBAAyB,CAAC;IACrC,CAAC;IAEO,WAAW,CAAC,WAAsB,EAAE,OAAwB,EAAE,MAAe;QACjF,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YAC1B,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAC7C,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACjC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACtD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,aAAa,CAAC,SAAkB,EAAE,OAAwB,EAAE,MAAe,EAAE,YAA2B;QAE5G,MAAM,IAAI,GAAgB,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAEhE,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QACnF,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,mEAAmE,EAC5E,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QAC/D,CAAC;aAAM,CAAC;YACJ,SAAS,CAAC,MAAM,GAAG,WAAW,CAAC;YAC/B,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;YAC9B,WAAW,CAAC,kBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAChD,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACpC,CAAC;IACL,CAAC;IAEO,iBAAiB,CAAC,SAAkB,EAAE,IAAiB,EAAE,OAAwB,EAAE,YAA2B;QAClH,IAAI,QAAQ,GAAY,OAAO,CAAC,QAAQ,CAAC;QAEzC,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE;YAC9B,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACzE,sCAAsC;YACtC,uFAAuF;YAEvF,IAAI,CAAC,YAAY,EAAE,2BAA2B,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,CAAC;gBAClE,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC7C,CAAC;iBAAM,CAAC;gBACJ,oDAAoD;gBACpD,YAAY,EAAE,gCAAgC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;YACxE,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEO,qBAAqB,CAAC,WAAoB,EAAE,SAAkB,EAAE,MAAe;QACnF,SAAS,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;QACtC,SAAS,CAAC,GAAG,GAAG,WAAW,CAAC,GAAG,CAAC;QAChC,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;QACpC,SAAS,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;QAC5C,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;QACpC,0FAA0F;QAC1F,oFAAoF;QACpF,IAAI,CAAC,MAAM,EAAE,CAAC;YACV,SAAS,CAAC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;QAC9C,CAAC;QAED,mGAAmG;QACnG,8FAA8F;QAC9F,SAAS,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;QAE5C,kFAAkF;QAClF,SAAS,CAAC,aAAa,GAAG,WAAW,CAAC,aAAa,CAAC;QAEpD,SAAS,CAAC,eAAe,GAAG,WAAW,CAAC,eAAe,CAAC;QACxD,SAAS,CAAC,kBAAkB,GAAG,WAAW,CAAC,kBAAkB,CAAC;QAC9D,SAAS,CAAC,cAAc,GAAG,WAAW,CAAC,cAAc,CAAC;QACtD,SAAS,CAAC,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;QACxC,SAAS,CAAC,iBAAiB,EAAE,CAAC;QAE9B,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;QACnC,SAAS,CAAC,kBAAmB,CAAC,OAAO,CAAC,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;QACxF,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACpD,CAAC;IAEO,mBAAmB,CAAC,WAAoB,EAAE,SAAoB,EAAE,KAAa,EACjF,OAAwB;QAExB,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;QAC/E,IAAI,QAAQ,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAExF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;YACpE,qCAAqC;YACrC,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;QAC5C,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEO,WAAW,CAAC,SAAoB,EAAE,MAAe,EAAE,KAAa,EAAE,OAAwB;QAC9F,MAAM,SAAS,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE1C,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC;QACvB,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;QAClC,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,CAAC;QAEpD,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAEjD,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC;QAC9B,SAAS,CAAC,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QAEnF,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC;QACxB,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,OAAO,CAAC,eAAe,GAAG,CAAC,CAAC,CAAC;QAE9F,SAAS,CAAC,eAAe,GAAG,EAAE,CAAC;QAE/B,0EAA0E;QAC1E,gDAAgD;QAChD,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;QAEjC,SAAS,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;QAE/D,SAAS,CAAC,kBAAkB,GAAG,EAAE,CAAC;QAClC,SAAS,CAAC,cAAc,GAAG,EAAE,CAAC;QAC9B,SAAS,CAAC,iBAAiB,EAAE,CAAC;QAE9B,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAE1D,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAEjD,OAAO,SAAS,CAAC;IACrB,CAAC;IAEO,aAAa,CAAC,IAAa,EAAE,MAAe,EAAE,aAAsB,EAAE,KAAa;QACvF,IAAI,aAAsF,CAAC;QAC3F,IAAI,aAAa,EAAE,CAAC;YAChB,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE;gBACpC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;oBAAC,OAAO,IAAI,CAAC;gBAAC,CAAC,CAAC,YAAY;gBAC5C,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACjF,OAAO,GAAG,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YAC3E,CAAC,CAAC;QACN,CAAC;aAAM,CAAC;YACJ,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;gBAC7B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;oBAAC,OAAO,IAAI,CAAC;gBAAC,CAAC,CAAC,YAAY;gBACvD,MAAM,QAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBACzE,OAAO,GAAG,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACpG,CAAC,CAAC;QACN,CAAC;QAED,iHAAiH;QACjH,yCAAyC;QACzC,OAAO,OAAO,CAAC,mBAAmB,GAAG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAC5E,CAAC;IAEO,YAAY,CAAC,SAAkB,EAAE,SAAoB,EAAE,OAAwB;QACnF,SAAS,CAAC,SAAS,GAAG,EAAE,CAAC;QACzB,MAAM,gBAAgB,GAAa,IAAI,CAAC,WAAW,CAAC,sBAAsB,EAAE,CAAC;QAC7E,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAC3B,+GAA+G;YAC/G,yGAAyG;YACzG,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC;YACzC,IAAI,UAAU,EAAE,CAAC;gBACb,SAAS,CAAC,SAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC;gBACrD,OAAO;YACX,CAAC;YAED,MAAM,WAAW,GAAG,SAAS,CAAC,cAAc,CAAC;YAC7C,MAAM,mBAAmB,GAAG,WAAW,KAAK,IAAI,IAAI,GAAG,CAAC,mBAAmB,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;YACjG,IAAI,mBAAmB,EAAE,CAAC;gBACtB,IAAI,OAAO,CAAC,8BAA8B,EAAE,CAAC;oBACzC,SAAS,CAAC,SAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC;gBACzD,CAAC;qBAAM,CAAC;oBACJ,kEAAkE;oBAClE,SAAS,CAAC,SAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;gBACvG,CAAC;YACL,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,oBAAoB,CAAC,GAAW,EAAE,cAA6B;QACnE,IAAI,cAAc,EAAE,CAAC;YACjB,sBAAsB;YACtB,OAAO,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9C,CAAC;QACD,4CAA4C;QAC5C,OAAO,GAAG,CAAC;IACf,CAAC;IAEO,uBAAuB,CAAC,OAAwB,EAAE,SAAkB;QACxE,2EAA2E;QAC3E,IAAI,OAAO,CAAC,SAAS,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;YAC3C,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC;YAC3B,OAAO;QACX,CAAC;QAED,yBAAyB;QACzB,MAAM,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC;QAClD,IAAI,YAAY,EAAE,CAAC;YACf,MAAM,MAAM,GAAkD;gBAC1D,OAAO,EAAE,SAAS;gBAClB,KAAK,EAAE,SAAS,CAAC,KAAM;gBACvB,GAAG,EAAE,SAAS,CAAC,GAAI;gBACnB,KAAK,EAAE,SAAS,CAAC,KAAK;gBACtB,cAAc,EAAE,SAAS,CAAC,cAAe;aAC5C,CAAC;YACF,SAAS,CAAC,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;YAClD,OAAO;QACX,CAAC;QAED,gCAAgC;QAChC,MAAM,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;QACpC,IAAI,OAAO,CAAC,eAAe,KAAK,CAAC,CAAC,EAAE,CAAC;YACjC,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC;YAC1B,OAAO;QACX,CAAC;QAED,YAAY;QACZ,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,KAAK,GAAG,eAAe,CAAC;IAC3D,CAAC;IAEO,YAAY,CAAC,OAAgB,EAAE,OAAwB;QAC3D,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC3D,CAAC;QACD,OAAO,IAAI,CAAC,4BAA4B,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IAEO,wBAAwB,CAAC,OAAgB,EAAE,OAAwB;QACvE,MAAM,IAAI,GAAoB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAE7F,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3D,CAAC,CAAC,QAAQ,CAAC,0DAA0D,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QACzF,CAAC;QACD,MAAM,eAAe,GAAG,CAAC,GAAkB,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,CAAc,CAAC;QAC1G,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACjD,CAAC;IAEO,4BAA4B,CAAC,OAAgB,EAAE,OAAwB;QAC3E,MAAM,GAAG,GAAgB,EAAE,CAAC;QAC5B,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YACnC,IAAI,GAAG,GAAW,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YACrE,IAAI,SAAS,GAAG,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,EAAE,CAAC;YAEhE,gGAAgG;YAChG,2GAA2G;YAC3G,wEAAwE;YACxE,MAAM,mBAAmB,GAAG,OAAO,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC;YAC/E,IAAI,mBAAmB,IAAI,CAAC,SAAS,EAAE,CAAC;gBACpC,GAAG,GAAG,EAAE,CAAC;gBACT,SAAS,GAAG,IAAI,CAAC;YACrB,CAAC;YAED,IAAI,SAAS,EAAE,CAAC;gBACZ,MAAM,IAAI,GAAG;oBACT,GAAG,EAAE,GAAG;oBACR,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK;oBACjC,cAAc,EAAE,QAAQ;oBACxB,QAAQ,EAAE,OAAO;iBACP,CAAC;gBACf,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnB,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACf,CAAC;CACJ,CAAA;AAvsBqC;IAAjC,SAAS,CAAC,aAAa,CAAC;+CAAkC;AACnB;IAAvC,SAAS,CAAC,mBAAmB,CAAC;qDAA8C;AAC1C;IAAlC,SAAS,CAAC,cAAc,CAAC;gDAAoC;AAClC;IAA3B,SAAS,CAAC,OAAO,CAAC;yCAAsB;AACF;IAAtC,SAAS,CAAC,kBAAkB,CAAC;oDAA6C;AANlE,UAAU;IADtB,IAAI,CAAC,YAAY,CAAC;GACN,UAAU,CAysBtB","sourcesContent":["import {\n    _,\n    Autowired,\n    Bean,\n    BeanStub,\n    ChangedPath,\n    Column,\n    ColumnModel,\n    GetDataPath,\n    IRowNodeStage,\n    IsGroupOpenByDefaultParams,\n    RowNode,\n    RowNodeTransaction,\n    SelectableService,\n    StageExecuteParams,\n    ValueService,\n    Beans,\n    ISelectionService,\n    WithoutGridCommon,\n    InitialGroupOrderComparatorParams,\n    GridOptions,\n    KeyCreatorParams\n} from \"@ag-grid-community/core\";\nimport { BatchRemover } from \"./batchRemover\";\n\ninterface GroupInfo {\n    key: string; // e.g. 'Ireland'\n    field: string | null; // e.g. 'country'\n    rowGroupColumn: Column | null;\n    leafNode?: RowNode;\n}\n\ninterface GroupingDetails {\n    pivotMode: boolean;\n    includeParents: boolean;\n    expandByDefault: number;\n    changedPath: ChangedPath;\n    rootNode: RowNode;\n    groupedCols: Column[];\n    groupedColCount: number;\n    transactions: RowNodeTransaction[];\n    rowNodeOrder: { [id: string]: number; };\n    \n    groupAllowUnbalanced: boolean;\n    isGroupOpenByDefault: (params: WithoutGridCommon<IsGroupOpenByDefaultParams>) => boolean;\n    initialGroupOrderComparator: (params: WithoutGridCommon<InitialGroupOrderComparatorParams>) => number;\n    \n    usingTreeData: boolean;\n    suppressGroupMaintainValueType: boolean;\n    getDataPath: GetDataPath | undefined;\n    keyCreators: (((params: KeyCreatorParams) => string) | undefined)[];\n}\n\n@Bean('groupStage')\nexport class GroupStage extends BeanStub implements IRowNodeStage {\n\n    @Autowired('columnModel') private columnModel: ColumnModel;\n    @Autowired('selectableService') private selectableService: SelectableService;\n    @Autowired('valueService') private valueService: ValueService;\n    @Autowired('beans') private beans: Beans;\n    @Autowired('selectionService') private selectionService: ISelectionService;\n\n    // when grouping, these items are of note:\n    // rowNode.parent: RowNode: set to the parent\n    // rowNode.childrenAfterGroup: RowNode[] = the direct children of this group\n    // rowNode.childrenMapped: string=>RowNode = children mapped by group key (when groups) or an empty map if leaf group (this is then used by pivot)\n    // for leaf groups, rowNode.childrenAfterGroup = rowNode.allLeafChildren;\n\n    private oldGroupingDetails: GroupingDetails;\n    private oldGroupDisplayColIds: string;\n\n    public execute(params: StageExecuteParams): void {\n\n        const details = this.createGroupingDetails(params);\n\n        if (details.transactions) {\n            this.handleTransaction(details);\n        } else {\n            const afterColsChanged = params.afterColumnsChanged === true;\n            this.shotgunResetEverything(details, afterColsChanged);\n        }\n\n        if (!details.usingTreeData) {\n            // we don't do group sorting for tree data\n            this.positionLeafsAndGroups(params.changedPath!);\n            this.orderGroups(details);\n        }\n\n        this.selectableService.updateSelectableAfterGrouping();\n    }\n\n    private positionLeafsAndGroups(changedPath: ChangedPath) {\n        changedPath.forEachChangedNodeDepthFirst(group => {\n            if (group.childrenAfterGroup) {\n                const leafNodes: RowNode[] = [];\n                const groupNodes: RowNode[] = [];\n                let unbalancedNode: RowNode | undefined;\n\n                group.childrenAfterGroup.forEach(row => {\n                    if (!row.childrenAfterGroup?.length) {\n                        leafNodes.push(row);\n                    } else {\n                        if (row.key === '' && !unbalancedNode) {\n                            unbalancedNode = row;\n                        } else {\n                            groupNodes.push(row);\n                        }\n                    }\n                });\n\n                if (unbalancedNode) {\n                    groupNodes.push(unbalancedNode);\n                }\n                \n                group.childrenAfterGroup = [...leafNodes, ...groupNodes];\n            }\n        }, false);\n    }\n\n    private createGroupingDetails(params: StageExecuteParams): GroupingDetails {\n        const { rowNode, changedPath, rowNodeTransactions, rowNodeOrder } = params;\n\n        const usingTreeData = this.gridOptionsService.get('treeData');\n\n        const groupedCols = usingTreeData ? null : this.columnModel.getRowGroupColumns();\n\n        const details: GroupingDetails = {\n            // someone complained that the parent attribute was causing some change detection\n            // to break in an angular add-on.  Taking the parent out breaks a cyclic dependency, hence this flag got introduced.\n            includeParents: !this.gridOptionsService.get('suppressParentsInRowNodes'),\n            expandByDefault: this.gridOptionsService.get('groupDefaultExpanded'),\n            groupedCols: groupedCols!,\n            rootNode: rowNode,\n            pivotMode: this.columnModel.isPivotMode(),\n            groupedColCount: usingTreeData || !groupedCols ? 0 : groupedCols.length,\n            rowNodeOrder: rowNodeOrder!,\n            transactions: rowNodeTransactions!,\n            // if no transaction, then it's shotgun, changed path would be 'not active' at this point anyway\n            changedPath: changedPath!,\n            groupAllowUnbalanced:  this.gridOptionsService.get('groupAllowUnbalanced'),\n            isGroupOpenByDefault: this.gridOptionsService.getCallback('isGroupOpenByDefault') as any,\n            initialGroupOrderComparator: this.gridOptionsService.getCallback('initialGroupOrderComparator') as any,\n            usingTreeData: usingTreeData,\n            suppressGroupMaintainValueType: this.gridOptionsService.get('suppressGroupMaintainValueType'),\n            getDataPath: usingTreeData ? this.gridOptionsService.get('getDataPath') : undefined,\n            keyCreators: groupedCols?.map(column => column.getColDef().keyCreator) ?? []\n        };\n\n        return details;\n    }\n\n    private handleTransaction(details: GroupingDetails): void {\n\n        details.transactions.forEach(tran => {\n            // we don't allow batch remover for tree data as tree data uses Filler Nodes,\n            // and creating/deleting filler nodes needs to be done alongside the node deleting\n            // and moving. if we want to Batch Remover working with tree data then would need\n            // to consider how Filler Nodes would be impacted (it's possible that it can be easily\n            // modified to work, however for now I don't have the brain energy to work it all out).\n            const batchRemover = !details.usingTreeData ? new BatchRemover() : undefined;\n\n            // the order here of [add, remove, update] needs to be the same as in ClientSideNodeManager,\n            // as the order is important when a record with the same id is added and removed in the same\n            // transaction.\n            if (_.existsAndNotEmpty(tran.remove)) {\n                this.removeNodes(tran.remove as RowNode[], details, batchRemover);\n            }\n            if (_.existsAndNotEmpty(tran.update)) {\n                this.moveNodesInWrongPath(tran.update as RowNode[], details, batchRemover);\n            }\n            if (_.existsAndNotEmpty(tran.add)) {\n                this.insertNodes(tran.add as RowNode[], details, false);\n            }\n            // must flush here, and not allow another transaction to be applied,\n            // as each transaction must finish leaving the data in a consistent state.\n            if (batchRemover) {\n                const parentsWithChildrenRemoved = batchRemover.getAllParents().slice();\n                batchRemover.flush();\n                this.removeEmptyGroups(parentsWithChildrenRemoved, details);\n            }\n        });\n\n        if (details.rowNodeOrder) {\n            this.sortChildren(details);\n        }\n    }\n\n    // this is used when doing delta updates, eg Redux, keeps nodes in right order\n    private sortChildren(details: GroupingDetails): void {\n        details.changedPath.forEachChangedNodeDepthFirst(node => {\n            if (!node.childrenAfterGroup) {\n                return;\n            }\n\n            const didSort = _.sortRowNodesByOrder(node.childrenAfterGroup!, details.rowNodeOrder);\n            if (didSort) {\n                details.changedPath.addParentNode(node);\n            }\n        }, false, true);\n    }\n\n    private orderGroups(details: GroupingDetails): void {\n        const comparator = details.initialGroupOrderComparator;\n        if (_.exists(comparator)) { recursiveSort(details.rootNode); }\n\n        function recursiveSort(rowNode: RowNode): void {\n            const doSort = _.exists(rowNode.childrenAfterGroup) &&\n                // we only want to sort groups, so we do not sort leafs (a leaf group has leafs as children)\n                !rowNode.leafGroup;\n\n            if (doSort) {\n                rowNode.childrenAfterGroup!.sort((nodeA, nodeB) => comparator!({ nodeA, nodeB }));\n                rowNode.childrenAfterGroup!.forEach((childNode: RowNode) => recursiveSort(childNode));\n            }\n        }\n    }\n\n    private getExistingPathForNode(node: RowNode, details: GroupingDetails): GroupInfo[] {\n        const res: GroupInfo[] = [];\n\n        // when doing tree data, the node is part of the path,\n        // but when doing grid grouping, the node is not part of the path so we start with the parent.\n        let pointer = details.usingTreeData ? node : node.parent;\n        while (pointer && pointer !== details.rootNode) {\n            res.push({\n                key: pointer.key!,\n                rowGroupColumn: pointer.rowGroupColumn,\n                field: pointer.field\n            });\n            pointer = pointer.parent;\n        }\n        res.reverse();\n        return res;\n    }\n\n    private moveNodesInWrongPath(childNodes: RowNode[], details: GroupingDetails, batchRemover: BatchRemover | undefined): void {\n        childNodes.forEach(childNode => {\n\n            // we add node, even if parent has not changed, as the data could have\n            // changed, hence aggregations will be wrong\n            if (details.changedPath.isActive()) {\n                details.changedPath.addParentNode(childNode.parent);\n            }\n\n            const infoToKeyMapper = (item: GroupInfo) => item.key;\n            const oldPath: string[] = this.getExistingPathForNode(childNode, details).map(infoToKeyMapper);\n            const newPath: string[] = this.getGroupInfo(childNode, details).map(infoToKeyMapper);\n\n            const nodeInCorrectPath = _.areEqual(oldPath, newPath);\n\n            if (!nodeInCorrectPath) {\n                this.moveNode(childNode, details, batchRemover);\n            }\n        });\n    }\n\n    private moveNode(childNode: RowNode, details: GroupingDetails, batchRemover: BatchRemover | undefined): void {\n\n        this.removeNodesInStages([childNode], details, batchRemover);\n        this.insertOneNode(childNode, details, true, batchRemover);\n\n        // hack - if we didn't do this, then renaming a tree item (ie changing rowNode.key) wouldn't get\n        // refreshed into the gui.\n        // this is needed to kick off the event that rowComp listens to for refresh. this in turn\n        // then will get each cell in the row to refresh - which is what we need as we don't know which\n        // columns will be displaying the rowNode.key info.\n        childNode.setData(childNode.data);\n\n        // we add both old and new parents to changed path, as both will need to be refreshed.\n        // we already added the old parent (in calling method), so just add the new parent here\n        if (details.changedPath.isActive()) {\n            const newParent = childNode.parent;\n            details.changedPath.addParentNode(newParent);\n        }\n    }\n\n    private removeNodes(leafRowNodes: RowNode[], details: GroupingDetails, batchRemover: BatchRemover | undefined): void {\n        this.removeNodesInStages(leafRowNodes, details, batchRemover);\n        if (details.changedPath.isActive()) {\n            leafRowNodes.forEach(rowNode => details.changedPath.addParentNode(rowNode.parent));\n        }\n    }\n\n    private removeNodesInStages(leafRowNodes: RowNode[], details: GroupingDetails, batchRemover: BatchRemover | undefined): void {\n        this.removeNodesFromParents(leafRowNodes, details, batchRemover);\n        if (details.usingTreeData) {\n            this.postRemoveCreateFillerNodes(leafRowNodes, details);\n\n            // When not TreeData, then removeEmptyGroups is called just before the BatchRemover is flushed.\n            // However for TreeData, there is no BatchRemover, so we have to call removeEmptyGroups here.\n            const nodeParents = leafRowNodes.map(n => n.parent!);\n            this.removeEmptyGroups(nodeParents, details);\n        }\n    }\n\n    private forEachParentGroup(details: GroupingDetails, group: RowNode, callback: (parent: RowNode) => void): void {\n        let pointer: RowNode | null = group;\n        while (pointer && pointer !== details.rootNode) {\n            callback(pointer);\n            pointer = pointer.parent;\n        }\n    }\n\n    private removeNodesFromParents(nodesToRemove: RowNode[], details: GroupingDetails, provided: BatchRemover | undefined): void {\n        // this method can be called with BatchRemover as optional. if it is missed, we created a local version\n        // and flush it at the end. if one is provided, we add to the provided one and it gets flushed elsewhere.\n        const batchRemoverIsLocal = provided == null;\n        const batchRemoverToUse = provided ? provided : new BatchRemover();\n\n        nodesToRemove.forEach(nodeToRemove => {\n            this.removeFromParent(nodeToRemove, batchRemoverToUse);\n\n            // remove from allLeafChildren. we clear down all parents EXCEPT the Root Node, as\n            // the ClientSideNodeManager is responsible for the Root Node.\n            this.forEachParentGroup(details, nodeToRemove.parent!, parentNode => {\n                batchRemoverToUse.removeFromAllLeafChildren(parentNode, nodeToRemove);\n            });\n        });\n\n        if (batchRemoverIsLocal) {\n            batchRemoverToUse.flush();\n        }\n    }\n\n    private postRemoveCreateFillerNodes(nodesToRemove: RowNode[], details: GroupingDetails): void {\n        nodesToRemove.forEach(nodeToRemove => {\n\n            // if not group, and children are present, need to move children to a group.\n            // otherwise if no children, we can just remove without replacing.\n            const replaceWithGroup = nodeToRemove.hasChildren();\n            if (replaceWithGroup) {\n                const oldPath = this.getExistingPathForNode(nodeToRemove, details);\n                // because we just removed the userGroup, this will always return new support group\n                const newGroupNode = this.findParentForNode(nodeToRemove, oldPath, details);\n\n                // these properties are the ones that will be incorrect in the newly created group,\n                // so copy them from the old childNode\n                newGroupNode.expanded = nodeToRemove.expanded;\n                newGroupNode.allLeafChildren = nodeToRemove.allLeafChildren;\n                newGroupNode.childrenAfterGroup = nodeToRemove.childrenAfterGroup;\n                newGroupNode.childrenMapped = nodeToRemove.childrenMapped;\n                newGroupNode.updateHasChildren();\n\n                newGroupNode.childrenAfterGroup!.forEach(rowNode => rowNode.parent = newGroupNode);\n            }\n\n        });\n    }\n\n    private removeEmptyGroups(possibleEmptyGroups: RowNode[], details: GroupingDetails): void {\n        // we do this multiple times, as when we remove groups, that means the parent of just removed\n        // group can then be empty. to get around this, if we remove, then we check everything again for\n        // newly emptied groups. the max number of times this will execute is the depth of the group tree.\n        let checkAgain = true;\n\n        const groupShouldBeRemoved = (rowNode: RowNode): boolean => {\n\n            // because of the while loop below, it's possible we already moved the node,\n            // so double check before trying to remove again.\n            const mapKey = this.getChildrenMappedKey(rowNode.key!, rowNode.rowGroupColumn);\n            const parentRowNode = rowNode.parent;\n            const groupAlreadyRemoved = (parentRowNode && parentRowNode.childrenMapped) ?\n                !parentRowNode.childrenMapped[mapKey] : true;\n\n            if (groupAlreadyRemoved) {\n                // if not linked, then group was already removed\n                return false;\n            }\n            // if still not removed, then we remove if this group is empty\n            return !!rowNode.isEmptyRowGroupNode();\n        };\n\n        while (checkAgain) {\n            checkAgain = false;\n            const batchRemover: BatchRemover = new BatchRemover();\n            possibleEmptyGroups.forEach(possibleEmptyGroup => {\n                // remove empty groups\n                this.forEachParentGroup(details, possibleEmptyGroup, rowNode => {\n                    if (groupShouldBeRemoved(rowNode)) {\n                        checkAgain = true;\n                        this.removeFromParent(rowNode, batchRemover);\n                        // we remove selection on filler nodes here, as the selection would not be removed\n                        // from the RowNodeManager, as filler nodes don't exist on the RowNodeManager\n                        rowNode.setSelectedParams({ newValue: false, source: 'rowGroupChanged' });\n                    }\n                });\n            });\n            batchRemover.flush();\n        }\n    }\n\n    // removes the node from the parent by:\n    // a) removing from childrenAfterGroup (using batchRemover if present, otherwise immediately)\n    // b) removing from childrenMapped (immediately)\n    // c) setRowTop(null) - as the rowRenderer uses this to know the RowNode is no longer needed\n    // d) setRowIndex(null) - as the rowNode will no longer be displayed.\n    private removeFromParent(child: RowNode, batchRemover?: BatchRemover) {\n        if (child.parent) {\n            if (batchRemover) {\n                batchRemover.removeFromChildrenAfterGroup(child.parent, child);\n            } else {\n                _.removeFromArray(child.parent.childrenAfterGroup!, child);\n                child.parent.updateHasChildren();\n            }\n        }\n        const mapKey = this.getChildrenMappedKey(child.key!, child.rowGroupColumn);\n        if (child.parent && child.parent.childrenMapped) {\n            child.parent.childrenMapped[mapKey] = undefined;\n        }\n        // this is important for transition, see rowComp removeFirstPassFuncs. when doing animation and\n        // remove, if rowTop is still present, the rowComp thinks it's just moved position.\n        child.setRowTop(null);\n        child.setRowIndex(null);\n    }\n\n    private addToParent(child: RowNode, parent: RowNode | null) {\n        const mapKey = this.getChildrenMappedKey(child.key!, child.rowGroupColumn);\n        if (parent) {\n            const children = parent.childrenMapped != null;\n            if (children) {\n                parent.childrenMapped![mapKey] = child;\n            }\n            parent.childrenAfterGroup!.push(child);\n            parent.updateHasChildren();\n        }\n    }\n\n    private areGroupColsEqual(d1: GroupingDetails, d2: GroupingDetails): boolean {\n        if (d1 == null || d2 == null || d1.pivotMode !== d2.pivotMode) { return false; }\n\n        return _.areEqual(d1.groupedCols, d2.groupedCols) && _.areEqual(d1.keyCreators, d2.keyCreators);\n    }\n\n    private checkAllGroupDataAfterColsChanged(details: GroupingDetails): void {\n\n        const recurse = (rowNodes: RowNode[] | null) => {\n            if (!rowNodes) { return; }\n            rowNodes.forEach(rowNode => {\n                const isLeafNode = !details.usingTreeData && !rowNode.group;\n                if (isLeafNode) { return; }\n                const groupInfo: GroupInfo = {\n                    field: rowNode.field,\n                    key: rowNode.key!,\n                    rowGroupColumn: rowNode.rowGroupColumn,\n                    leafNode: rowNode.allLeafChildren[0],\n                };\n                this.setGroupData(rowNode, groupInfo, details);\n                recurse(rowNode.childrenAfterGroup);\n            });\n        };\n\n        recurse(details.rootNode.childrenAfterGroup);\n    }\n\n    private shotgunResetEverything(details: GroupingDetails, afterColumnsChanged: boolean): void {\n\n        if (this.noChangeInGroupingColumns(details, afterColumnsChanged)) {\n            return;\n        }\n\n        // groups are about to get disposed, so need to deselect any that are selected\n        this.selectionService.filterFromSelection((node: RowNode) => node && !node.group);\n\n        const { rootNode, groupedCols } = details;\n        // because we are not creating the root node each time, we have the logic\n        // here to change leafGroup once.\n        // we set .leafGroup to false for tree data, as .leafGroup is only used when pivoting, and pivoting\n        // isn't allowed with treeData, so the grid never actually use .leafGroup when doing treeData.\n        rootNode.leafGroup = details.usingTreeData ? false : groupedCols.length === 0;\n\n        // we are doing everything from scratch, so reset childrenAfterGroup and childrenMapped from the rootNode\n        rootNode.childrenAfterGroup = [];\n        rootNode.childrenMapped = {};\n        rootNode.updateHasChildren();\n\n        const sibling = rootNode.sibling;\n        if (sibling) {\n            sibling.childrenAfterGroup = rootNode.childrenAfterGroup;\n            sibling.childrenMapped = rootNode.childrenMapped;\n        }\n\n        this.insertNodes(rootNode.allLeafChildren, details, false);\n    }\n\n    private noChangeInGroupingColumns(details: GroupingDetails, afterColumnsChanged: boolean): boolean {\n        let noFurtherProcessingNeeded = false;\n\n        const groupDisplayColumns = this.columnModel.getGroupDisplayColumns();\n        const newGroupDisplayColIds = groupDisplayColumns ?\n            groupDisplayColumns.map(c => c.getId()).join('-') : '';\n\n        if (afterColumnsChanged) {\n            // we only need to redo grouping if doing normal grouping (ie not tree data)\n            // and the group cols have changed.\n            noFurtherProcessingNeeded = details.usingTreeData || this.areGroupColsEqual(details, this.oldGroupingDetails);\n\n            // if the group display cols have changed, then we need to update rowNode.groupData\n            // (regardless of tree data or row grouping)\n            if (this.oldGroupDisplayColIds !== newGroupDisplayColIds) {\n                this.checkAllGroupDataAfterColsChanged(details);\n            }\n        }\n\n        this.oldGroupingDetails = details;\n        this.oldGroupDisplayColIds = newGroupDisplayColIds;\n\n        return noFurtherProcessingNeeded;\n    }\n\n    private insertNodes(newRowNodes: RowNode[], details: GroupingDetails, isMove: boolean): void {\n        newRowNodes.forEach(rowNode => {\n            this.insertOneNode(rowNode, details, isMove);\n            if (details.changedPath.isActive()) {\n                details.changedPath.addParentNode(rowNode.parent);\n            }\n        });\n    }\n\n    private insertOneNode(childNode: RowNode, details: GroupingDetails, isMove: boolean, batchRemover?: BatchRemover): void {\n\n        const path: GroupInfo[] = this.getGroupInfo(childNode, details);\n\n        const parentGroup = this.findParentForNode(childNode, path, details, batchRemover);\n        if (!parentGroup.group) {\n            console.warn(`AG Grid: duplicate group keys for row data, keys should be unique`,\n                [parentGroup.data, childNode.data]);\n        }\n\n        if (details.usingTreeData) {\n            this.swapGroupWithUserNode(parentGroup, childNode, isMove);\n        } else {\n            childNode.parent = parentGroup;\n            childNode.level = path.length;\n            parentGroup.childrenAfterGroup!.push(childNode);\n            parentGroup.updateHasChildren();\n        }\n    }\n\n    private findParentForNode(childNode: RowNode, path: GroupInfo[], details: GroupingDetails, batchRemover?: BatchRemover): RowNode {\n        let nextNode: RowNode = details.rootNode;\n\n        path.forEach((groupInfo, level) => {\n            nextNode = this.getOrCreateNextNode(nextNode, groupInfo, level, details);\n            // node gets added to all group nodes.\n            // note: we do not add to rootNode here, as the rootNode is the master list of rowNodes\n\n            if (!batchRemover?.isRemoveFromAllLeafChildren(nextNode, childNode)) {\n                nextNode.allLeafChildren.push(childNode);\n            } else {\n                // if this node is about to be removed, prevent that\n                batchRemover?.preventRemoveFromAllLeafChildren(nextNode, childNode);\n            }\n        });\n\n        return nextNode;\n    }\n\n    private swapGroupWithUserNode(fillerGroup: RowNode, userGroup: RowNode, isMove: boolean) {\n        userGroup.parent = fillerGroup.parent;\n        userGroup.key = fillerGroup.key;\n        userGroup.field = fillerGroup.field;\n        userGroup.groupData = fillerGroup.groupData;\n        userGroup.level = fillerGroup.level;\n        // AG-3441 - preserve the existing expanded status of the node if we're moving it, so that\n        // you can drag a sub tree from one parent to another without changing its expansion\n        if (!isMove) {\n            userGroup.expanded = fillerGroup.expanded;\n        }\n\n        // we set .leafGroup to false for tree data, as .leafGroup is only used when pivoting, and pivoting\n        // isn't allowed with treeData, so the grid never actually use .leafGroup when doing treeData.\n        userGroup.leafGroup = fillerGroup.leafGroup;\n\n        // always null for userGroups, as row grouping is not allowed when doing tree data\n        userGroup.rowGroupIndex = fillerGroup.rowGroupIndex;\n\n        userGroup.allLeafChildren = fillerGroup.allLeafChildren;\n        userGroup.childrenAfterGroup = fillerGroup.childrenAfterGroup;\n        userGroup.childrenMapped = fillerGroup.childrenMapped;\n        userGroup.sibling = fillerGroup.sibling;\n        userGroup.updateHasChildren();\n\n        this.removeFromParent(fillerGroup);\n        userGroup.childrenAfterGroup!.forEach((rowNode: RowNode) => rowNode.parent = userGroup);\n        this.addToParent(userGroup, fillerGroup.parent);\n    }\n\n    private getOrCreateNextNode(parentGroup: RowNode, groupInfo: GroupInfo, level: number,\n        details: GroupingDetails): RowNode {\n\n        const key = this.getChildrenMappedKey(groupInfo.key, groupInfo.rowGroupColumn);\n        let nextNode = parentGroup.childrenMapped ? parentGroup.childrenMapped[key] : undefined;\n\n        if (!nextNode) {\n            nextNode = this.createGroup(groupInfo, parentGroup, level, details);\n            // attach the new group to the parent\n            this.addToParent(nextNode, parentGroup);\n        }\n\n        return nextNode;\n    }\n\n    private createGroup(groupInfo: GroupInfo, parent: RowNode, level: number, details: GroupingDetails): RowNode {\n        const groupNode = new RowNode(this.beans);\n\n        groupNode.group = true;\n        groupNode.field = groupInfo.field;\n        groupNode.rowGroupColumn = groupInfo.rowGroupColumn;\n\n        this.setGroupData(groupNode, groupInfo, details);\n\n        groupNode.key = groupInfo.key;\n        groupNode.id = this.createGroupId(groupNode, parent, details.usingTreeData, level);\n\n        groupNode.level = level;\n        groupNode.leafGroup = details.usingTreeData ? false : level === (details.groupedColCount - 1);\n\n        groupNode.allLeafChildren = [];\n\n        // why is this done here? we are not updating the children count as we go,\n        // i suspect this is updated in the filter stage\n        groupNode.setAllChildrenCount(0);\n\n        groupNode.rowGroupIndex = details.usingTreeData ? null : level;\n\n        groupNode.childrenAfterGroup = [];\n        groupNode.childrenMapped = {};\n        groupNode.updateHasChildren();\n\n        groupNode.parent = details.includeParents ? parent : null;\n\n        this.setExpandedInitialValue(details, groupNode);\n\n        return groupNode;\n    }\n\n    private createGroupId(node: RowNode, parent: RowNode, usingTreeData: boolean, level: number): string {\n        let createGroupId: (node: RowNode, parent: RowNode | null, level: number) => string | null;\n        if (usingTreeData) {\n            createGroupId = (node, parent, level) => {\n                if (level < 0) { return null; } // root node\n                const parentId = parent ? createGroupId(parent, parent.parent, level - 1) : null;\n                return `${parentId == null ? '' : parentId + '-'}${level}-${node.key}`;\n            };\n        } else {\n            createGroupId = (node, parent) => {\n                if (!node.rowGroupColumn) { return null; } // root node\n                const parentId = parent ? createGroupId(parent, parent.parent, 0) : null;\n                return `${parentId == null ? '' : parentId + '-'}${node.rowGroupColumn.getColId()}-${node.key}`;\n            };\n        }\n\n        // we put 'row-group-' before the group id, so it doesn't clash with standard row id's. we also use 't-' and 'b-'\n        // for top pinned and bottom pinned rows.\n        return RowNode.ID_PREFIX_ROW_GROUP + createGroupId(node, parent, level);\n    }\n\n    private setGroupData(groupNode: RowNode, groupInfo: GroupInfo, details: GroupingDetails): void {\n        groupNode.groupData = {};\n        const groupDisplayCols: Column[] = this.columnModel.getGroupDisplayColumns();\n        groupDisplayCols.forEach(col => {\n            // newGroup.rowGroupColumn=null when working off GroupInfo, and we always display the group in the group column\n            // if rowGroupColumn is present, then it's grid row grouping and we only include if configuration says so\n            const isTreeData = details.usingTreeData;\n            if (isTreeData) {\n                groupNode.groupData![col.getColId()] = groupInfo.key;\n                return;\n            }\n\n            const groupColumn = groupNode.rowGroupColumn;\n            const isRowGroupDisplayed = groupColumn !== null && col.isRowGroupDisplayed(groupColumn.getId());\n            if (isRowGroupDisplayed) {\n                if (details.suppressGroupMaintainValueType) {\n                    groupNode.groupData![col.getColId()] = groupInfo.key;\n                } else {\n                    // if maintain group value type, get the value from any leaf node.\n                    groupNode.groupData![col.getColId()] = this.valueService.getValue(groupColumn, groupInfo.leafNode);\n                }\n            }\n        });\n    }\n\n    private getChildrenMappedKey(key: string, rowGroupColumn: Column | null): string {\n        if (rowGroupColumn) {\n            // grouping by columns\n            return rowGroupColumn.getId() + '-' + key;\n        }\n        // tree data - we don't have rowGroupColumns\n        return key;\n    }\n\n    private setExpandedInitialValue(details: GroupingDetails, groupNode: RowNode): void {\n        // if pivoting the leaf group is never expanded as we do not show leaf rows\n        if (details.pivotMode && groupNode.leafGroup) {\n            groupNode.expanded = false;\n            return;\n        }\n\n        // use callback if exists\n        const userCallback = details.isGroupOpenByDefault;\n        if (userCallback) {\n            const params: WithoutGridCommon<IsGroupOpenByDefaultParams> = {\n                rowNode: groupNode,\n                field: groupNode.field!,\n                key: groupNode.key!,\n                level: groupNode.level,\n                rowGroupColumn: groupNode.rowGroupColumn!\n            };\n            groupNode.expanded = userCallback(params) == true;\n            return;\n        }\n\n        // use expandByDefault if exists\n        const { expandByDefault } = details;\n        if (details.expandByDefault === -1) {\n            groupNode.expanded = true;\n            return;\n        }\n\n        // otherwise\n        groupNode.expanded = groupNode.level < expandByDefault;\n    }\n\n    private getGroupInfo(rowNode: RowNode, details: GroupingDetails): GroupInfo[] {\n        if (details.usingTreeData) {\n            return this.getGroupInfoFromCallback(rowNode, details);\n        }\n        return this.getGroupInfoFromGroupColumns(rowNode, details);\n    }\n\n    private getGroupInfoFromCallback(rowNode: RowNode, details: GroupingDetails): GroupInfo[] {        \n        const keys: string[] | null = details.getDataPath ? details.getDataPath(rowNode.data) : null;\n\n        if (keys === null || keys === undefined || keys.length === 0) {\n            _.warnOnce(`getDataPath() should not return an empty path for data ${rowNode.data}`);\n        }\n        const groupInfoMapper = (key: string | null) => ({ key, field: null, rowGroupColumn: null }) as GroupInfo;\n        return keys ? keys.map(groupInfoMapper) : [];\n    }\n\n    private getGroupInfoFromGroupColumns(rowNode: RowNode, details: GroupingDetails) {\n        const res: GroupInfo[] = [];\n        details.groupedCols.forEach(groupCol => {\n            let key: string = this.valueService.getKeyForNode(groupCol, rowNode);\n            let keyExists = key !== null && key !== undefined && key !== '';\n\n            // unbalanced tree and pivot mode don't work together - not because of the grid, it doesn't make\n            // mathematical sense as you are building up a cube. so if pivot mode, we put in a blank key where missing.\n            // this keeps the tree balanced and hence can be represented as a group.\n            const createGroupForEmpty = details.pivotMode || !details.groupAllowUnbalanced;\n            if (createGroupForEmpty && !keyExists) {\n                key = '';\n                keyExists = true;\n            }\n\n            if (keyExists) {\n                const item = {\n                    key: key,\n                    field: groupCol.getColDef().field,\n                    rowGroupColumn: groupCol,\n                    leafNode: rowNode,\n                } as GroupInfo;\n                res.push(item);\n            }\n        });\n        return res;\n    }\n}"]}