@mui/x-data-grid-premium 8.0.0-alpha.8 → 8.0.0-beta.0

package/hooks/features/aggregation/gridAggregationInterfaces.d.ts

@@ -1,33 +1,33 @@
 import { GridRowId, GridRowModel, GridColDef, GridValueFormatter } from '@mui/x-data-grid-pro';
 export interface GridAggregationState {
-    model: GridAggregationModel;
-    lookup: GridAggregationLookup;
+  model: GridAggregationModel;
+  lookup: GridAggregationLookup;
 }
 export interface GridAggregationInitialState {
-    model?: GridAggregationModel;
+  model?: GridAggregationModel;
 }
 export interface GridAggregationInternalCache {
-    rulesOnLastColumnHydration: GridAggregationRules;
-    rulesOnLastRowHydration: GridAggregationRules;
+  rulesOnLastColumnHydration: GridAggregationRules;
+  rulesOnLastRowHydration: GridAggregationRules;
 }
 export interface GridAggregationApi {
-    /**
-     * Sets the aggregation model to the one given by `model`.
-     * @param {GridAggregationModel} model The aggregation model.
-     */
-    setAggregationModel: (model: GridAggregationModel) => void;
+  /**
+   * Sets the aggregation model to the one given by `model`.
+   * @param {GridAggregationModel} model The aggregation model.
+   */
+  setAggregationModel: (model: GridAggregationModel) => void;
 }
 export interface GridAggregationPrivateApi {
-    /**
-     * Applies the aggregation to the rows.
-     */
-    applyAggregation: () => void;
+  /**
+   * Applies the aggregation to the rows.
+   */
+  applyAggregation: () => void;
 }
 export interface GridAggregationGetCellValueParams {
-    /**
-     * The row model of the row that the current cell belongs to.
-     */
-    row: GridRowModel;
+  /**
+   * The row model of the row that the current cell belongs to.
+   */
+  row: GridRowModel;
 }
 /**
  * Grid aggregation function definition interface.
@@ -35,87 +35,86 @@ export interface GridAggregationGetCellValueParams {
  *   - [Aggregation functions](/x/react-data-grid/aggregation/#aggregation-functions)
  */
 export interface GridAggregationFunction<V = any, AV = V> {
-    /**
-     * Function that takes the current cell values and generates the aggregated value.
-     * @template V, AV
-     * @param {GridAggregationParams<V>} params The params of the current aggregated cell.
-     * @returns {AV} The aggregated value.
-     */
-    apply: (params: GridAggregationParams<V>) => AV | null | undefined;
-    /**
-     * Label of the aggregation function.
-     * Used for adding a label to the footer of the grouping column when this aggregation function is the only one being used.
-     * @default apiRef.current.getLocaleText('aggregationFunctionLabel{capitalize(name)})
-     */
-    label?: string;
-    /**
-     * Column types supported by this aggregation function.
-     * If not defined, all types are supported (in most cases this property should be defined).
-     */
-    columnTypes?: string[];
-    /**
-     * Function for applying a formatter to the aggregated value.
-     * If not defined, the grid uses the formatter of the column.
-     */
-    valueFormatter?: GridValueFormatter;
-    /**
-     * Indicates if the aggregated value has the same unit as the cells used to generate it.
-     * It can be used to apply a custom cell renderer only if the aggregated value has the same unit.
-     * @default true
-     */
-    hasCellUnit?: boolean;
-    /**
-     * Function that allows to transform the value of the cell passed to the aggregation function applier.
-     * Useful for aggregating data from multiple row fields.
-     * @demo https://mui.com/x/react-data-grid/aggregation/#aggregating-data-from-multiple-row-fields
-     * @param {GridAggregationGetCellValueParams} params The params of the current cell
-     * @returns {V} The value of the cell that will be passed to the aggregation `apply` function
-     */
-    getCellValue?: (params: GridAggregationGetCellValueParams) => V;
+  /**
+   * Function that takes the current cell values and generates the aggregated value.
+   * @template V, AV
+   * @param {GridAggregationParams<V>} params The params of the current aggregated cell.
+   * @returns {AV} The aggregated value.
+   */
+  apply: (params: GridAggregationParams<V>) => AV | null | undefined;
+  /**
+   * Label of the aggregation function.
+   * Used for adding a label to the footer of the grouping column when this aggregation function is the only one being used.
+   * @default apiRef.current.getLocaleText('aggregationFunctionLabel{capitalize(name)})
+   */
+  label?: string;
+  /**
+   * Column types supported by this aggregation function.
+   * If not defined, all types are supported (in most cases this property should be defined).
+   */
+  columnTypes?: string[];
+  /**
+   * Function for applying a formatter to the aggregated value.
+   * If not defined, the grid uses the formatter of the column.
+   */
+  valueFormatter?: GridValueFormatter;
+  /**
+   * Indicates if the aggregated value has the same unit as the cells used to generate it.
+   * It can be used to apply a custom cell renderer only if the aggregated value has the same unit.
+   * @default true
+   */
+  hasCellUnit?: boolean;
+  /**
+   * Function that allows to transform the value of the cell passed to the aggregation function applier.
+   * Useful for aggregating data from multiple row fields.
+   * @demo https://mui.com/x/react-data-grid/aggregation/#aggregating-data-from-multiple-row-fields
+   * @param {GridAggregationGetCellValueParams} params The params of the current cell
+   * @returns {V} The value of the cell that will be passed to the aggregation `apply` function
+   */
+  getCellValue?: (params: GridAggregationGetCellValueParams) => V;
 }
 /**
  * Grid aggregation function data source definition interface.
  * @demos
  *   - [Server-side aggregation](/x/react-data-grid/server-side-data/aggregation/)
  */
