@mui/x-data-grid-pro 5.17.5 → 6.0.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/x-data-grid-pro",
-  "version": "5.17.5",
+  "version": "6.0.0-alpha.1",
   "description": "The Pro plan edition of the data grid component (MUI X).",
   "author": "MUI Team",
   "main": "./node/index.js",
@@ -31,10 +31,10 @@
     "directory": "packages/grid/x-data-grid-pro"
   },
   "dependencies": {
-    "@babel/runtime": "^7.18.9",
-    "@mui/utils": "^5.10.3",
-    "@mui/x-data-grid": "5.17.5",
-    "@mui/x-license-pro": "5.17.0",
+    "@babel/runtime": "^7.19.0",
+    "@mui/utils": "^5.10.6",
+    "@mui/x-data-grid": "6.0.0-alpha.1",
+    "@mui/x-license-pro": "6.0.0-alpha.0",
     "@types/format-util": "^1.0.2",
     "clsx": "^1.2.1",
     "prop-types": "^15.8.1",

package/utils/tree/createRowTree.d.ts

@@ -0,0 +1,15 @@
+import { GridRowTreeCreationValue } from '@mui/x-data-grid/internals';
+import { RowTreeBuilderNode, GridTreePathDuplicateHandler } from './models';
+import { DataGridProProps } from '../../models/dataGridProProps';
+interface CreateRowTreeParams {
+    nodes: RowTreeBuilderNode[];
+    defaultGroupingExpansionDepth: number;
+    isGroupExpandedByDefault?: DataGridProProps['isGroupExpandedByDefault'];
+    groupingName: string;
+    onDuplicatePath?: GridTreePathDuplicateHandler;
+}
+/**
+ * Transform a list of rows into a tree structure where each row references its parent and children.
+ */
+export declare const createRowTree: (params: CreateRowTreeParams) => GridRowTreeCreationValue;
+export {};

package/utils/tree/createRowTree.js

@@ -0,0 +1,35 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { buildRootGroup } from '@mui/x-data-grid/internals';
+import { insertDataRowInTree } from './insertDataRowInTree';
+
+/**
+ * Transform a list of rows into a tree structure where each row references its parent and children.
+ */
+export const createRowTree = params => {
+  const dataRowIds = [];
+  const tree = {
+    [GRID_ROOT_GROUP_ID]: buildRootGroup()
+  };
+  const treeDepths = {};
+
+  for (let i = 0; i < params.nodes.length; i += 1) {
+    const node = params.nodes[i];
+    dataRowIds.push(node.id);
+    insertDataRowInTree({
+      tree,
+      id: node.id,
+      path: node.path,
+      onDuplicatePath: params.onDuplicatePath,
+      treeDepths,
+      isGroupExpandedByDefault: params.isGroupExpandedByDefault,
+      defaultGroupingExpansionDepth: params.defaultGroupingExpansionDepth
+    });
+  }
+
+  return {
+    tree,
+    treeDepths,
+    groupingName: params.groupingName,
+    dataRowIds
+  };
+};

package/utils/tree/index.d.ts

@@ -1 +1 @@
-export { getGroupRowIdFromPath } from './buildRowTree';
+export { getGroupRowIdFromPath } from './utils';

package/utils/tree/index.js

@@ -1 +1 @@
-export { getGroupRowIdFromPath } from './buildRowTree';
+export { getGroupRowIdFromPath } from './utils';

package/utils/tree/insertDataRowInTree.d.ts

@@ -0,0 +1,51 @@
+import { GridRowId, GridRowTreeConfig } from '@mui/x-data-grid';
+import { GridTreeDepths, GridRowTreeUpdatedGroupsManager } from '@mui/x-data-grid/internals';
+import { GridTreePathDuplicateHandler, RowTreeBuilderGroupingCriterion } from './models';
+import { DataGridProProps } from '../../models/dataGridProProps';
+interface InsertDataRowInTreeParams {
+    /**
+     * ID of the data row to insert in the tree.
+     */
+    id: GridRowId;
+    /**
+     * Path of the data row to insert in the tree.
+     */
+    path: RowTreeBuilderGroupingCriterion[];
+    /**
+     * Tree in which to insert the data row.
+     * This tree can be mutated but it's children should not.
+     * For instance:
+     *
+     * - `tree[nodeId] = newNode` => valid
+     * - `tree[nodeId].children.push(newNodeId)` => invalid
+     */
+    tree: GridRowTreeConfig;
+    /**
+     * Amount of nodes at each depth of the tree.
+     * This object can be mutated.
+     * For instance:
+     *
+     * - `treeDepths[nodeDepth] = treeDepth[nodeDepth] + 1` => valid
+     */
+    treeDepths: GridTreeDepths;
+    /**
+     * Object tracking the action performed on each group.
+     * Used to decide which groups to refresh on sorting, filtering, aggregation, ...
+     * If not defined, then the tracking will be skipped.
+     */
+    updatedGroupsManager?: GridRowTreeUpdatedGroupsManager;
+    /**
+     * Callback fired when trying to insert a data row for a path already populated by another data row.
+     */
+    onDuplicatePath?: GridTreePathDuplicateHandler;
+    isGroupExpandedByDefault?: DataGridProProps['isGroupExpandedByDefault'];
+    defaultGroupingExpansionDepth: number;
+}
+/**
+ * Inserts a data row in a tree.
+ * For each steps of its path:
+ * - if a node exists with the same partial path, it will register this node as the ancestor of the data row.
+ * - if not, it will create an auto-generated node and register it as ancestor of the data row.
+ */
+export declare const insertDataRowInTree: ({ id, path, updatedGroupsManager, tree, treeDepths, onDuplicatePath, isGroupExpandedByDefault, defaultGroupingExpansionDepth, }: InsertDataRowInTreeParams) => void;
+export {};

package/utils/tree/insertDataRowInTree.js

@@ -0,0 +1,129 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { addGroupDefaultExpansion, getGroupRowIdFromPath, insertNodeInTree, updateGroupNodeIdAndAutoGenerated } from './utils';
+
+/**
+ * Inserts a data row in a tree.
+ * For each steps of its path:
+ * - if a node exists with the same partial path, it will register this node as the ancestor of the data row.
+ * - if not, it will create an auto-generated node and register it as ancestor of the data row.
+ */
+export const insertDataRowInTree = ({
+  id,
+  path,
+  updatedGroupsManager,
+  tree,
+  treeDepths,
+  onDuplicatePath,
+  isGroupExpandedByDefault,
+  defaultGroupingExpansionDepth
+}) => {
+  let parentNodeId = GRID_ROOT_GROUP_ID;
+
+  for (let depth = 0; depth < path.length; depth += 1) {
+    var _childrenFromPath, _childrenFromPath$fie;
+
+    const {
+      key,
+      field
+    } = path[depth];
+    const fieldWithDefaultValue = field != null ? field : '__no_field__';
+    const keyWithDefaultValue = key != null ? key : '__no_key__';
+    const existingNodeIdWithPartialPath = (_childrenFromPath = tree[parentNodeId].childrenFromPath) == null ? void 0 : (_childrenFromPath$fie = _childrenFromPath[fieldWithDefaultValue]) == null ? void 0 : _childrenFromPath$fie[keyWithDefaultValue.toString()]; // When we reach the last step of the path,
+    // We need to create a node for the row passed to `insertNodeInTree`
+
+    if (depth === path.length - 1) {
+      // If no node matches the full path,
+      // We create a leaf node for the data row.
+      if (existingNodeIdWithPartialPath == null) {
+        const leafNode = {
+          type: 'leaf',
+          id,
+          depth,
+          parent: parentNodeId,
+          groupingKey: key
+        };
+        updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+        insertNodeInTree({
+          node: leafNode,
+          tree,
+          treeDepths
+        });
+      } else {
+        const existingNodeWithPartialPath = tree[existingNodeIdWithPartialPath]; // If we already have an auto-generated group matching the partial path,
+        // We replace it with the node from of data row passed to `insertNodeInTree`
+
+        if (existingNodeWithPartialPath.type === 'group' && existingNodeWithPartialPath.isAutoGenerated) {
+          updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'removeChildren');
+          updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+          updateGroupNodeIdAndAutoGenerated({
+            tree,
+            treeDepths,
+            node: existingNodeWithPartialPath,
+            updatedNode: {
+              id,
+              isAutoGenerated: false
+            }
+          });
+        } else {
+          // If we have another row matching the partial path, then there is a duplicate in the dataset.
+          // We warn the user and skip the current row.
+          onDuplicatePath == null ? void 0 : onDuplicatePath(existingNodeIdWithPartialPath, id, path);
+        }
+      }
+    } // For the intermediary steps of the path,
+    // We need to make sure that there is a node matching the partial path.
+    //
+    // If no node matches the partial path,
+    // We create an auto-generated group node.
+    else if (existingNodeIdWithPartialPath == null) {
+      const nodeId = getGroupRowIdFromPath(path.slice(0, depth + 1));
+      const autoGeneratedGroupNode = {
+        type: 'group',
+        id: nodeId,
+        parent: parentNodeId,
+        depth,
+        isAutoGenerated: true,
+        groupingKey: key,
+        groupingField: field,
+        children: [],
+        childrenFromPath: {}
+      };
+      updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNodeId, 'insertChildren');
+      insertNodeInTree({
+        node: addGroupDefaultExpansion({
+          node: autoGeneratedGroupNode,
+          defaultGroupingExpansionDepth,
+          isGroupExpandedByDefault
+        }),
+        tree,
+        treeDepths
+      });
+      parentNodeId = nodeId;
+    } // For the intermediary steps of the path
+    // If a node matches the partial path, we use it as parent for the next step
+    else {
+      const currentGroupNode = tree[existingNodeIdWithPartialPath]; // If the node matching the partial path is not a group, we turn it into a group
+
+      if (currentGroupNode.type !== 'group') {
+        const groupNode = {
+          type: 'group',
+          id: currentGroupNode.id,
+          parent: currentGroupNode.parent,
+          depth: currentGroupNode.depth,
+          isAutoGenerated: false,
+          groupingKey: key,
+          groupingField: field,
+          children: [],
+          childrenFromPath: {}
+        };
+        tree[existingNodeIdWithPartialPath] = addGroupDefaultExpansion({
+          node: groupNode,
+          defaultGroupingExpansionDepth,
+          isGroupExpandedByDefault
+        });
+      }
+
+      parentNodeId = currentGroupNode.id;
+    }
+  }
+};

