@mui/x-data-grid 7.17.0 → 7.19.0

package/modern/hooks/features/keyboardNavigation/useGridKeyboardNavigation.js

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { useRtl } from '@mui/system/RtlProvider';
-import { gridVisibleColumnDefinitionsSelector } from "../columns/gridColumnsSelector.js";
+import { gridVisibleColumnDefinitionsSelector, gridVisibleColumnFieldsSelector } from "../columns/gridColumnsSelector.js";
 import { useGridLogger } from "../../utils/useGridLogger.js";
 import { useGridApiEventHandler } from "../../utils/useGridApiEventHandler.js";
 import { gridExpandedSortedRowEntriesSelector } from "../filter/gridFilterSelector.js";
@@ -10,50 +10,12 @@ import { gridClasses } from "../../../constants/gridClasses.js";
 import { GridCellModes } from "../../../models/gridEditRowModel.js";
 import { isNavigationKey } from "../../../utils/keyboardUtils.js";
 import { GRID_DETAIL_PANEL_TOGGLE_FIELD } from "../../../constants/gridDetailPanelToggleField.js";
-import { gridPinnedRowsSelector } from "../rows/gridRowsSelector.js";
 import { gridFocusColumnGroupHeaderSelector } from "../focus/index.js";
 import { gridColumnGroupsHeaderMaxDepthSelector } from "../columnGrouping/gridColumnGroupsSelector.js";
 import { gridHeaderFilteringEditFieldSelector, gridHeaderFilteringMenuSelector } from "../headerFiltering/gridHeaderFilteringSelectors.js";
 import { useGridRegisterPipeProcessor } from "../../core/pipeProcessing/index.js";
 import { isEventTargetInPortal } from "../../../utils/domUtils.js";
-function enrichPageRowsWithPinnedRows(apiRef, rows) {
-  const pinnedRows = gridPinnedRowsSelector(apiRef) || {};
-  return [...(pinnedRows.top || []), ...rows, ...(pinnedRows.bottom || [])];
-}
-const getLeftColumnIndex = ({
-  currentColIndex,
-  firstColIndex,
-  lastColIndex,
-  isRtl
-}) => {
-  if (isRtl) {
-    if (currentColIndex < lastColIndex) {
-      return currentColIndex + 1;
-    }
-  } else if (!isRtl) {
-    if (currentColIndex > firstColIndex) {
-      return currentColIndex - 1;
-    }
-  }
-  return null;
-};
-const getRightColumnIndex = ({
-  currentColIndex,
-  firstColIndex,
-  lastColIndex,
-  isRtl
-}) => {
-  if (isRtl) {
-    if (currentColIndex > firstColIndex) {
-      return currentColIndex - 1;
-    }
-  } else if (!isRtl) {
-    if (currentColIndex < lastColIndex) {
-      return currentColIndex + 1;
-    }
-  }
-  return null;
-};
+import { enrichPageRowsWithPinnedRows, getLeftColumnIndex, getRightColumnIndex, findNonRowSpannedCell } from "./utils.js";
 
 /**
  * @requires useGridSorting (method) - can be after
@@ -73,11 +35,12 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
 
   /**
    * @param {number} colIndex Index of the column to focus
-   * @param {number} rowIndex index of the row to focus
+   * @param {GridRowId} rowId index of the row to focus
    * @param {string} closestColumnToUse Which closest column cell to use when the cell is spanned by `colSpan`.
+   * @param {string} rowSpanScanDirection Which direction to search to find the next cell not hidden by `rowSpan`.
    * TODO replace with apiRef.current.moveFocusToRelativeCell()
    */