-export interface GridAggregationFunctionDataSource extends Omit<GridAggregationFunction, 'apply' | 'getCellValue'> {
-}
+export interface GridAggregationFunctionDataSource extends Omit<GridAggregationFunction, 'apply' | 'getCellValue'> {}
 export interface GridAggregationParams<V = any> {
-    values: (V | undefined)[];
-    groupId: GridRowId;
-    field: GridColDef['field'];
+  values: (V | undefined)[];
+  groupId: GridRowId;
+  field: GridColDef['field'];
 }
 export type GridAggregationModel = {
-    [field: string]: string;
+  [field: string]: string;
 };
 export type GridAggregationLookup = {
-    [rowId: GridRowId]: {
-        [field: string]: {
-            position: GridAggregationPosition;
-            value: any;
-        };
+  [rowId: GridRowId]: {
+    [field: string]: {
+      position: GridAggregationPosition;
+      value: any;
     };
+  };
 };
 export type GridAggregationPosition = 'inline' | 'footer';
 export interface GridAggregationCellMeta {
-    /**
-     * If `true`, the current aggregated value has the same unit as the value of the other cells of this row.
-     * For instance, "min" / "max" aggregation have the same unit as the other cells.
-     * If `false`, the current aggregated value has another unit or not unit.
-     * For instance, "size" aggregation has no unit.
-     */
-    hasCellUnit: boolean;
-    /**
-     * Name of the aggregation function currently applied on this cell.
-     */
-    aggregationFunctionName: string;
+  /**
+   * If `true`, the current aggregated value has the same unit as the value of the other cells of this row.
+   * For instance, "min" / "max" aggregation have the same unit as the other cells.
+   * If `false`, the current aggregated value has another unit or not unit.
+   * For instance, "size" aggregation has no unit.
+   */
+  hasCellUnit: boolean;
+  /**
+   * Name of the aggregation function currently applied on this cell.
+   */
+  aggregationFunctionName: string;
 }
 export interface GridAggregationHeaderMeta {
-    aggregationRule: GridAggregationRule;
+  aggregationRule: GridAggregationRule;
 }
 export interface GridAggregationRule {
-    aggregationFunctionName: string;
-    aggregationFunction: GridAggregationFunction | GridAggregationFunctionDataSource;
+  aggregationFunctionName: string;
+  aggregationFunction: GridAggregationFunction | GridAggregationFunctionDataSource;
 }
 /**
  * Object containing all the aggregation rules that must be applied to the current columns.
@@ -126,5 +125,5 @@ export interface GridAggregationRule {
  * - items for non-available aggregation function on the column (GridColDef.availableAggregationFunctions)
  */
 export type GridAggregationRules = {
-    [field: string]: GridAggregationRule;
-};
+  [field: string]: GridAggregationRule;
+};

package/hooks/features/aggregation/gridAggregationSelectors.d.ts