package/utils/tree/models.d.ts

@@ -0,0 +1,13 @@
+import { GridKeyValue, GridRowId } from '@mui/x-data-grid';
+export interface RowTreeBuilderGroupingCriterion {
+    field: string | null;
+    key: GridKeyValue | null;
+}
+export interface RowTreeBuilderNode {
+    id: GridRowId;
+    path: RowTreeBuilderGroupingCriterion[];
+}
+/**
+ * Callback called when trying to insert a data row in the tree in place of an already existing data row.
+ */
+export declare type GridTreePathDuplicateHandler = (firstId: GridRowId, secondId: GridRowId, path: RowTreeBuilderGroupingCriterion[]) => void;

package/utils/tree/models.js

@@ -0,0 +1 @@
+export {};

package/utils/tree/removeDataRowFromTree.d.ts

@@ -0,0 +1,40 @@
+import { GridRowId, GridRowTreeConfig } from '@mui/x-data-grid';
+import { GridTreeDepths, GridRowTreeUpdatedGroupsManager } from '@mui/x-data-grid/internals';
+interface RemoveDataRowFromTreeParams {
+    /**
+     * ID of the data row to remove from the tree.
+     */
+    id: GridRowId;
+    /**
+     * Tree from which to remove the data row.
+     * This tree can be mutated but it's children should not.
+     * For instance:
+     *
+     * - `tree[nodeId] = newNode` => valid
+     * - `tree[nodeId].children.push(newNodeId)` => invalid
+     */
+    tree: GridRowTreeConfig;
+    /**
+     * Amount of nodes at each depth of the tree.
+     * This object can be mutated.
+     * For instance:
+     *
+     * - `treeDepths[nodeDepth] = treeDepth[nodeDepth] + 1` => valid
+     */
+    treeDepths: GridTreeDepths;
+    /**
+     * Object tracking the action performed on each group.
+     * Used to decide which groups to refresh on sorting, filtering, aggregation, ...
+     * If not defined, then the tracking will be skipped.
+     */
+    updatedGroupsManager?: GridRowTreeUpdatedGroupsManager;
+}
+/**
+ * Removed a data row from the tree.
+ * If the node is a non-empty group, replace it with an auto-generated group to be able to keep displaying its children.
+ * If not, remove it and recursively clean its parent with the following rules:
+ * - An empty auto-generated should be removed from the tree
+ * - An empty non-auto-generated should be turned into a leaf
+ */
+export declare const removeDataRowFromTree: ({ id, tree, treeDepths, updatedGroupsManager, }: RemoveDataRowFromTreeParams) => void;
+export {};

