@mui/x-data-grid-premium 8.0.0-alpha.11 → 8.0.0-alpha.13

package/esm/components/promptControl/GridToolbarPromptControl.js

@@ -119,10 +119,18 @@ function GridToolbarPromptControl(props) {
         sort: s.direction
       })));
       const rows = getVisibleRows(apiRef, rootProps);
-      const selectedRowIds = result.select === -1 ? [] : rows.rows.slice(0, result.select).map(r => {
-        return apiRef.current.getRowId(r);
-      });
-      apiRef.current.setRowSelectionModel(selectedRowIds);
+      const rowSelectionModel = {
+        type: 'include',
+        ids: new Set()
+      };
+      if (result.select !== -1) {
+        for (let i = 0; i < result.select; i += 1) {
+          const row = rows.rows[i];
+          const id = apiRef.current.getRowId(row);
+          rowSelectionModel.ids.add(id);
+        }
+      }
+      apiRef.current.setRowSelectionModel(rowSelectionModel);
       const columns = apiRef.current.getAllColumns();
       const targetIndex = Number(columns.find(c => c.field === GRID_CHECKBOX_SELECTION_FIELD) !== undefined) + Number(result.grouping.length);
       interestColumns.push(...Object.keys(result.aggregation));
@@ -172,35 +180,29 @@ function GridToolbarPromptControl(props) {
       helperText: error,
       slotProps: {
         input: {
-          startAdornment: supportsSpeechRecognition && /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-            position: "start",
-            children: /*#__PURE__*/_jsx(RecordButton, {
-              className: classes.recordButton,
-              lang: lang,
-              recording: isRecording,
-              setRecording: setRecording,
-              disabled: isLoading,
-              onUpdate: setQuery,
-              onDone: handleDone,
-              onError: setError
-            })
+          startAdornment: supportsSpeechRecognition && /*#__PURE__*/_jsx(RecordButton, {
+            className: classes.recordButton,
+            lang: lang,
+            recording: isRecording,
+            setRecording: setRecording,
+            disabled: isLoading,
+            onUpdate: setQuery,
+            onDone: handleDone,
+            onError: setError
           }),
-          endAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-            position: "end",
-            children: /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
-              title: apiRef.current.getLocaleText('toolbarPromptControlSendActionLabel'),
-              children: /*#__PURE__*/_jsx("div", {
-                children: /*#__PURE__*/_jsx(rootProps.slots.baseIconButton, {
-                  className: classes.sendButton,
-                  disabled: isLoading || isRecording || query === '',
-                  color: "primary",
-                  onClick: processPrompt,
-                  size: "small",
-                  "aria-label": apiRef.current.getLocaleText('toolbarPromptControlSendActionAriaLabel'),
-                  edge: "end",
-                  children: /*#__PURE__*/_jsx(rootProps.slots.toolbarPromptSendIcon, {
-                    fontSize: "small"
-                  })
+          endAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
+            title: apiRef.current.getLocaleText('toolbarPromptControlSendActionLabel'),
+            children: /*#__PURE__*/_jsx("div", {
+              children: /*#__PURE__*/_jsx(rootProps.slots.baseIconButton, {
+                className: classes.sendButton,
+                disabled: isLoading || isRecording || query === '',
+                color: "primary",
+                onClick: processPrompt,
+                size: "small",
+                "aria-label": apiRef.current.getLocaleText('toolbarPromptControlSendActionAriaLabel'),
+                edge: "end",
+                children: /*#__PURE__*/_jsx(rootProps.slots.toolbarPromptSendIcon, {
+                  fontSize: "small"
                 })
               })
             })

package/esm/components/promptControl/RecordButton.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export declare const BrowserSpeechRecognition: any;
+type SpeechRecognitionOptions = {
+  onUpdate: (value: string) => void;
+  onDone: (value: string) => void;
+  onError: (error: string) => void;
+};
+interface RecordButtonProps extends SpeechRecognitionOptions {
+  disabled: boolean;
+  lang?: string;
+  recording: boolean;
+  setRecording: (value: boolean) => void;
+  className: string;
+}
+declare function RecordButton(props: RecordButtonProps): React.JSX.Element;
+export { RecordButton };

package/esm/components/promptControl/index.d.ts

@@ -0,0 +1 @@
+export { GridToolbarPromptControl as Unstable_GridToolbarPromptControl } from "./GridToolbarPromptControl.js";

package/esm/components/reexports.d.ts

@@ -0,0 +1 @@
+export { GridPremiumColumnMenu as GridColumnMenu, GRID_COLUMN_MENU_SLOTS_PREMIUM as GRID_COLUMN_MENU_SLOTS, GRID_COLUMN_MENU_SLOT_PROPS_PREMIUM as GRID_COLUMN_MENU_SLOT_PROPS } from "./GridPremiumColumnMenu.js";

package/esm/constants/dataGridPremiumDefaultSlotsComponents.d.ts

@@ -0,0 +1,2 @@
+import type { GridPremiumSlotsComponent } from '../models';
+export declare const DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS: GridPremiumSlotsComponent;

package/esm/constants/dataGridPremiumDefaultSlotsComponents.js

@@ -2,6 +2,8 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import { DATA_GRID_PRO_DEFAULT_SLOTS_COMPONENTS } from '@mui/x-data-grid-pro/internals';
 import { GridPremiumColumnMenu } from "../components/GridPremiumColumnMenu.js";
 import materialSlots from "../material/index.js";
+import { GridBottomContainer } from "../components/GridBottomContainer.js";
 export const DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS = _extends({}, DATA_GRID_PRO_DEFAULT_SLOTS_COMPONENTS, materialSlots, {
-  columnMenu: GridPremiumColumnMenu
+  columnMenu: GridPremiumColumnMenu,
+  bottomContainer: GridBottomContainer
 });

package/esm/hooks/features/aggregation/createAggregationLookup.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationLookup } from "./gridAggregationInterfaces.js";
+export declare const createAggregationLookup: ({
+  apiRef,
+  aggregationFunctions,
+  aggregationRowsScope,
+  getAggregationPosition,
+  isDataSource
+}: {
+  apiRef: RefObject<GridPrivateApiPremium>;
+  aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
+  aggregationRowsScope: DataGridPremiumProcessedProps["aggregationRowsScope"];
+  getAggregationPosition: DataGridPremiumProcessedProps["getAggregationPosition"];
+  isDataSource: boolean;
+}) => GridAggregationLookup;

package/esm/hooks/features/aggregation/createAggregationLookup.js

@@ -1,4 +1,4 @@
-import { gridColumnLookupSelector, gridFilteredRowsLookupSelector, gridRowTreeSelector, GRID_ROOT_GROUP_ID } from '@mui/x-data-grid-pro';
+import { gridColumnLookupSelector, gridFilteredRowsLookupSelector, gridRowTreeSelector, GRID_ROOT_GROUP_ID, gridRowNodeSelector } from '@mui/x-data-grid-pro';
 import { getAggregationRules } from "./gridAggregationUtils.js";
 import { gridAggregationModelSelector } from "./gridAggregationSelectors.js";
 const getGroupAggregatedValue = (groupId, apiRef, aggregationRowsScope, aggregatedFields, aggregationRules, position) => {
@@ -20,7 +20,7 @@ const getGroupAggregatedValue = (groupId, apiRef, aggregationRowsScope, aggregat
     //   A.B
     //     A.B.A
     //     A.B.B
-    const rowNode = apiRef.current.getRowNode(rowId);
+    const rowNode = gridRowNodeSelector(apiRef, rowId);
     if (rowNode.type === 'group') {
       return;
     }
@@ -70,7 +70,7 @@ const getGroupAggregatedValueDataSource = (groupId, apiRef, aggregatedFields, po
     const aggregatedField = aggregatedFields[j];
     groupAggregationLookup[aggregatedField] = {
       position,
-      value: apiRef.current.resolveGroupAggregation(groupId, aggregatedField)
+      value: apiRef.current.resolveGroupAggregation?.(groupId, aggregatedField) ?? ''
     };
   }
   return groupAggregationLookup;

package/esm/hooks/features/aggregation/gridAggregationFunctions.d.ts

@@ -0,0 +1,8 @@
+import { GridAggregationFunction } from "./gridAggregationInterfaces.js";
+export declare const GRID_AGGREGATION_FUNCTIONS: {
+  sum: GridAggregationFunction<unknown, number>;
+  avg: GridAggregationFunction<unknown, number>;
+  min: GridAggregationFunction<number | Date, number | Date>;
+  max: GridAggregationFunction<number | Date, number | Date>;
+  size: GridAggregationFunction<unknown, number>;
+};

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

@@ -0,0 +1,129 @@
+import { GridRowId, GridRowModel, GridColDef, GridValueFormatter } from '@mui/x-data-grid-pro';
+export interface GridAggregationState {
+  model: GridAggregationModel;
+  lookup: GridAggregationLookup;
+}
+export interface GridAggregationInitialState {
+  model?: GridAggregationModel;
+}
+export interface GridAggregationInternalCache {
+  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;
+}
+export interface GridAggregationPrivateApi {
+  /**
+   * 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;
+}
+/**
+ * Grid aggregation function definition interface.
+ * @demos
+ *   - [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;
+}
+/**
+ * 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 GridAggregationParams<V = any> {
+  values: (V | undefined)[];
+  groupId: GridRowId;
+  field: GridColDef['field'];
+}
+export type GridAggregationModel = {
+  [field: string]: string;
+};
+export type GridAggregationLookup = {
+  [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;
+}
+export interface GridAggregationHeaderMeta {
+  aggregationRule: GridAggregationRule;
+}
+export interface GridAggregationRule {
+  aggregationFunctionName: string;
+  aggregationFunction: GridAggregationFunction | GridAggregationFunctionDataSource;
+}
+/**
+ * Object containing all the aggregation rules that must be applied to the current columns.
+ * Unlike the aggregation model, those rules are sanitized and do not contain:
+ * - items for non-existing columns
+ * - items for non-aggregable columns (GridColDef.aggregable = false)
+ * - items for non-existing aggregation function
+ * - items for non-available aggregation function on the column (GridColDef.availableAggregationFunctions)
+ */
+export type GridAggregationRules = {
+  [field: string]: GridAggregationRule;
+};

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

@@ -0,0 +1,13 @@
+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.
+ * @category Aggregation
+ */
+export declare const gridAggregationModelSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationModel>;
+/**
+ * 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>;

package/esm/hooks/features/aggregation/gridAggregationSelectors.js

@@ -1,5 +1,5 @@
-import { createSelector } from '@mui/x-data-grid-pro/internals';
-export const gridAggregationStateSelector = state => state.aggregation;
+import { createSelector, createRootSelector } from '@mui/x-data-grid-pro/internals';
+export const gridAggregationStateSelector = createRootSelector(state => state.aggregation);
 
 /**
  * Get the aggregation model, containing the aggregation function of each column.

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

@@ -0,0 +1,62 @@
+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.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;
+}) => 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: 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;
+/**
+ * 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: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
+}) => string;
+export {};

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

@@ -0,0 +1,4 @@
+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/esm/hooks/features/aggregation/useGridAggregation.d.ts

@@ -0,0 +1,6 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
+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: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "onAggregationModelChange" | "initialState" | "aggregationModel" | "getAggregationPosition" | "aggregationFunctions" | "aggregationRowsScope" | "disableAggregation" | "rowGroupingColumnMode" | "dataSource">) => void;

package/esm/hooks/features/aggregation/useGridAggregation.js

@@ -40,14 +40,14 @@ export const useGridAggregation = (apiRef, props) => {
       getAggregationPosition: props.getAggregationPosition,
       aggregationFunctions: props.aggregationFunctions,
       aggregationRowsScope: props.aggregationRowsScope,
-      isDataSource: !!props.unstable_dataSource
+      isDataSource: !!props.dataSource
     });
     apiRef.current.setState(state => _extends({}, state, {
       aggregation: _extends({}, 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
   };
@@ -71,12 +71,12 @@ export const useGridAggregation = (apiRef, props) => {
       rulesOnLastRowHydration,
       rulesOnLastColumnHydration
     } = apiRef.current.caches.aggregation;
-    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.dataSource);
 
     // Re-apply the row hydration to add / remove the aggregation footers
     if (!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();
@@ -87,7 +87,7 @@ export const useGridAggregation = (apiRef, props) => {
     if (!areAggregationRulesEqual(rulesOnLastColumnHydration, aggregationRules)) {
       apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
     }
-  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   useGridApiEventHandler(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
   useGridApiEventHandler(apiRef, 'columnsChange', checkAggregationRulesDiff);
   useGridApiEventHandler(apiRef, 'filteredRowsSet', applyAggregation);

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

@@ -0,0 +1,4 @@
+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/esm/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -10,7 +10,7 @@ export 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 ? {} : getAggregationRules(columnsState.lookup, gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(columnsState.lookup, gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.dataSource);
     columnsState.orderedFields.forEach(field => {
       const shouldHaveAggregationValue = !!aggregationRules[field];
       const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
@@ -32,9 +32,9 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
     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 ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), 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,
@@ -49,7 +49,7 @@ export 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;
@@ -57,13 +57,13 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
     const availableAggregationFunctions = 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/esm/hooks/features/aggregation/wrapColumnWithAggregation.d.ts

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import { RefObject } from '@mui/x-internals/types';
+import { GridColDef, GridFilterOperator } from '@mui/x-data-grid-pro';
+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];
+  }[];
+}
+/**
+ * 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: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
+}) => GridBaseColDef;
+/**
+ * Remove the aggregation wrappers around the wrappable properties of the column.
+ */
+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, 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 {};

package/esm/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -2,17 +2,17 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import _extends from "@babel/runtime/helpers/esm/extends";
 const _excluded = ["aggregationWrappedProperties"];
 import * as React from 'react';
+import { gridRowIdSelector, gridRowNodeSelector } from '@mui/x-data-grid-pro';
 import { gridAggregationLookupSelector } from "./gridAggregationSelectors.js";
 import { GridFooterCell } from "../../../components/GridFooterCell.js";
 import { GridAggregationHeader } from "../../../components/GridAggregationHeader.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-const AGGREGATION_WRAPPABLE_PROPERTIES = ['valueGetter', 'valueFormatter', 'renderCell', 'renderHeader', 'filterOperators'];
 const getAggregationValueWrappedValueGetter = ({
   value: valueGetter,
   getCellAggregationResult
 }) => {
   const wrappedValueGetter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId?.(row);
+    const rowId = gridRowIdSelector(apiRef, row);
     const cellAggregationResult = rowId ? getCellAggregationResult(rowId, column.field) : null;
     if (cellAggregationResult != null) {
       return cellAggregationResult?.value ?? null;
@@ -35,7 +35,7 @@ const getAggregationValueWrappedValueFormatter = ({
     return valueFormatter;
   }
   const wrappedValueFormatter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId(row);
+    const rowId = gridRowIdSelector(apiRef, row);
     if (rowId != null) {
       const cellAggregationResult = getCellAggregationResult(rowId, column.field);
       if (cellAggregationResult != null) {
@@ -94,7 +94,8 @@ const getWrappedFilterOperators = ({
       return null;
     }
     return (value, row, column, api) => {
-      if (getCellAggregationResult(apiRef.current.getRowId(row), column.field) != null) {
+      const rowId = gridRowIdSelector(apiRef, row);
+      if (getCellAggregationResult(rowId, column.field) != null) {
         return true;
       }
       return filterFn(value, row, column, api);
@@ -133,7 +134,7 @@ export const wrapColumnWithAggregationValue = ({
 }) => {
   const getCellAggregationResult = (id, field) => {
     let cellAggregationPosition = null;
-    const rowNode = apiRef.current.getRowNode(id);
+    const rowNode = gridRowNodeSelector(apiRef, id);
     if (rowNode.type === 'group') {
       cellAggregationPosition = 'inline';
     } else if (id.toString().startsWith('auto-generated-group-footer-')) {