@@ -1,5 +1,5 @@
-import { GridStatePremium } from '../../../models/gridStatePremium';
-export declare const gridAggregationStateSelector: (state: GridStatePremium) => import("./gridAggregationInterfaces").GridAggregationState;
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+export declare const gridAggregationStateSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, unknown, import("./gridAggregationInterfaces").GridAggregationState>;
 /**
  * Get the aggregation model, containing the aggregation function of each column.
  * If a column is not in the model, it is not aggregated.
@@ -10,4 +10,4 @@ export declare const gridAggregationModelSelector: import("@mui/x-data-grid").Ou
  * Get the aggregation results as a lookup.
  * @category Aggregation
  */
-export declare const gridAggregationLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationLookup>;
+export declare const gridAggregationLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationLookup>;

package/hooks/features/aggregation/gridAggregationSelectors.js

@@ -5,14 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.gridAggregationStateSelector = exports.gridAggregationModelSelector = exports.gridAggregationLookupSelector = void 0;
 var _internals = require("@mui/x-data-grid-pro/internals");
-const gridAggregationStateSelector = state => state.aggregation;
+const gridAggregationStateSelector = exports.gridAggregationStateSelector = (0, _internals.createRootSelector)(state => state.aggregation);
 
 /**
  * Get the aggregation model, containing the aggregation function of each column.
  * If a column is not in the model, it is not aggregated.
  * @category Aggregation
  */
-exports.gridAggregationStateSelector = gridAggregationStateSelector;
 const gridAggregationModelSelector = exports.gridAggregationModelSelector = (0, _internals.createSelector)(gridAggregationStateSelector, aggregationState => aggregationState.model);
 
 /**

package/hooks/features/aggregation/gridAggregationUtils.d.ts

@@ -1,45 +1,62 @@
-import * as React from 'react';
+import { RefObject } from '@mui/x-internals/types';
 import { GridColDef, GridRowId } from '@mui/x-data-grid-pro';
 import { GridColumnRawLookup, GridHydrateRowsValue } from '@mui/x-data-grid-pro/internals';
-import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationModel, GridAggregationRule, GridAggregationRules } from './gridAggregationInterfaces';
-import { GridStatePremium } from '../../../models/gridStatePremium';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-import { GridApiPremium, GridPrivateApiPremium } from '../../../models/gridApiPremium';
+import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationModel, GridAggregationRule, GridAggregationRules } from "./gridAggregationInterfaces.js";
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridApiPremium, GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = "auto-generated-group-footer-root";
 export declare const getAggregationFooterRowIdFromGroupId: (groupId: GridRowId | null) => string;
 type AggregationFunction = GridAggregationFunction | GridAggregationFunctionDataSource | undefined;
-export declare const canColumnHaveAggregationFunction: ({ colDef, aggregationFunctionName, aggregationFunction, isDataSource, }: {
-    colDef: GridColDef | undefined;
-    aggregationFunctionName: string;
-    aggregationFunction: AggregationFunction;
-    isDataSource: boolean;
+export declare const canColumnHaveAggregationFunction: ({
+  colDef,
+  aggregationFunctionName,
+  aggregationFunction,
+  isDataSource
+}: {
+  colDef: GridColDef | undefined;
+  aggregationFunctionName: string;
+  aggregationFunction: AggregationFunction;
+  isDataSource: boolean;
 }) => boolean;
-export declare const getAvailableAggregationFunctions: ({ aggregationFunctions, colDef, isDataSource, }: {
-    aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
-    colDef: GridColDef;
-    isDataSource: boolean;
+export declare const getAvailableAggregationFunctions: ({
+  aggregationFunctions,
+  colDef,
+  isDataSource
+}: {
+  aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
+  colDef: GridColDef;
+  isDataSource: boolean;
 }) => string[];
 export declare const mergeStateWithAggregationModel: (aggregationModel: GridAggregationModel) => (state: GridStatePremium) => GridStatePremium;
 export declare const getAggregationRules: (columnsLookup: GridColumnRawLookup, aggregationModel: GridAggregationModel, aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>, isDataSource: boolean) => GridAggregationRules;
 interface AddFooterRowsParams {
-    groupingParams: GridHydrateRowsValue;
-    getAggregationPosition: DataGridPremiumProcessedProps['getAggregationPosition'];
-    /**
-     * If `true`, there are some aggregation rules to apply
-     */
-    hasAggregationRule: boolean;
-    apiRef: React.RefObject<GridPrivateApiPremium>;
+  groupingParams: GridHydrateRowsValue;
+  getAggregationPosition: DataGridPremiumProcessedProps['getAggregationPosition'];
+  /**
+   * If `true`, there are some aggregation rules to apply
+   */
+  hasAggregationRule: boolean;
+  apiRef: RefObject<GridPrivateApiPremium>;
 }
 /**
  * Add a footer for each group that has at least one column with an aggregated value.
  */
