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

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 { 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: 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: RefObject<GridApiPremium>;
-    aggregationRule: GridAggregationRule;
+export declare const getAggregationFunctionLabel: ({
+  apiRef,
+  aggregationRule
+}: {
+  apiRef: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
 }) => string;
-export {};
+export {};

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 { 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: 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" | "unstable_dataSource">) => void;

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

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

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

@@ -1,76 +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: 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, 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 {};

package/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -9,18 +9,18 @@ exports.wrapColumnWithAggregationValue = exports.unwrapColumnFromAggregation = v
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
+var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _gridAggregationSelectors = require("./gridAggregationSelectors");
 var _GridFooterCell = require("../../../components/GridFooterCell");
 var _GridAggregationHeader = require("../../../components/GridAggregationHeader");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["aggregationWrappedProperties"];
-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 = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
     const cellAggregationResult = rowId ? getCellAggregationResult(rowId, column.field) : null;
     if (cellAggregationResult != null) {
       return cellAggregationResult?.value ?? null;
@@ -43,7 +43,7 @@ const getAggregationValueWrappedValueFormatter = ({
     return valueFormatter;
   }
   const wrappedValueFormatter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId(row);
+    const rowId = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
     if (rowId != null) {
       const cellAggregationResult = getCellAggregationResult(rowId, column.field);
       if (cellAggregationResult != null) {
@@ -102,7 +102,8 @@ const getWrappedFilterOperators = ({
       return null;
     }
     return (value, row, column, api) => {
-      if (getCellAggregationResult(apiRef.current.getRowId(row), column.field) != null) {
+      const rowId = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
+      if (getCellAggregationResult(rowId, column.field) != null) {
         return true;
       }
       return filterFn(value, row, column, api);
@@ -141,7 +142,7 @@ const wrapColumnWithAggregationValue = ({
 }) => {
   const getCellAggregationResult = (id, field) => {
     let cellAggregationPosition = null;
-    const rowNode = apiRef.current.getRowNode(id);
+    const rowNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, id);
     if (rowNode.type === 'group') {
       cellAggregationPosition = 'inline';
     } else if (id.toString().startsWith('auto-generated-group-footer-')) {