package/utils/tree/removeDataRowFromTree.js

@@ -0,0 +1,100 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { getNodePathInTree, getGroupRowIdFromPath, removeNodeFromTree, updateGroupNodeIdAndAutoGenerated } from './utils';
+
+const removeNodeAndCleanParent = ({
+  node,
+  tree,
+  treeDepths,
+  updatedGroupsManager
+}) => {
+  removeNodeFromTree({
+    node,
+    tree,
+    treeDepths
+  });
+
+  if (node.type === 'group' && node.footerId != null) {
+    removeNodeFromTree({
+      node: tree[node.footerId],
+      tree,
+      treeDepths
+    });
+  }
+
+  const parentNode = tree[node.parent];
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(parentNode.id, 'removeChildren');
+  const shouldDeleteGroup = parentNode.id !== GRID_ROOT_GROUP_ID && parentNode.children.length === 0;
+
+  if (shouldDeleteGroup) {
+    if (parentNode.isAutoGenerated) {
+      removeNodeAndCleanParent({
+        node,
+        tree,
+        treeDepths
+      });
+    } else {
+      tree[parentNode.id] = {
+        type: 'leaf',
+        id: parentNode.id,
+        depth: parentNode.depth,
+        parent: parentNode.parent,
+        groupingKey: parentNode.groupingKey
+      };
+    }
+  }
+};
+
+const replaceDataGroupWithAutoGeneratedGroup = ({
+  node,
+  tree,
+  treeDepths,
+  updatedGroupsManager
+}) => {
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(node.parent, 'removeChildren');
+  updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(node.parent, 'insertChildren');
+  updateGroupNodeIdAndAutoGenerated({
+    tree,
+    treeDepths,
+    node,
+    updatedNode: {
+      id: getGroupRowIdFromPath(getNodePathInTree({
+        id: node.id,
+        tree
+      })),
+      isAutoGenerated: true
+    }
+  });
+};
+/**
+ * Removed a data row from the tree.
+ * If the node is a non-empty group, replace it with an auto-generated group to be able to keep displaying its children.
+ * If not, remove it and recursively clean its parent with the following rules:
+ * - An empty auto-generated should be removed from the tree
+ * - An empty non-auto-generated should be turned into a leaf
+ */
+
+
+export const removeDataRowFromTree = ({
+  id,
+  tree,
+  treeDepths,
+  updatedGroupsManager
+}) => {
+  const node = tree[id];
+
+  if (node.type === 'group' && node.children.length > 0) {
+    replaceDataGroupWithAutoGeneratedGroup({
+      node,
+      tree,
+      treeDepths,
+      updatedGroupsManager
+    });
+  } else {
+    removeNodeAndCleanParent({
+      node,
+      tree,
+      treeDepths,
+      updatedGroupsManager
+    });
+  }
+};