-export declare const addFooterRows: ({ groupingParams, apiRef, getAggregationPosition, hasAggregationRule, }: AddFooterRowsParams) => GridHydrateRowsValue;
+export declare const addFooterRows: ({
+  groupingParams,
+  apiRef,
+  getAggregationPosition,
+  hasAggregationRule
+}: AddFooterRowsParams) => GridHydrateRowsValue;
 /**
  * Compares two sets of aggregation rules to determine if they are equal or not.
  */
 export declare const areAggregationRulesEqual: (previousValue: GridAggregationRules | undefined, newValue: GridAggregationRules) => boolean;
-export declare const getAggregationFunctionLabel: ({ apiRef, aggregationRule, }: {
-    apiRef: React.RefObject<GridApiPremium>;
-    aggregationRule: GridAggregationRule;
+export declare const getAggregationFunctionLabel: ({
+  apiRef,
+  aggregationRule
+}: {
+  apiRef: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
 }) => string;
-export {};
+export {};

package/hooks/features/aggregation/gridAggregationUtils.js

@@ -123,7 +123,7 @@ const addFooterRows = ({
     }
   };
   const updateRootGroupFooter = groupNode => {
-    const shouldHaveFooter = hasAggregationRule && getAggregationPosition(groupNode) === 'footer';
+    const shouldHaveFooter = hasAggregationRule && getAggregationPosition(groupNode) === 'footer' && groupNode.children.length > 0;
     if (shouldHaveFooter) {
       const rowId = getAggregationFooterRowIdFromGroupId(null);
       newGroupingParams = (0, _internals2.addPinnedRow)({

package/hooks/features/aggregation/index.d.ts

@@ -1,4 +1,4 @@
-export type { GridAggregationState, GridAggregationInitialState, GridAggregationInternalCache, GridAggregationApi, GridAggregationGetCellValueParams, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationParams, GridAggregationModel, GridAggregationLookup, GridAggregationPosition, GridAggregationCellMeta, GridAggregationHeaderMeta, GridAggregationRule, GridAggregationRules, } from './gridAggregationInterfaces';
-export * from './gridAggregationSelectors';
-export * from './gridAggregationFunctions';
-export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId, } from './gridAggregationUtils';
+export type { GridAggregationState, GridAggregationInitialState, GridAggregationInternalCache, GridAggregationApi, GridAggregationGetCellValueParams, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationParams, GridAggregationModel, GridAggregationLookup, GridAggregationPosition, GridAggregationCellMeta, GridAggregationHeaderMeta, GridAggregationRule, GridAggregationRules } from './gridAggregationInterfaces';
+export * from "./gridAggregationSelectors.js";
+export * from "./gridAggregationFunctions.js";
+export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId } from "./gridAggregationUtils.js";

package/hooks/features/aggregation/useGridAggregation.d.ts

@@ -1,6 +1,6 @@
-import * as React from 'react';
+import { RefObject } from '@mui/x-internals/types';
 import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-import { GridPrivateApiPremium } from '../../../models/gridApiPremium';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const aggregationStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'aggregationModel' | 'initialState'>, GridPrivateApiPremium>;
-export declare const useGridAggregation: (apiRef: React.RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "onAggregationModelChange" | "initialState" | "aggregationModel" | "getAggregationPosition" | "aggregationFunctions" | "aggregationRowsScope" | "disableAggregation" | "rowGroupingColumnMode" | "unstable_dataSource">) => void;
+export declare const useGridAggregation: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "onAggregationModelChange" | "initialState" | "aggregationModel" | "getAggregationPosition" | "aggregationFunctions" | "aggregationRowsScope" | "disableAggregation" | "rowGroupingColumnMode" | "dataSource">) => void;

package/hooks/features/aggregation/useGridAggregation.js

@@ -41,7 +41,6 @@ const useGridAggregation = (apiRef, props) => {
     const currentModel = (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef);
     if (currentModel !== model) {
       apiRef.current.setState((0, _gridAggregationUtils.mergeStateWithAggregationModel)(model));
-      apiRef.current.forceUpdate();
     }
   }, [apiRef]);
   const applyAggregation = React.useCallback(() => {
@@ -50,14 +49,14 @@ const useGridAggregation = (apiRef, props) => {
       getAggregationPosition: props.getAggregationPosition,
       aggregationFunctions: props.aggregationFunctions,
       aggregationRowsScope: props.aggregationRowsScope,
-      isDataSource: !!props.unstable_dataSource
+      isDataSource: !!props.dataSource
     });
     apiRef.current.setState(state => (0, _extends2.default)({}, state, {
       aggregation: (0, _extends2.default)({}, state.aggregation, {
         lookup: aggregationLookup
       })
     }));
-  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope, props.unstable_dataSource]);
+  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope, props.dataSource]);
   const aggregationApi = {
     setAggregationModel
   };
