@mui/x-data-grid-premium 8.0.0-beta.3 → 8.0.0

package/esm/hooks/features/pivoting/useGridPivoting.js

@@ -0,0 +1,339 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { gridDataRowIdsSelector, gridRowIdSelector, gridRowsLoadingSelector, gridRowsLookupSelector } from '@mui/x-data-grid-pro';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import useOnMount from '@mui/utils/useOnMount';
+import { useGridApiMethod, useGridRegisterPipeProcessor, useGridSelector, gridPivotInitialColumnsSelector } from '@mui/x-data-grid-pro/internals';
+import { gridPivotModelSelector, gridPivotActiveSelector, gridPivotPanelOpenSelector } from "./gridPivotingSelectors.js";
+import { getInitialColumns, getPivotedData, isPivotingAvailable as isPivotingAvailableFn } from "./utils.js";
+import { getAvailableAggregationFunctions } from "../aggregation/gridAggregationUtils.js";
+const emptyPivotModel = {
+  rows: [],
+  columns: [],
+  values: []
+};
+export const pivotingStateInitializer = (state, props, apiRef) => {
+  if (!isPivotingAvailableFn(props)) {
+    return _extends({}, state, {
+      pivoting: {
+        active: false,
+        model: emptyPivotModel,
+        panelOpen: false
+      }
+    });
+  }
+  const initialColumns = getInitialColumns(props.columns ?? [], props.getPivotDerivedColumns, apiRef.current.getLocaleText);
+  return _extends({}, state, {
+    pivoting: {
+      active: props.pivotActive ?? props.initialState?.pivoting?.enabled ?? false,
+      model: props.pivotModel ?? props.initialState?.pivoting?.model ?? emptyPivotModel,
+      panelOpen: props.pivotPanelOpen ?? props.initialState?.pivoting?.panelOpen ?? false,
+      initialColumns
+    }
+  });
+};
+export const useGridPivoting = (apiRef, props, originalColumnsProp, originalRowsProp) => {
+  const isPivotActive = useGridSelector(apiRef, gridPivotActiveSelector);
+  const exportedStateRef = React.useRef(null);
+  const nonPivotDataRef = React.useRef(undefined);
+  const isPivotingAvailable = isPivotingAvailableFn(props);
+  apiRef.current.registerControlState({
+    stateId: 'pivotModel',
+    propModel: props.pivotModel,
+    propOnChange: props.onPivotModelChange,
+    stateSelector: gridPivotModelSelector,
+    changeEvent: 'pivotModelChange'
+  });
+  apiRef.current.registerControlState({
+    stateId: 'pivotMode',
+    propModel: props.pivotActive,
+    propOnChange: props.onPivotActiveChange,
+    stateSelector: gridPivotActiveSelector,
+    changeEvent: 'pivotModeChange'
+  });
+  apiRef.current.registerControlState({
+    stateId: 'pivotPanelOpen',
+    propModel: props.pivotPanelOpen,
+    propOnChange: props.onPivotPanelOpenChange,
+    stateSelector: gridPivotPanelOpenSelector,
+    changeEvent: 'pivotPanelOpenChange'
+  });
+  const getInitialData = React.useCallback(() => {
+    if (!exportedStateRef.current) {
+      exportedStateRef.current = apiRef.current.exportState();
+    }
+    const rowIds = gridDataRowIdsSelector(apiRef);
+    const rowsLookup = gridRowsLookupSelector(apiRef);
+    const rows = rowIds.map(id => rowsLookup[id]);
+    const initialColumns = getInitialColumns(originalColumnsProp, props.getPivotDerivedColumns, apiRef.current.getLocaleText);
+    return {
+      rows,
+      columns: initialColumns
+    };
+  }, [apiRef, props.getPivotDerivedColumns, originalColumnsProp]);
+  const computePivotingState = React.useCallback(({
+    active,
+    model: pivotModel
+  }) => {
+    if (active && pivotModel) {
+      const {
+        rows,
+        columns
+      } = nonPivotDataRef.current || {
+        rows: [],
+        columns: new Map()
+      };
+      return {
+        initialColumns: columns,
+        // TODO: fix getPivotedData called twice in controlled mode
+        propsOverrides: getPivotedData({
+          rows,
+          columns,
+          pivotModel,
+          apiRef: apiRef,
+          pivotingColDef: props.pivotingColDef
+        })
+      };
+    }
+    return undefined;
+  }, [apiRef, props.pivotingColDef]);
+  useOnMount(() => {
+    if (!isPivotingAvailable || !isPivotActive) {
+      return undefined;
+    }
+    const isLoading = gridRowsLoadingSelector(apiRef) ?? false;
+    const runPivoting = () => {
+      nonPivotDataRef.current = getInitialData();
+      apiRef.current.setState(state => {
+        const pivotingState = _extends({}, state.pivoting, computePivotingState(state.pivoting));
+        return _extends({}, state, {
+          pivoting: pivotingState
+        });
+      });
+    };
+    if (!isLoading) {
+      runPivoting();
+      return undefined;
+    }
+    const unsubscribe = apiRef.current?.store.subscribe(() => {
+      const loading = gridRowsLoadingSelector(apiRef);
+      if (loading === false) {
+        unsubscribe();
+        runPivoting();
+      }
+    });
+    return unsubscribe;
+  });
+  useEnhancedEffect(() => {
+    if (!isPivotingAvailable || !isPivotActive) {
+      if (exportedStateRef.current) {
+        apiRef.current.restoreState(exportedStateRef.current);
+        exportedStateRef.current = null;
+      }
+      if (nonPivotDataRef.current) {
+        apiRef.current.setRows(nonPivotDataRef.current.rows);
+        nonPivotDataRef.current = undefined;
+      }
+    }
+  }, [isPivotActive, apiRef, isPivotingAvailable]);
+  const setPivotModel = React.useCallback(callback => {
+    if (!isPivotingAvailable) {
+      return;
+    }
+    apiRef.current.setState(state => {
+      const newPivotModel = typeof callback === 'function' ? callback(state.pivoting?.model) : callback;
+      if (state.pivoting?.model === newPivotModel) {
+        return state;
+      }
+      const newPivotingState = _extends({}, state.pivoting, computePivotingState(_extends({}, state.pivoting, {
+        model: newPivotModel
+      })), {
+        model: newPivotModel
+      });
+      return _extends({}, state, {
+        pivoting: newPivotingState
+      });
+    });
+  }, [apiRef, computePivotingState, isPivotingAvailable]);
+  const updatePivotModel = React.useCallback(({
+    field,
+    targetSection,
+    originSection,
+    targetField,
+    targetFieldPosition
+  }) => {
+    if (field === targetField) {
+      return;
+    }
+    apiRef.current.setPivotModel(prev => {
+      const newModel = _extends({}, prev);
+      const isSameSection = targetSection === originSection;
+      const hidden = originSection === null ? false : prev[originSection].find(item => item.field === field)?.hidden ?? false;
+      if (targetSection) {
+        const newSectionArray = [...prev[targetSection]];
+        let toIndex = newSectionArray.length;
+        if (targetField) {
+          const fromIndex = newSectionArray.findIndex(item => item.field === field);
+          if (fromIndex > -1) {
+            newSectionArray.splice(fromIndex, 1);
+          }
+          toIndex = newSectionArray.findIndex(item => item.field === targetField);
+          if (targetFieldPosition === 'bottom') {
+            toIndex += 1;
+          }
+        }
+        if (targetSection === 'values') {
+          const initialColumns = gridPivotInitialColumnsSelector(apiRef);
+          const aggFunc = isSameSection ? prev.values.find(item => item.field === field)?.aggFunc : getAvailableAggregationFunctions({
+            aggregationFunctions: props.aggregationFunctions,
+            colDef: initialColumns.get(field),
+            isDataSource: false
+          })[0];
+          newSectionArray.splice(toIndex, 0, {
+            field,
+            aggFunc,
+            hidden
+          });
+          newModel.values = newSectionArray;
+        } else if (targetSection === 'columns') {
+          const sort = isSameSection ? prev.columns.find(item => item.field === field)?.sort : undefined;
+          newSectionArray.splice(toIndex, 0, {
+            field,
+            sort,
+            hidden
+          });
+          newModel.columns = newSectionArray;
+        } else if (targetSection === 'rows') {
+          newSectionArray.splice(toIndex, 0, {
+            field,
+            hidden
+          });
+          newModel.rows = newSectionArray;
+        }
+      }
+      if (!isSameSection && originSection) {
+        newModel[originSection] = prev[originSection].filter(f => f.field !== field);
+      }
+      return newModel;
+    });
+  }, [apiRef, props.aggregationFunctions]);
+  const setPivotActive = React.useCallback(callback => {
+    if (!isPivotingAvailable) {
+      return;
+    }
+    apiRef.current.selectRows([], false, true);
+    apiRef.current.setState(state => {
+      const newPivotMode = typeof callback === 'function' ? callback(state.pivoting?.active) : callback;
+      if (state.pivoting?.active === newPivotMode) {
+        return state;
+      }
+      if (newPivotMode) {
+        nonPivotDataRef.current = getInitialData();
+      }
+      const newPivotingState = _extends({}, state.pivoting, computePivotingState(_extends({}, state.pivoting, {
+        active: newPivotMode
+      })), {
+        active: newPivotMode
+      });
+      const newState = _extends({}, state, {
+        pivoting: newPivotingState
+      });
+      return newState;
+    });
+  }, [apiRef, computePivotingState, getInitialData, isPivotingAvailable]);
+  const setPivotPanelOpen = React.useCallback(callback => {
+    if (!isPivotingAvailable) {
+      return;
+    }
+    apiRef.current.setState(state => _extends({}, state, {
+      pivoting: _extends({}, state.pivoting, {
+        panelOpen: typeof callback === 'function' ? callback(state.pivoting?.panelOpen) : callback
+      })
+    }));
+  }, [apiRef, isPivotingAvailable]);
+  const addColumnMenuButton = React.useCallback(menuItems => {
+    if (isPivotingAvailable) {
+      return [...menuItems, 'columnMenuPivotItem'];
+    }
+    return menuItems;
+  }, [isPivotingAvailable]);
+  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButton);
+  const updateNonPivotColumns = React.useCallback((columns, keepPreviousColumns = true) => {
+    if (!nonPivotDataRef.current || !isPivotingAvailable) {
+      return;
+    }
+    if (keepPreviousColumns) {
+      getInitialColumns(columns, props.getPivotDerivedColumns, apiRef.current.getLocaleText).forEach(col => {
+        nonPivotDataRef.current.columns.set(col.field, col);
+      });
+    } else {
+      nonPivotDataRef.current.columns = getInitialColumns(columns, props.getPivotDerivedColumns, apiRef.current.getLocaleText);
+    }
+    apiRef.current.setState(state => {
+      return _extends({}, state, {
+        pivoting: _extends({}, state.pivoting, computePivotingState(state.pivoting), {
+          initialColumns: nonPivotDataRef.current?.columns
+        })
+      });
+    });
+  }, [isPivotingAvailable, apiRef, props.getPivotDerivedColumns, computePivotingState]);
+  const updateNonPivotRows = React.useCallback((rows, keepPreviousRows = true) => {
+    if (!nonPivotDataRef.current || !rows || rows.length === 0) {
+      return;
+    }
+    if (keepPreviousRows) {
+      const rowsMap = new Map();
+      nonPivotDataRef.current.rows.forEach(row => {
+        rowsMap.set(gridRowIdSelector(apiRef, row), row);
+      });
+      rows.forEach(row => {
+        const rowId = gridRowIdSelector(apiRef, row);
+        // eslint-disable-next-line no-underscore-dangle
+        if (row._action === 'delete') {
+          rowsMap.delete(rowId);
+        } else {
+          rowsMap.set(rowId, row);
+        }
+      });
+      nonPivotDataRef.current.rows = Array.from(rowsMap.values());
+    } else {
+      nonPivotDataRef.current.rows = rows;
+    }
+    apiRef.current.setState(state => {
+      return _extends({}, state, {
+        pivoting: _extends({}, state.pivoting, computePivotingState(state.pivoting))
+      });
+    });
+  }, [apiRef, computePivotingState]);
+  useGridApiMethod(apiRef, {
+    setPivotModel,
+    setPivotActive,
+    setPivotPanelOpen
+  }, 'public');
+  useGridApiMethod(apiRef, {
+    updatePivotModel,
+    updateNonPivotColumns,
+    updateNonPivotRows
+  }, 'private');
+  useEnhancedEffect(() => {
+    apiRef.current.updateNonPivotColumns(originalColumnsProp, false);
+  }, [originalColumnsProp, apiRef]);
+  useEnhancedEffect(() => {
+    apiRef.current.updateNonPivotRows(originalRowsProp, false);
+  }, [originalRowsProp, apiRef]);
+  useEnhancedEffect(() => {
+    if (props.pivotModel !== undefined) {
+      apiRef.current.setPivotModel(props.pivotModel);
+    }
+  }, [apiRef, props.pivotModel]);
+  useEnhancedEffect(() => {
+    if (props.pivotActive !== undefined) {
+      apiRef.current.setPivotActive(props.pivotActive);
+    }
+  }, [apiRef, props.pivotActive]);
+  useEnhancedEffect(() => {
+    if (props.pivotPanelOpen !== undefined) {
+      apiRef.current.setPivotPanelOpen(props.pivotPanelOpen);
+    }
+  }, [apiRef, props.pivotPanelOpen]);
+};