package/utils/tree/sortRowTree.d.ts

@@ -1,10 +1,15 @@
 import { GridRowId, GridRowTreeConfig } from '@mui/x-data-grid';
 import { GridSortingModelApplier } from '@mui/x-data-grid/internals';
 interface SortRowTreeParams {
-    rowIds: GridRowId[];
     rowTree: GridRowTreeConfig;
     disableChildrenSorting: boolean;
     sortRowList: GridSortingModelApplier | null;
+    /**
+     * Defines where the groups are placed relative to the leaves of same depth when no sorting rule is applied.
+     * If `true` the groups will be rendered below the leaves.
+     * If `false`, the groups will be rendered on their creation order.
+     */
+    shouldRenderGroupBelowLeaves: boolean;
 }
 export declare const sortRowTree: (params: SortRowTreeParams) => GridRowId[];
 export {};

package/utils/tree/sortRowTree.js

@@ -1,59 +1,65 @@
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
 export const sortRowTree = params => {
   const {
-    rowIds,
     rowTree,
     disableChildrenSorting,
-    sortRowList
+    sortRowList,
+    shouldRenderGroupBelowLeaves
   } = params;
-  let sortedRows = []; // Group the rows by parent
+  let sortedRows = [];
+  const sortedGroupedByParentRows = new Map();
 
-  const groupedByParentRows = new Map([[null, {
-    body: [],
-    footer: null
-  }]]);
+  const sortGroup = node => {
+    const shouldSortGroup = !!sortRowList && (!disableChildrenSorting || node.depth === -1);
+    let sortedRowIds;
 
-  for (let i = 0; i < rowIds.length; i += 1) {
-    const rowId = rowIds[i];
-    const node = rowTree[rowId];
-    let group = groupedByParentRows.get(node.parent);
+    if (shouldSortGroup) {
+      for (let i = 0; i < node.children.length; i += 1) {
+        const childNode = rowTree[node.children[i]];
 
-    if (!group) {
-      group = {
-        body: [],
-        footer: null
-      };
-      groupedByParentRows.set(node.parent, group);
-    }
+        if (childNode.type === 'group') {
+          sortGroup(childNode);
+        }
+      }
 
-    if (node.position === 'footer') {
-      group.footer = node;
-    } else {
-      group.body.push(node);
-    }
-  } // Apply the sorting to each list of children
+      sortedRowIds = sortRowList(node.children.map(childId => rowTree[childId]));
+    } else if (shouldRenderGroupBelowLeaves) {
+      const childrenLeaves = [];
+      const childrenGroups = [];
 
+      for (let i = 0; i < node.children.length; i += 1) {
+        const childId = node.children[i];
+        const childNode = rowTree[childId];
 
-  const sortedGroupedByParentRows = new Map();
-  groupedByParentRows.forEach((group, parent) => {
-    if (group.body.length === 0) {
-      sortedGroupedByParentRows.set(parent, []);
+        if (childNode.type === 'group') {
+          sortGroup(childNode);
+          childrenGroups.push(childId);
+        } else if (childNode.type === 'leaf') {
+          childrenLeaves.push(childId);
+        }
+      }
+
+      sortedRowIds = [...childrenLeaves, ...childrenGroups];
     } else {
-      let groupSortedRows;
-      const depth = group.body[0].depth;
+      for (let i = 0; i < node.children.length; i += 1) {
+        const childNode = rowTree[node.children[i]];
 
-      if (depth > 0 && disableChildrenSorting || !sortRowList) {
-        groupSortedRows = group.body.map(row => row.id);
-      } else {
-        groupSortedRows = sortRowList(group.body);
+        if (childNode.type === 'group') {
+          sortGroup(childNode);
+        }
       }
 
-      if (group.footer != null) {
-        groupSortedRows.push(group.footer.id);
-      }
+      sortedRowIds = [...node.children];
+    }
 
-      sortedGroupedByParentRows.set(parent, groupSortedRows);
+    if (node.footerId != null) {
+      sortedRowIds.push(node.footerId);
     }
-  }); // Flatten the sorted lists to have children just after their parent
+
+    sortedGroupedByParentRows.set(node.id, sortedRowIds);
+  };
+
+  sortGroup(rowTree[GRID_ROOT_GROUP_ID]); // Flatten the sorted lists to have children just after their parent
 
   const insertRowListIntoSortedRows = (startIndex, rowList) => {
     sortedRows = [...sortedRows.slice(0, startIndex), ...rowList, ...sortedRows.slice(startIndex)];
@@ -70,6 +76,6 @@ export const sortRowTree = params => {
     return treeSize;
   };
 
-  insertRowListIntoSortedRows(0, sortedGroupedByParentRows.get(null));
+  insertRowListIntoSortedRows(0, sortedGroupedByParentRows.get(GRID_ROOT_GROUP_ID));
   return sortedRows;
 };

package/utils/tree/updateRowTree.d.ts

@@ -0,0 +1,19 @@
+import { GridGroupNode, GridRowId, GridRowTreeConfig } from '@mui/x-data-grid';
+import { GridRowTreeCreationValue, GridTreeDepths } from '@mui/x-data-grid/internals';
+import { GridTreePathDuplicateHandler, RowTreeBuilderNode } from './models';
+export interface UpdateRowTreeNodes {
+    inserted: RowTreeBuilderNode[];
+    modified: RowTreeBuilderNode[];
+    removed: GridRowId[];
+}
+interface UpdateRowTreeParams {
+    previousTree: GridRowTreeConfig;
+    previousTreeDepth: GridTreeDepths;
+    nodes: UpdateRowTreeNodes;
+    defaultGroupingExpansionDepth: number;
+    isGroupExpandedByDefault?: (node: GridGroupNode) => boolean;
+    groupingName: string;
+    onDuplicatePath?: GridTreePathDuplicateHandler;
+}
+export declare const updateRowTree: (params: UpdateRowTreeParams) => GridRowTreeCreationValue;
+export {};

package/utils/tree/updateRowTree.js

@@ -0,0 +1,83 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid';
+import { isDeepEqual, getTreeNodeDescendants } from '@mui/x-data-grid/internals';
+import { insertDataRowInTree } from './insertDataRowInTree';
+import { removeDataRowFromTree } from './removeDataRowFromTree';
+import { createUpdatedGroupsManager, getNodePathInTree } from './utils';
+export const updateRowTree = params => {
+  const tree = _extends({}, params.previousTree);
+
+  const treeDepths = _extends({}, params.previousTreeDepth);
+
+  const updatedGroupsManager = createUpdatedGroupsManager();
+
+  for (let i = 0; i < params.nodes.inserted.length; i += 1) {
+    const {
+      id,
+      path
+    } = params.nodes.inserted[i];
+    insertDataRowInTree({
+      tree,
+      treeDepths,
+      updatedGroupsManager,
+      id,
+      path,
+      onDuplicatePath: params.onDuplicatePath,
+      isGroupExpandedByDefault: params.isGroupExpandedByDefault,
+      defaultGroupingExpansionDepth: params.defaultGroupingExpansionDepth
+    });
+  }
+
+  for (let i = 0; i < params.nodes.removed.length; i += 1) {
+    const nodeId = params.nodes.removed[i];
+    removeDataRowFromTree({
+      tree,
+      treeDepths,
+      updatedGroupsManager,
+      id: nodeId
+    });
+  }
+
+  for (let i = 0; i < params.nodes.modified.length; i += 1) {
+    const {
+      id,
+      path
+    } = params.nodes.modified[i];
+    const pathInPreviousTree = getNodePathInTree({
+      tree,
+      id
+    });
+    const isInSameGroup = isDeepEqual(pathInPreviousTree, path);
+
+    if (!isInSameGroup) {
+      removeDataRowFromTree({
+        tree,
+        treeDepths,
+        updatedGroupsManager,
+        id
+      });
+      insertDataRowInTree({
+        tree,
+        treeDepths,
+        updatedGroupsManager,
+        id,
+        path,
+        onDuplicatePath: params.onDuplicatePath,
+        isGroupExpandedByDefault: params.isGroupExpandedByDefault,
+        defaultGroupingExpansionDepth: params.defaultGroupingExpansionDepth
+      });
+    } else {
+      updatedGroupsManager == null ? void 0 : updatedGroupsManager.addAction(tree[id].parent, 'modifyChildren');
+    }
+  } // TODO rows v6: Avoid walking the whole tree, we should be able to generate the new list only using slices.
+
+
+  const dataRowIds = getTreeNodeDescendants(tree, GRID_ROOT_GROUP_ID, true);
+  return {
+    tree,
+    treeDepths,
+    groupingName: params.groupingName,
+    dataRowIds,
+    updatedGroupsManager
+  };
+};