@@ -81,12 +80,12 @@ const useGridAggregation = (apiRef, props) => {
       rulesOnLastRowHydration,
       rulesOnLastColumnHydration
     } = apiRef.current.caches.aggregation;
-    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
 
     // Re-apply the row hydration to add / remove the aggregation footers
     if (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
-      if (props.unstable_dataSource) {
-        apiRef.current.unstable_dataSource.fetchRows();
+      if (props.dataSource) {
+        apiRef.current.dataSource.fetchRows();
       } else {
         apiRef.current.requestPipeProcessorsApplication('hydrateRows');
         applyAggregation();
@@ -95,10 +94,9 @@ const useGridAggregation = (apiRef, props) => {
 
     // Re-apply the column hydration to wrap / unwrap the aggregated columns
     if (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastColumnHydration, aggregationRules)) {
-      apiRef.current.caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
       apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
     }
-  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'columnsChange', checkAggregationRulesDiff);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'filteredRowsSet', applyAggregation);

package/hooks/features/aggregation/useGridAggregationPreProcessors.d.ts

@@ -1,4 +1,4 @@
-import * as React from 'react';
-import { GridPrivateApiPremium } from '../../../models/gridApiPremium';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-export declare const useGridAggregationPreProcessors: (apiRef: React.RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "aggregationFunctions" | "disableAggregation" | "getAggregationPosition" | "slotProps" | "slots" | "unstable_dataSource">) => void;
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+export declare const useGridAggregationPreProcessors: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "aggregationFunctions" | "disableAggregation" | "getAggregationPosition" | "slotProps" | "slots" | "dataSource">) => void;