-  const goToCell = React.useCallback((colIndex, rowId, closestColumnToUse = 'left') => {
+  const goToCell = React.useCallback((colIndex, rowId, closestColumnToUse = 'left', rowSpanScanDirection = 'up') => {
     const visibleSortedRows = gridExpandedSortedRowEntriesSelector(apiRef);
     const nextCellColSpanInfo = apiRef.current.unstable_getCellColSpanInfo(rowId, colIndex);
     if (nextCellColSpanInfo && nextCellColSpanInfo.spannedByColSpan) {
@@ -87,16 +50,17 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
         colIndex = nextCellColSpanInfo.rightVisibleCellIndex;
       }
     }
+    const field = gridVisibleColumnFieldsSelector(apiRef)[colIndex];
+    const nonRowSpannedRowId = findNonRowSpannedCell(apiRef, rowId, field, rowSpanScanDirection);
     // `scrollToIndexes` requires a rowIndex relative to all visible rows.
     // Those rows do not include pinned rows, but pinned rows do not need scroll anyway.
-    const rowIndexRelativeToAllRows = visibleSortedRows.findIndex(row => row.id === rowId);
+    const rowIndexRelativeToAllRows = visibleSortedRows.findIndex(row => row.id === nonRowSpannedRowId);
     logger.debug(`Navigating to cell row ${rowIndexRelativeToAllRows}, col ${colIndex}`);
     apiRef.current.scrollToIndexes({
       colIndex,
       rowIndex: rowIndexRelativeToAllRows
     });
-    const field = apiRef.current.getVisibleColumns()[colIndex].field;
-    apiRef.current.setCellFocus(rowId, field);
+    apiRef.current.setCellFocus(nonRowSpannedRowId, field);
   }, [apiRef, logger]);
   const goToHeader = React.useCallback((colIndex, event) => {
     logger.debug(`Navigating to header col ${colIndex}`);
@@ -432,7 +396,7 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
         {
           // "Enter" is only triggered by the row / cell editing feature
           if (rowIndexBefore < lastRowIndexInPage) {
-            goToCell(colIndexBefore, getRowIdFromIndex(rowIndexBefore + 1));
+            goToCell(colIndexBefore, getRowIdFromIndex(rowIndexBefore + 1), isRtl ? 'right' : 'left', 'down');
           }
           break;
         }

package/modern/hooks/features/keyboardNavigation/utils.js

@@ -0,0 +1,58 @@
+import { gridFilteredSortedRowIdsSelector } from "../filter/gridFilterSelector.js";
+import { gridRowSpanningHiddenCellsSelector } from "../rows/gridRowSpanningSelectors.js";
+import { gridPinnedRowsSelector } from "../rows/gridRowsSelector.js";
+export function enrichPageRowsWithPinnedRows(apiRef, rows) {
+  const pinnedRows = gridPinnedRowsSelector(apiRef) || {};
+  return [...(pinnedRows.top || []), ...rows, ...(pinnedRows.bottom || [])];
+}
+export const getLeftColumnIndex = ({
+  currentColIndex,
+  firstColIndex,
+  lastColIndex,
+  isRtl
+}) => {
+  if (isRtl) {
+    if (currentColIndex < lastColIndex) {
+      return currentColIndex + 1;
+    }
+  } else if (!isRtl) {
+    if (currentColIndex > firstColIndex) {
+      return currentColIndex - 1;
+    }
+  }
+  return null;
+};
+export const getRightColumnIndex = ({
+  currentColIndex,
+  firstColIndex,
+  lastColIndex,
+  isRtl
+}) => {
+  if (isRtl) {
+    if (currentColIndex > firstColIndex) {
+      return currentColIndex - 1;
+    }
+  } else if (!isRtl) {
+    if (currentColIndex < lastColIndex) {
+      return currentColIndex + 1;
+    }
+  }
+  return null;
+};
+export function findNonRowSpannedCell(apiRef, rowId, field, rowSpanScanDirection) {
+  const rowSpanHiddenCells = gridRowSpanningHiddenCellsSelector(apiRef);
+  if (!rowSpanHiddenCells[rowId]?.[field]) {
+    return rowId;
+  }
+  const filteredSortedRowIds = gridFilteredSortedRowIdsSelector(apiRef);
+  // find closest non row spanned cell in the given `rowSpanScanDirection`
+  let nextRowIndex = filteredSortedRowIds.indexOf(rowId) + (rowSpanScanDirection === 'down' ? 1 : -1);
+  while (nextRowIndex >= 0 && nextRowIndex < filteredSortedRowIds.length) {
+    const nextRowId = filteredSortedRowIds[nextRowIndex];
+    if (!rowSpanHiddenCells[nextRowId]?.[field]) {
+      return nextRowId;
+    }
+    nextRowIndex += rowSpanScanDirection === 'down' ? 1 : -1;
+  }
+  return rowId;
+}

package/modern/hooks/features/rowSelection/useGridRowSelection.js

@@ -3,11 +3,12 @@ import * as React from 'react';
 import { GridSignature, useGridApiEventHandler } from "../../utils/useGridApiEventHandler.js";
 import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
 import { useGridLogger } from "../../utils/useGridLogger.js";
-import { gridRowsLookupSelector } from "../rows/gridRowsSelector.js";
+import { useGridSelector } from "../../utils/useGridSelector.js";
+import { gridRowMaximumTreeDepthSelector, gridRowTreeSelector } from "../rows/gridRowsSelector.js";
 import { gridRowSelectionStateSelector, selectedGridRowsSelector, selectedIdsLookupSelector } from "./gridRowSelectionSelector.js";
 import { gridPaginatedVisibleSortedGridRowIdsSelector } from "../pagination/index.js";
 import { gridFocusCellSelector } from "../focus/gridFocusStateSelector.js";
-import { gridExpandedSortedRowIdsSelector, gridFilterModelSelector } from "../filter/gridFilterSelector.js";
+import { gridExpandedSortedRowIdsSelector, gridFilteredRowsLookupSelector } from "../filter/gridFilterSelector.js";
 import { GRID_CHECKBOX_SELECTION_COL_DEF, GRID_ACTIONS_COLUMN_TYPE } from "../../../colDef/index.js";
 import { GridCellModes } from "../../../models/gridEditRowModel.js";
 import { isKeyboardEvent, isNavigationKey } from "../../../utils/keyboardUtils.js";
@@ -15,7 +16,7 @@ import { useGridVisibleRows } from "../../utils/useGridVisibleRows.js";
 import { GRID_DETAIL_PANEL_TOGGLE_FIELD } from "../../../constants/gridDetailPanelToggleField.js";
 import { gridClasses } from "../../../constants/gridClasses.js";
 import { isEventTargetInPortal } from "../../../utils/domUtils.js";
-import { isMultipleRowSelectionEnabled } from "./utils.js";
+import { isMultipleRowSelectionEnabled, findRowsToSelect, findRowsToDeselect } from "./utils.js";
 const getSelectionModelPropValue = (selectionModelProp, prevSelectionModel) => {
   if (selectionModelProp == null) {
     return selectionModelProp;
@@ -40,11 +41,12 @@ export const rowSelectionStateInitializer = (state, props) => _extends({}, state
  */
 export const useGridRowSelection = (apiRef, props) => {
   const logger = useGridLogger(apiRef, 'useGridSelection');
-  const runIfRowSelectionIsEnabled = callback => (...args) => {
+  const runIfRowSelectionIsEnabled = React.useCallback(callback => (...args) => {
     if (props.rowSelection) {
       callback(...args);
     }
-  };
+  }, [props.rowSelection]);
+  const applyAutoSelection = props.signature !== GridSignature.DataGrid && (props.rowSelectionPropagation?.parents || props.rowSelectionPropagation?.descendants);
   const propRowSelectionModel = React.useMemo(() => {
     return getSelectionModelPropValue(props.rowSelectionModel, gridRowSelectionStateSelector(apiRef.current.state));
   }, [apiRef, props.rowSelectionModel]);
@@ -63,6 +65,8 @@ export const useGridRowSelection = (apiRef, props) => {
   } = props;
   const canHaveMultipleSelection = isMultipleRowSelectionEnabled(props);
   const visibleRows = useGridVisibleRows(apiRef, props);
+  const tree = useGridSelector(apiRef, gridRowTreeSelector);
+  const isNestedData = useGridSelector(apiRef, gridRowMaximumTreeDepthSelector) > 1;
   const expandMouseRowRangeSelection = React.useCallback(id => {
     let endId = id;
     const startId = lastRowToggled.current ?? id;
@@ -87,7 +91,7 @@ export const useGridRowSelection = (apiRef, props) => {
     }, !isSelected);
   }, [apiRef]);
 
-  /**
+  /*
    * API METHODS
    */
   const setRowSelectionModel = React.useCallback(model => {
@@ -125,34 +129,80 @@ export const useGridRowSelection = (apiRef, props) => {
     lastRowToggled.current = id;
     if (resetSelection) {
       logger.debug(`Setting selection for row ${id}`);
-      apiRef.current.setRowSelectionModel(isSelected ? [id] : []);
+      const newSelection = [];
+      const addRow = rowId => {
+        newSelection.push(rowId);
+      };
+      if (isSelected) {
+        addRow(id);
+        if (applyAutoSelection) {
+          findRowsToSelect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, addRow);
+        }
+      }
+      apiRef.current.setRowSelectionModel(newSelection);
     } else {
       logger.debug(`Toggling selection for row ${id}`);
       const selection = gridRowSelectionStateSelector(apiRef.current.state);
-      const newSelection = selection.filter(el => el !== id);
+      const newSelection = new Set(selection);
+      newSelection.delete(id);
+      const addRow = rowId => {
+        newSelection.add(rowId);
+      };
+      const removeRow = rowId => {
+        newSelection.delete(rowId);
+      };
       if (isSelected) {
-        newSelection.push(id);
+        addRow(id);
+        if (applyAutoSelection) {
+          findRowsToSelect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, addRow);
+        }
+      } else if (applyAutoSelection) {
+        findRowsToDeselect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, removeRow);
       }
-      const isSelectionValid = newSelection.length < 2 || canHaveMultipleSelection;
+      const isSelectionValid = newSelection.size < 2 || canHaveMultipleSelection;
       if (isSelectionValid) {
-        apiRef.current.setRowSelectionModel(newSelection);
+        apiRef.current.setRowSelectionModel(Array.from(newSelection));
       }
     }
-  }, [apiRef, logger, canHaveMultipleSelection]);
+  }, [apiRef, logger, applyAutoSelection, tree, props.rowSelectionPropagation?.descendants, props.rowSelectionPropagation?.parents, canHaveMultipleSelection]);
   const selectRows = React.useCallback((ids, isSelected = true, resetSelection = false) => {
     logger.debug(`Setting selection for several rows`);
     const selectableIds = ids.filter(id => apiRef.current.isRowSelectable(id));
     let newSelection;
     if (resetSelection) {
-      newSelection = isSelected ? selectableIds : [];
+      if (isSelected) {
+        newSelection = selectableIds;
+        if (applyAutoSelection) {
+          const addRow = rowId => {
+            newSelection.push(rowId);
+          };
+          selectableIds.forEach(id => {
+            findRowsToSelect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, addRow);
+          });
+        }
+      } else {
+        newSelection = [];
+      }
     } else {
       // We clone the existing object to avoid mutating the same object returned by the selector to others part of the project
       const selectionLookup = _extends({}, selectedIdsLookupSelector(apiRef));
+      const addRow = rowId => {
+        selectionLookup[rowId] = rowId;
+      };
+      const removeRow = rowId => {
+        delete selectionLookup[rowId];
+      };
       selectableIds.forEach(id => {
         if (isSelected) {
           selectionLookup[id] = id;
+          if (applyAutoSelection) {
+            findRowsToSelect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, addRow);
+          }
         } else {
-          delete selectionLookup[id];
+          removeRow(id);
+          if (applyAutoSelection) {
+            findRowsToDeselect(apiRef, tree, id, props.rowSelectionPropagation?.descendants ?? false, props.rowSelectionPropagation?.parents ?? false, removeRow);
+          }
         }
       });
       newSelection = Object.values(selectionLookup);
@@ -161,7 +211,7 @@ export const useGridRowSelection = (apiRef, props) => {
     if (isSelectionValid) {
       apiRef.current.setRowSelectionModel(newSelection);
     }
-  }, [apiRef, logger, canHaveMultipleSelection]);
+  }, [logger, applyAutoSelection, canHaveMultipleSelection, apiRef, tree, props.rowSelectionPropagation?.descendants, props.rowSelectionPropagation?.parents]);
   const selectRowRange = React.useCallback(({
     startId,
     endId
@@ -193,29 +243,52 @@ export const useGridRowSelection = (apiRef, props) => {
   useGridApiMethod(apiRef, selectionPublicApi, 'public');
   useGridApiMethod(apiRef, selectionPrivateApi, props.signature === GridSignature.DataGrid ? 'private' : 'public');
 
-  /**
+  /*
    * EVENTS
    */
-  const removeOutdatedSelection = React.useCallback(() => {
-    if (props.keepNonExistentRowsSelected) {
-      return;
-    }
+  const removeOutdatedSelection = React.useCallback((sortModelUpdated = false) => {
     const currentSelection = gridRowSelectionStateSelector(apiRef.current.state);
-    const rowsLookup = gridRowsLookupSelector(apiRef);
+    const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
 
     // We clone the existing object to avoid mutating the same object returned by the selector to others part of the project
     const selectionLookup = _extends({}, selectedIdsLookupSelector(apiRef));
     let hasChanged = false;
     currentSelection.forEach(id => {
-      if (!rowsLookup[id]) {
+      if (filteredRowsLookup[id] === false) {
+        if (props.keepNonExistentRowsSelected) {
+          return;
+        }
         delete selectionLookup[id];
         hasChanged = true;
+        return;
+      }
+      if (!props.rowSelectionPropagation?.parents) {
+        return;
+      }
+      const node = tree[id];
+      if (node.type === 'group') {
+        const isAutoGenerated = node.isAutoGenerated;
+        if (isAutoGenerated) {
+          delete selectionLookup[id];
+          hasChanged = true;
+          return;
+        }
+        // Keep previously selected tree data parents selected if all their children are filtered out
+        if (!node.children.every(childId => filteredRowsLookup[childId] === false)) {
+          delete selectionLookup[id];
+          hasChanged = true;
+        }
       }
     });
-    if (hasChanged) {
-      apiRef.current.setRowSelectionModel(Object.values(selectionLookup));
+    if (hasChanged || isNestedData && !sortModelUpdated) {
+      const newSelection = Object.values(selectionLookup);
+      if (isNestedData) {
+        apiRef.current.selectRows(newSelection, true, true);
+      } else {
+        apiRef.current.setRowSelectionModel(newSelection);
+      }
     }
-  }, [apiRef, props.keepNonExistentRowsSelected]);
+  }, [apiRef, isNestedData, props.rowSelectionPropagation?.parents, props.keepNonExistentRowsSelected, tree]);
   const handleSingleRowSelection = React.useCallback((id, event) => {
     const hasCtrlKey = event.metaKey || event.ctrlKey;
 
@@ -276,8 +349,7 @@ export const useGridRowSelection = (apiRef, props) => {
   }, [apiRef, expandMouseRowRangeSelection, canHaveMultipleSelection]);
   const handleHeaderSelectionCheckboxChange = React.useCallback(params => {
     const rowsToBeSelected = props.pagination && props.checkboxSelectionVisibleOnly && props.paginationMode === 'client' ? gridPaginatedVisibleSortedGridRowIdsSelector(apiRef) : gridExpandedSortedRowIdsSelector(apiRef);
-    const filterModel = gridFilterModelSelector(apiRef);
-    apiRef.current.selectRows(rowsToBeSelected, params.value, filterModel?.items.length > 0);
+    apiRef.current.selectRows(rowsToBeSelected, params.value);
   }, [apiRef, props.checkboxSelectionVisibleOnly, props.pagination, props.paginationMode]);
   const handleCellKeyDown = React.useCallback((params, event) => {
     // Get the most recent cell mode because it may have been changed by another listener
@@ -341,14 +413,15 @@ export const useGridRowSelection = (apiRef, props) => {
       selectRows(apiRef.current.getAllRowIds(), true);
     }
   }, [apiRef, handleSingleRowSelection, selectRows, visibleRows.rows, canHaveMultipleSelection]);
-  useGridApiEventHandler(apiRef, 'sortedRowsSet', runIfRowSelectionIsEnabled(removeOutdatedSelection));
+  useGridApiEventHandler(apiRef, 'sortedRowsSet', runIfRowSelectionIsEnabled(() => removeOutdatedSelection(true)));
+  useGridApiEventHandler(apiRef, 'filteredRowsSet', runIfRowSelectionIsEnabled(removeOutdatedSelection));
   useGridApiEventHandler(apiRef, 'rowClick', runIfRowSelectionIsEnabled(handleRowClick));
   useGridApiEventHandler(apiRef, 'rowSelectionCheckboxChange', runIfRowSelectionIsEnabled(handleRowSelectionCheckboxChange));
   useGridApiEventHandler(apiRef, 'headerSelectionCheckboxChange', handleHeaderSelectionCheckboxChange);
   useGridApiEventHandler(apiRef, 'cellMouseDown', runIfRowSelectionIsEnabled(preventSelectionOnShift));
   useGridApiEventHandler(apiRef, 'cellKeyDown', runIfRowSelectionIsEnabled(handleCellKeyDown));
 
-  /**
+  /*
    * EFFECTS
    */
   React.useEffect(() => {
@@ -386,4 +459,7 @@ export const useGridRowSelection = (apiRef, props) => {
       apiRef.current.setRowSelectionModel([]);
     }
   }, [apiRef, canHaveMultipleSelection, checkboxSelection, isStateControlled, props.rowSelection]);
+  React.useEffect(() => {
+    runIfRowSelectionIsEnabled(removeOutdatedSelection);
+  }, [removeOutdatedSelection, runIfRowSelectionIsEnabled]);
 };

package/modern/hooks/features/rowSelection/utils.js

@@ -1,8 +1,163 @@
 import { GridSignature } from "../../utils/useGridApiEventHandler.js";
+import { GRID_ROOT_GROUP_ID } from "../rows/gridRowsUtils.js";
+import { gridFilteredRowsLookupSelector } from "../filter/gridFilterSelector.js";
+import { gridSortedRowIdsSelector } from "../sorting/gridSortingSelector.js";
+import { selectedIdsLookupSelector } from "./gridRowSelectionSelector.js";
+import { gridRowTreeSelector } from "../rows/gridRowsSelector.js";
+import { createSelector } from "../../../utils/createSelector.js";
+export const ROW_SELECTION_PROPAGATION_DEFAULT = {
+  parents: false,
+  descendants: false
+};
+function getGridRowGroupSelectableDescendants(apiRef, groupId) {
+  const rowTree = gridRowTreeSelector(apiRef);
+  const sortedRowIds = gridSortedRowIdsSelector(apiRef);
+  const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
+  const groupNode = rowTree[groupId];
+  if (!groupNode || groupNode.type !== 'group') {
+    return [];
+  }
+  const descendants = [];
+  const startIndex = sortedRowIds.findIndex(id => id === groupId) + 1;
+  for (let index = startIndex; index < sortedRowIds.length && rowTree[sortedRowIds[index]]?.depth > groupNode.depth; index += 1) {
+    const id = sortedRowIds[index];
+    if (filteredRowsLookup[id] !== false && apiRef.current.isRowSelectable(id)) {
+      descendants.push(id);
+    }
+  }
+  return descendants;
+}
+
+// TODO v8: Use `createSelectorV8`
+export function getCheckboxPropsSelector(groupId, autoSelectParents) {
+  return createSelector(gridRowTreeSelector, gridSortedRowIdsSelector, gridFilteredRowsLookupSelector, selectedIdsLookupSelector, (rowTree, sortedRowIds, filteredRowsLookup, rowSelectionLookup) => {
+    const groupNode = rowTree[groupId];
+    if (!groupNode || groupNode.type !== 'group') {
+      return {
+        isIndeterminate: false,
+        isChecked: rowSelectionLookup[groupId] === groupId
+      };
+    }
+    if (rowSelectionLookup[groupId] === groupId) {
+      return {
+        isIndeterminate: false,
+        isChecked: true
+      };
+    }
+    let selectableDescendentsCount = 0;
+    let selectedDescendentsCount = 0;
+    const startIndex = sortedRowIds.findIndex(id => id === groupId) + 1;
+    for (let index = startIndex; index < sortedRowIds.length && rowTree[sortedRowIds[index]]?.depth > groupNode.depth; index += 1) {
+      const id = sortedRowIds[index];
+      if (filteredRowsLookup[id] !== false) {
+        selectableDescendentsCount += 1;
+        if (rowSelectionLookup[id] !== undefined) {
+          selectedDescendentsCount += 1;
+        }
+      }
+    }
+    return {
+      isIndeterminate: selectedDescendentsCount > 0 && selectedDescendentsCount < selectableDescendentsCount || selectedDescendentsCount === selectableDescendentsCount && rowSelectionLookup[groupId] === undefined,
+      isChecked: autoSelectParents ? selectedDescendentsCount > 0 : rowSelectionLookup[groupId] === groupId
+    };
+  });
+}
 export function isMultipleRowSelectionEnabled(props) {
   if (props.signature === GridSignature.DataGrid) {
     // DataGrid Community has multiple row selection enabled only if checkbox selection is enabled.
     return props.checkboxSelection && props.disableMultipleRowSelection !== true;
   }
   return !props.disableMultipleRowSelection;
-}
+}
+const getRowNodeParents = (tree, id) => {
+  const parents = [];
+  let parent = id;
+  while (parent != null && parent !== GRID_ROOT_GROUP_ID) {
+    const node = tree[parent];
+    if (!node) {
+      return parents;
+    }
+    parents.push(parent);
+    parent = node.parent;
+  }
+  return parents;
+};
+const getFilteredRowNodeSiblings = (tree, filteredRows, id) => {
+  const node = tree[id];
+  if (!node) {
+    return [];
+  }
+  const parent = node.parent;
+  if (parent == null) {
+    return [];
+  }
+  const parentNode = tree[parent];
+  return parentNode.children.filter(childId => childId !== id && filteredRows[childId]);
+};
+export const findRowsToSelect = (apiRef, tree, selectedRow, autoSelectDescendants, autoSelectParents, addRow) => {
+  const filteredRows = gridFilteredRowsLookupSelector(apiRef);
+  const selectedIdsLookup = selectedIdsLookupSelector(apiRef);
+  const selectedDescendants = new Set([]);
+  if (!autoSelectDescendants && !autoSelectParents) {
+    return;
+  }
+  if (autoSelectDescendants) {
+    const rowNode = tree[selectedRow];
+    if (rowNode?.type === 'group') {
+      const descendants = getGridRowGroupSelectableDescendants(apiRef, selectedRow);
+      descendants.forEach(rowId => {
+        addRow(rowId);
+        selectedDescendants.add(rowId);
+      });
+    }
+  }
+  if (autoSelectParents) {
+    const checkAllDescendantsSelected = rowId => {
+      if (selectedIdsLookup[rowId] !== rowId && !selectedDescendants.has(rowId)) {
+        return false;
+      }
+      const node = tree[rowId];
+      if (node?.type !== 'group') {
+        return true;
+      }
+      return node.children.every(checkAllDescendantsSelected);
+    };
+    const traverseParents = rowId => {
+      const siblings = getFilteredRowNodeSiblings(tree, filteredRows, rowId);
+      if (siblings.length === 0 || siblings.every(checkAllDescendantsSelected)) {
+        const rowNode = tree[rowId];
+        const parent = rowNode.parent;
+        if (parent != null && parent !== GRID_ROOT_GROUP_ID && apiRef.current.isRowSelectable(parent)) {
+          addRow(parent);
+          selectedDescendants.add(parent);
+          traverseParents(parent);
+        }
+      }
+    };
+    traverseParents(selectedRow);
+  }
+};
+export const findRowsToDeselect = (apiRef, tree, deselectedRow, autoSelectDescendants, autoSelectParents, removeRow) => {
+  const selectedIdsLookup = selectedIdsLookupSelector(apiRef);
+  if (!autoSelectParents && !autoSelectDescendants) {
+    return;
+  }
+  if (autoSelectParents) {
+    const allParents = getRowNodeParents(tree, deselectedRow);
+    allParents.forEach(parent => {
+      const isSelected = selectedIdsLookup[parent] === parent;
+      if (isSelected) {
+        removeRow(parent);
+      }
+    });
+  }
+  if (autoSelectDescendants) {
+    const rowNode = tree[deselectedRow];
+    if (rowNode?.type === 'group') {
+      const descendants = getGridRowGroupSelectableDescendants(apiRef, deselectedRow);
+      descendants.forEach(descendant => {
+        removeRow(descendant);
+      });
+    }
+  }
+};

package/modern/hooks/features/rows/gridRowSpanningSelectors.js

@@ -0,0 +1,5 @@
+import { createSelector } from "../../../utils/createSelector.js";
+const gridRowSpanningStateSelector = state => state.rowSpanning;
+export const gridRowSpanningHiddenCellsSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.hiddenCells);
+export const gridRowSpanningSpannedCellsSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.spannedCells);
+export const gridRowSpanningHiddenCellsOriginMapSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.hiddenCellOriginMap);

package/modern/hooks/features/rows/gridRowSpanningUtils.js

@@ -0,0 +1,42 @@
+export function getUnprocessedRange(testRange, processedRange) {
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return null;
+  }
+  // Overflowing at the end
+  // Example: testRange={ firstRowIndex: 10, lastRowIndex: 20 }, processedRange={ firstRowIndex: 0, lastRowIndex: 15 }
+  // Unprocessed Range={ firstRowIndex: 16, lastRowIndex: 20 }
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex > processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: processedRange.lastRowIndex,
+      lastRowIndex: testRange.lastRowIndex
+    };
+  }
+  // Overflowing at the beginning
+  // Example: testRange={ firstRowIndex: 0, lastRowIndex: 20 }, processedRange={ firstRowIndex: 16, lastRowIndex: 30 }
+  // Unprocessed Range={ firstRowIndex: 0, lastRowIndex: 15 }
+  if (testRange.firstRowIndex < processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: testRange.firstRowIndex,
+      lastRowIndex: processedRange.firstRowIndex - 1
+    };
+  }
+  // TODO: Should return two ranges handle overflowing at both ends ?
+  return testRange;
+}
+export function isRowContextInitialized(renderContext) {
+  return renderContext.firstRowIndex !== 0 || renderContext.lastRowIndex !== 0;
+}
+export function isRowRangeUpdated(range1, range2) {
+  return range1.firstRowIndex !== range2.firstRowIndex || range1.lastRowIndex !== range2.lastRowIndex;
+}
+export const getCellValue = (row, colDef, apiRef) => {
+  if (!row) {
+    return null;
+  }
+  let cellValue = row[colDef.field];
+  const valueGetter = colDef.rowSpanValueGetter ?? colDef.valueGetter;
+  if (valueGetter) {
+    cellValue = valueGetter(cellValue, row, colDef, apiRef);
+  }
+  return cellValue;
+};