package/esm/hooks/features/pivoting/utils.d.ts

@@ -0,0 +1,21 @@
+import { GridColDef, GridRowModel, GridLocaleTextApi } from '@mui/x-data-grid-pro';
+import type { RefObject } from '@mui/x-internals/types';
+import type { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
+import type { GridApiPremium } from '../../../models/gridApiPremium';
+import type { GridPivotingPropsOverrides, GridPivotModel } from './gridPivotingInterfaces';
+export declare const isPivotingAvailable: (props: Pick<DataGridPremiumProcessedProps, "disablePivoting">) => boolean;
+export declare const defaultGetPivotDerivedColumns: DataGridPremiumProcessedProps['getPivotDerivedColumns'];
+export declare const getInitialColumns: (originalColumns: DataGridPremiumProcessedProps["columns"], getPivotDerivedColumns: DataGridPremiumProcessedProps["getPivotDerivedColumns"], getLocaleText: GridLocaleTextApi["getLocaleText"]) => Map<string, GridColDef>;
+export declare const getPivotedData: ({
+  rows,
+  columns,
+  pivotModel,
+  apiRef,
+  pivotingColDef
+}: {
+  rows: GridRowModel[];
+  columns: Map<string, GridColDef>;
+  pivotModel: GridPivotModel;
+  apiRef: RefObject<GridApiPremium>;
+  pivotingColDef: DataGridPremiumProcessedProps["pivotingColDef"];
+}) => GridPivotingPropsOverrides;

package/esm/hooks/features/pivoting/utils.js

@@ -0,0 +1,259 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { isLeaf, gridStringOrNumberComparator } from '@mui/x-data-grid-pro';
+import { getDefaultColTypeDef } from '@mui/x-data-grid-pro/internals';
+import { isGroupingColumn } from "../rowGrouping/index.js";
+const columnGroupIdSeparator = '>->';
+export const isPivotingAvailable = props => {
+  return !props.disablePivoting;
+};
+export const defaultGetPivotDerivedColumns = (column, getLocaleText) => {
+  if (column.type === 'date') {
+    const field = column.field;
+    return [{
+      // String column type to avoid formatting the value as 2,025 instead of 2025
+      field: `${field}-year`,
+      headerName: `${column.headerName} ${getLocaleText('pivotYearColumnHeaderName')}`,
+      valueGetter: (value, row) => new Date(row[field]).getFullYear()
+    }, {
+      field: `${field}-quarter`,
+      headerName: `${column.headerName} ${getLocaleText('pivotQuarterColumnHeaderName')}`,
+      valueGetter: (value, row) => `Q${Math.floor(new Date(row[field]).getMonth() / 3) + 1}`
+    }];
+  }
+  return undefined;
+};
+export const getInitialColumns = (originalColumns, getPivotDerivedColumns, getLocaleText) => {
+  const initialColumns = new Map();
+  for (let i = 0; i < originalColumns.length; i += 1) {
+    const originalColumn = originalColumns[i];
+    const column = _extends({}, getDefaultColTypeDef(originalColumn.type), originalColumn);
+    const field = column.field;
+    if (!isGroupingColumn(field)) {
+      initialColumns.set(field, column);
+      const derivedColumns = getPivotDerivedColumns?.(column, getLocaleText);
+      if (derivedColumns) {
+        derivedColumns.forEach(col => initialColumns.set(col.field, col));
+      }
+    }
+  }
+  return initialColumns;
+};
+function sortColumnGroups(columnGroups, pivotModelColumns, depth = 0) {
+  if (depth > pivotModelColumns.length - 1) {
+    return;
+  }
+  const sort = pivotModelColumns[depth].sort;
+  columnGroups.sort((a, b) => {
+    if (isLeaf(a) || isLeaf(b)) {
+      return 0;
+    }
+    if (a.children) {
+      sortColumnGroups(a.children, pivotModelColumns, depth + 1);
+    }
+    if (b.children) {
+      sortColumnGroups(b.children, pivotModelColumns, depth + 1);
+    }
+    if (sort === undefined) {
+      return 0;
+    }
+    return (sort === 'asc' ? 1 : -1) * gridStringOrNumberComparator(a.headerName, b.headerName, {}, {});
+  });
+}
+export const getPivotedData = ({
+  rows,
+  columns,
+  pivotModel,
+  apiRef,
+  pivotingColDef
+}) => {
+  const visibleColumns = pivotModel.columns.filter(column => !column.hidden);
+  const visibleRows = pivotModel.rows.filter(row => !row.hidden);
+  const visibleValues = pivotModel.values.filter(value => !value.hidden);
+  let pivotColumns = [];
+  const columnVisibilityModel = {};
+  const pivotColumnsIncludedInPivotValues = [];
+  const initialColumns = new Map();
+  for (const column of columns.values()) {
+    if (!isGroupingColumn(column.field)) {
+      initialColumns.set(column.field, column);
+      const pivotValueIndex = visibleValues.findIndex(({
+        field
+      }) => field === column.field);
+      const isVisiblePivotValueField = pivotValueIndex !== -1;
+      const columnToAdd = _extends({}, column, {
+        aggregable: false,
+        groupable: false,
+        hideable: false,
+        editable: false,
+        disableReorder: true
+      });
+      if (isVisiblePivotValueField) {
+        // Store columns that are used as pivot values in a temporary array to keep them in the same order as in pivotModel.values, not in the order of the initial columns.
+        // `pivotColumnsIncludedInPivotValues` is concatenated to pivotColumns later.
+        pivotColumnsIncludedInPivotValues[pivotValueIndex] = columnToAdd;
+      } else {
+        pivotColumns.push(columnToAdd);
+      }
+      columnVisibilityModel[column.field] = false;
+    }
+  }
+  pivotColumns = pivotColumns.concat(pivotColumnsIncludedInPivotValues);
+  const getAttributesFromInitialColumn = field => {
+    const initialColumn = initialColumns.get(field);
+    if (!initialColumn) {
+      return undefined;
+    }
+    const attributes = {
+      width: initialColumn.width,
+      minWidth: initialColumn.minWidth,
+      maxWidth: initialColumn.maxWidth,
+      valueFormatter: initialColumn.valueFormatter,
+      headerName: initialColumn.headerName,
+      renderCell: initialColumn.renderCell,
+      display: initialColumn.display
+    };
+    return attributes;
+  };
+  const aggregationModel = {};
+  const columnGroupingModel = [];
+  const columnGroupingModelLookup = new Map();
+  let newRows = [];
+  if (visibleColumns.length === 0) {
+    newRows = rows;
+    visibleValues.forEach(pivotValue => {
+      aggregationModel[pivotValue.field] = pivotValue.aggFunc;
+      delete columnVisibilityModel[pivotValue.field];
+    });
+  } else {
+    for (let i = 0; i < rows.length; i += 1) {
+      const row = rows[i];
+      const newRow = _extends({}, row);
+      const columnGroupPath = [];
+      visibleColumns.forEach(({
+        field: colGroupField
+      }, depth) => {
+        const column = initialColumns.get(colGroupField);
+        if (!column) {
+          return;
+        }
+        let colValue = apiRef.current.getRowValue(row, column) ?? '(No value)';
+        if (column.type === 'singleSelect') {
+          const singleSelectColumn = column;
+          if (singleSelectColumn.getOptionLabel) {
+            colValue = singleSelectColumn.getOptionLabel(colValue);
+          }
+        }
+        columnGroupPath.push(String(colValue));
+        const groupId = columnGroupPath.join(columnGroupIdSeparator);
+        if (!columnGroupingModelLookup.has(groupId)) {
+          const columnGroup = {
+            groupId,
+            headerName: String(colValue),
+            children: []
+          };
+          columnGroupingModelLookup.set(groupId, columnGroup);
+          if (depth === 0) {
+            columnGroupingModel.push(columnGroup);
+          } else {
+            const parentGroupId = columnGroupPath.slice(0, -1).join(columnGroupIdSeparator);
+            const parentGroup = columnGroupingModelLookup.get(parentGroupId);
+            if (parentGroup) {
+              parentGroup.children.push(columnGroup);
+            }
+          }
+        }
+        const isLastColumnGroupLevel = depth === visibleColumns.length - 1;
+        if (isLastColumnGroupLevel) {
+          visibleValues.forEach(pivotValue => {
+            const valueField = pivotValue.field;
+            const originalColumn = initialColumns.get(valueField);
+            if (!originalColumn) {
+              return;
+            }
+            const valueKey = `${columnGroupPath.join(columnGroupIdSeparator)}${columnGroupIdSeparator}${valueField}`;
+            newRow[valueKey] = apiRef.current.getRowValue(row, originalColumn);
+          });
+        }
+      });
+      newRows.push(newRow);
+    }
+    sortColumnGroups(columnGroupingModel, visibleColumns);
+  }
+  function createColumns(columnGroups, depth = 0) {
+    for (let i = 0; i < columnGroups.length; i += 1) {
+      const columnGroup = columnGroups[i];
+      if (isLeaf(columnGroup)) {
+        continue;
+      }
+      const isLastColumnGroupLevel = depth === visibleColumns.length - 1;
+      if (isLastColumnGroupLevel) {
+        if (visibleValues.length === 0) {
+          // If there are no visible values, there are no actual columns added to the data grid, which leads to column groups not being visible.
+          // Adding an empty column to each column group ensures that the column groups are visible.
+          const emptyColumnField = `${columnGroup.groupId}${columnGroupIdSeparator}empty`;
+          const emptyColumn = {
+            field: emptyColumnField,
+            headerName: '',
+            sortable: false,
+            filterable: false,
+            groupable: false,
+            aggregable: false,
+            hideable: false,
+            disableColumnMenu: true
+          };
+          pivotColumns.push(emptyColumn);
+          if (columnGroup) {
+            columnGroup.children.push({
+              field: emptyColumnField
+            });
+          }
+        } else {
+          visibleValues.forEach(pivotValue => {
+            const valueField = pivotValue.field;
+            const mapValueKey = `${columnGroup.groupId}${columnGroupIdSeparator}${valueField}`;
+            const overrides = typeof pivotingColDef === 'function' ? pivotingColDef(valueField, columnGroup.groupId.split(columnGroupIdSeparator)) : pivotingColDef;
+            const column = _extends({
+              headerName: String(valueField)
+            }, getAttributesFromInitialColumn(pivotValue.field), overrides, {
+              field: mapValueKey,
+              aggregable: false,
+              groupable: false,
+              filterable: false,
+              hideable: false,
+              editable: false,
+              disableReorder: true,
+              availableAggregationFunctions: [pivotValue.aggFunc]
+            });
+            pivotColumns.push(column);
+            aggregationModel[mapValueKey] = pivotValue.aggFunc;
+            if (columnGroup) {
+              columnGroup.children.push({
+                field: mapValueKey
+              });
+            }
+          });
+        }
+      } else {
+        createColumns(columnGroup.children, depth + 1);
+      }
+    }
+  }
+  createColumns(columnGroupingModel);
+  return {
+    rows: visibleRows.length > 0 ? newRows : [],
+    columns: pivotColumns,
+    rowGroupingModel: visibleRows.map(row => row.field),
+    aggregationModel,
+    getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline',
+    columnVisibilityModel,
+    columnGroupingModel,
+    groupingColDef: {
+      filterable: false,
+      aggregable: false,
+      hideable: false
+    },
+    headerFilters: false,
+    disableAggregation: false,
+    disableRowGrouping: false
+  };
+};

package/esm/hooks/features/rowGrouping/useGridDataSourceRowGroupingPreProcessors.js

@@ -22,10 +22,7 @@ export const useGridDataSourceRowGroupingPreProcessors = (apiRef, props) => {
     apiRef.current.caches.rowGrouping.rulesOnLastRowTreeCreation = groupingRules;
     const getRowTreeBuilderNode = rowId => {
       const parentPath = params.updates.groupKeys ?? [];
-      const row = params.dataRowIdToModelLookup[rowId];
-      const groupingRule = groupingRules[parentPath.length];
-      const groupingValueGetter = groupingRule?.groupingValueGetter;
-      const leafKey = groupingValueGetter?.(row[groupingRule.field], row, columnsLookup[groupingRule.field], apiRef) ?? getGroupKey(params.dataRowIdToModelLookup[rowId]);
+      const leafKey = getGroupKey(params.dataRowIdToModelLookup[rowId]);
       return {
         id: rowId,
         path: [...parentPath, leafKey ?? rowId.toString()].map((key, i) => ({

package/esm/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -169,7 +169,6 @@ export const useGridRowGrouping = (apiRef, props) => {
   useGridEvent(apiRef, 'cellKeyDown', handleCellKeyDown);
   useGridEvent(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
   useGridEvent(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);
-  useGridEvent(apiRef, 'rowGroupingModelChange', () => apiRef.current.dataSource.fetchRows());
 
   /*
    * EFFECTS

package/esm/hooks/utils/useResize.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export type ResizeDirection = 'horizontal' | 'vertical';
+export declare const useResize: <TElement extends HTMLDivElement>(options: {
+  getInitialSize: (handleElement: TElement) => number;
+  onSizeChange: (newSize: number, handleElement: TElement) => void;
+  direction?: ResizeDirection;
+}) => {
+  ref: React.RefObject<TElement | null>;
+};