package/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -18,7 +18,7 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
   // that the pre-processor is called it will already have been updated with the current rules.
   const rulesOnLastColumnHydration = React.useRef({});
   const updateAggregatedColumns = React.useCallback(columnsState => {
-    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)(columnsState.lookup, (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)(columnsState.lookup, (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
     columnsState.orderedFields.forEach(field => {
       const shouldHaveAggregationValue = !!aggregationRules[field];
       const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
@@ -38,10 +38,11 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
       columnsState.lookup[field] = column;
     });
     rulesOnLastColumnHydration.current = aggregationRules;
+    apiRef.current.caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
     return columnsState;
-  }, [apiRef, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [apiRef, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   const addGroupFooterRows = React.useCallback(value => {
-    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
     const hasAggregationRule = Object.keys(aggregationRules).length > 0;
 
     // If we did not have any aggregation footer before, and we still don't have any,
@@ -56,7 +57,7 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
       getAggregationPosition: props.getAggregationPosition,
       hasAggregationRule
     });
-  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions, props.unstable_dataSource]);
+  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions, props.dataSource]);
   const addColumnMenuButtons = React.useCallback((columnMenuItems, colDef) => {
     if (props.disableAggregation || !colDef.aggregable) {
       return columnMenuItems;
@@ -64,13 +65,13 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
     const availableAggregationFunctions = (0, _gridAggregationUtils.getAvailableAggregationFunctions)({
       aggregationFunctions: props.aggregationFunctions,
       colDef,
-      isDataSource: !!props.unstable_dataSource
+      isDataSource: !!props.dataSource
     });
     if (availableAggregationFunctions.length === 0) {
       return columnMenuItems;
     }
     return [...columnMenuItems, 'columnMenuAggregationItem'];
-  }, [props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   const stateExportPreProcessing = React.useCallback(prevState => {
     if (props.disableAggregation) {
       return prevState;

package/hooks/features/aggregation/wrapColumnWithAggregation.d.ts

@@ -1,75 +1,81 @@
 import * as React from 'react';
+import { RefObject } from '@mui/x-internals/types';
 import { GridColDef, GridFilterOperator } from '@mui/x-data-grid-pro';
-import { GridBaseColDef } from '@mui/x-data-grid-pro/internals';
-import { GridApiPremium } from '../../../models/gridApiPremium';
-import { GridAggregationRule } from './gridAggregationInterfaces';
-declare const AGGREGATION_WRAPPABLE_PROPERTIES: readonly ["valueGetter", "valueFormatter", "renderCell", "renderHeader", "filterOperators"];
-type WrappableColumnProperty = (typeof AGGREGATION_WRAPPABLE_PROPERTIES)[number];
+import { type GridBaseColDef } from '@mui/x-data-grid-pro/internals';
+import { GridApiPremium } from "../../../models/gridApiPremium.js";
+import type { GridAggregationRule } from './gridAggregationInterfaces';
+type WrappableColumnProperty = 'valueGetter' | 'valueFormatter' | 'renderCell' | 'renderHeader' | 'filterOperators';
 interface GridColDefWithAggregationWrappers extends GridBaseColDef {
-    aggregationWrappedProperties: {
-        name: WrappableColumnProperty;
-        originalValue: GridBaseColDef[WrappableColumnProperty];
-        wrappedValue: GridBaseColDef[WrappableColumnProperty];
-    }[];
+  aggregationWrappedProperties: {
+    name: WrappableColumnProperty;
+    originalValue: GridBaseColDef[WrappableColumnProperty];
+    wrappedValue: GridBaseColDef[WrappableColumnProperty];
+  }[];
 }
 /**
  * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
  */
-export declare const wrapColumnWithAggregationValue: ({ column, apiRef, aggregationRule, }: {
-    column: GridBaseColDef;
-    apiRef: React.RefObject<GridApiPremium>;
-    aggregationRule: GridAggregationRule;
+export declare const wrapColumnWithAggregationValue: ({
+  column,
+  apiRef,
+  aggregationRule
+}: {
+  column: GridBaseColDef;
+  apiRef: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
 }) => GridBaseColDef;
 /**
  * Remove the aggregation wrappers around the wrappable properties of the column.
  */
-export declare const unwrapColumnFromAggregation: ({ column, }: {
-    column: GridColDef | GridColDefWithAggregationWrappers;
+export declare const unwrapColumnFromAggregation: ({
+  column
+}: {
+  column: GridColDef | GridColDefWithAggregationWrappers;
 }) => GridBaseColDef<any, any, any> | {
-    field: string;
-    headerName?: string;
-    description?: string;
-    width?: number;
-    flex?: number;
-    minWidth?: number;
-    maxWidth?: number;
-    hideable?: boolean;
-    sortable?: boolean;
-    sortingOrder?: readonly import("@mui/x-data-grid").GridSortDirection[];
-    resizable?: boolean;
-    editable?: boolean;
-    groupable?: boolean;
-    pinnable?: boolean;
-    sortComparator?: import("@mui/x-data-grid").GridComparatorFn<any> | undefined;
-    getSortComparator?: ((sortDirection: import("@mui/x-data-grid").GridSortDirection) => import("@mui/x-data-grid").GridComparatorFn<any> | undefined) | undefined;
-    type?: import("@mui/x-data-grid").GridColType;
-    align?: import("@mui/x-data-grid").GridAlignment;
-    valueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
-    rowSpanValueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
-    valueSetter?: import("@mui/x-data-grid").GridValueSetter<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
-    valueFormatter?: import("@mui/x-data-grid").GridValueFormatter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
-    valueParser?: import("@mui/x-data-grid").GridValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
-    cellClassName?: import("@mui/x-data-grid").GridCellClassNamePropType<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
-    display?: "text" | "flex";
-    renderCell?: ((params: import("@mui/x-data-grid").GridRenderCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
-    renderEditCell?: ((params: import("@mui/x-data-grid").GridRenderEditCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
-    preProcessEditCellProps?: ((params: import("@mui/x-data-grid").GridPreProcessEditCellProps) => import("@mui/x-data-grid").GridEditCellProps | Promise<import("@mui/x-data-grid").GridEditCellProps>) | undefined;
-    headerClassName?: import("@mui/x-data-grid").GridColumnHeaderClassNamePropType;
-    renderHeader?: ((params: import("@mui/x-data-grid").GridColumnHeaderParams<import("@mui/x-data-grid").GridValidRowModel, any, any>) => React.ReactNode) | undefined;
-    headerAlign?: import("@mui/x-data-grid").GridAlignment;
-    hideSortIcons?: boolean;
-    disableColumnMenu?: boolean;
-    filterable?: boolean;
-    filterOperators?: readonly GridFilterOperator<import("@mui/x-data-grid").GridValidRowModel, any, any>[] | undefined;
-    getApplyQuickFilterFn?: import("@mui/x-data-grid").GetApplyQuickFilterFn<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
-    disableReorder?: boolean;
-    disableExport?: boolean;
-    colSpan?: number | import("@mui/x-data-grid").GridColSpanFn<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
-    unstable_examples?: any[] | undefined;
-    renderHeaderFilter?: (params: import("@mui/x-data-grid-pro").GridRenderHeaderFilterProps) => React.ReactNode;
-    aggregable?: boolean;
-    availableAggregationFunctions?: string[];
-    groupingValueGetter?: import("../../..").GridGroupingValueGetter<import("@mui/x-data-grid").GridValidRowModel> | undefined;
-    pastedValueParser?: import("../../..").GridPastedValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  field: string;
+  headerName?: string;
+  description?: string;
+  width?: number;
+  flex?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  hideable?: boolean;
+  sortable?: boolean;
+  sortingOrder?: readonly import("@mui/x-data-grid").GridSortDirection[];
+  resizable?: boolean;
+  editable?: boolean;
+  groupable?: boolean;
+  pinnable?: boolean;
+  sortComparator?: import("@mui/x-data-grid").GridComparatorFn<any> | undefined;
+  getSortComparator?: ((sortDirection: import("@mui/x-data-grid").GridSortDirection) => import("@mui/x-data-grid").GridComparatorFn<any> | undefined) | undefined;
+  type?: import("@mui/x-data-grid").GridColType;
+  align?: import("@mui/x-data-grid").GridAlignment;
+  valueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  rowSpanValueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  valueSetter?: import("@mui/x-data-grid").GridValueSetter<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  valueFormatter?: import("@mui/x-data-grid").GridValueFormatter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  valueParser?: import("@mui/x-data-grid").GridValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  cellClassName?: import("@mui/x-data-grid").GridCellClassNamePropType<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
+  display?: "text" | "flex";
+  renderCell?: ((params: import("@mui/x-data-grid").GridRenderCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
+  renderEditCell?: ((params: import("@mui/x-data-grid").GridRenderEditCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
+  preProcessEditCellProps?: ((params: import("@mui/x-data-grid").GridPreProcessEditCellProps) => import("@mui/x-data-grid").GridEditCellProps | Promise<import("@mui/x-data-grid").GridEditCellProps>) | undefined;
+  headerClassName?: import("@mui/x-data-grid").GridColumnHeaderClassNamePropType;
+  renderHeader?: ((params: import("@mui/x-data-grid").GridColumnHeaderParams<import("@mui/x-data-grid").GridValidRowModel, any, any>) => React.ReactNode) | undefined;
+  headerAlign?: import("@mui/x-data-grid").GridAlignment;
+  hideSortIcons?: boolean;
+  disableColumnMenu?: boolean;
+  filterable?: boolean;
+  filterOperators?: readonly GridFilterOperator<import("@mui/x-data-grid").GridValidRowModel, any, any, any>[] | undefined;
+  getApplyQuickFilterFn?: import("@mui/x-data-grid").GetApplyQuickFilterFn<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
+  disableReorder?: boolean;
+  disableExport?: boolean;
+  colSpan?: number | import("@mui/x-data-grid").GridColSpanFn<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  unstable_examples?: any[] | undefined;
+  renderHeaderFilter?: (params: import("@mui/x-data-grid-pro").GridRenderHeaderFilterProps) => React.ReactNode;
+  aggregable?: boolean;
+  availableAggregationFunctions?: string[];
+  groupingValueGetter?: import("../../..").GridGroupingValueGetter<import("@mui/x-data-grid").GridValidRowModel> | undefined;
+  pastedValueParser?: import("../../..").GridPastedValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
 };
-export {};
+export {};