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

package/esm/models/gridApiPremium.d.ts

@@ -0,0 +1,14 @@
+import { GridPrivateOnlyApiCommon } from '@mui/x-data-grid/internals';
+import { GridApiCommon, GridColumnPinningApi, GridDetailPanelApi, GridDetailPanelPrivateApi, GridRowPinningApi, GridRowMultiSelectionApi, GridColumnReorderApi, GridRowProApi } from '@mui/x-data-grid-pro';
+import { GridInitialStatePremium, GridStatePremium } from "./gridStatePremium.js";
+import type { GridRowGroupingApi, GridExcelExportApi, GridAggregationApi } from '../hooks';
+import { GridCellSelectionApi } from "../hooks/features/cellSelection/gridCellSelectionInterfaces.js";
+import type { DataGridPremiumProcessedProps } from './dataGridPremiumProps';
+import type { GridDataSourcePremiumPrivateApi, GridDataSourceApiPremium } from '../hooks/features/dataSource/models';
+import type { GridAggregationPrivateApi } from '../hooks/features/aggregation/gridAggregationInterfaces';
+/**
+ * The api of Data Grid Premium.
+ * TODO: Do not redefine manually the pro features
+ */
+export interface GridApiPremium extends GridApiCommon<GridStatePremium, GridInitialStatePremium>, GridRowProApi, GridColumnPinningApi, GridDetailPanelApi, GridRowGroupingApi, GridExcelExportApi, GridAggregationApi, GridRowPinningApi, GridDataSourceApiPremium, GridCellSelectionApi, GridRowMultiSelectionApi, GridColumnReorderApi {}
+export interface GridPrivateApiPremium extends GridApiPremium, GridPrivateOnlyApiCommon<GridApiPremium, GridPrivateApiPremium, DataGridPremiumProcessedProps>, GridDataSourcePremiumPrivateApi, GridAggregationPrivateApi, GridDetailPanelPrivateApi {}

package/esm/models/gridGroupingValueGetter.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridValidRowModel, GridColDef, GridKeyValue } from '@mui/x-data-grid-pro';
+import { GridApiPremium } from "./gridApiPremium.js";
+export type GridGroupingValueGetter<R extends GridValidRowModel = GridValidRowModel, TValue = never> = (value: TValue, row: R, column: GridColDef<R>, apiRef: RefObject<GridApiPremium>) => GridKeyValue | null | undefined;

package/esm/models/gridPastedValueParser.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridColDef, GridValidRowModel } from '@mui/x-data-grid';
+import { GridApiPremium } from "./gridApiPremium.js";
+export type GridPastedValueParser<R extends GridValidRowModel = GridValidRowModel, V = any, F = V> = (value: string, row: R, column: GridColDef<R, V, F>, apiRef: RefObject<GridApiPremium>) => V | undefined;

package/esm/models/gridPremiumIconSlotsComponent.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+export interface GridPremiumIconSlotsComponent {
+  /**
+   * Icon displayed in column menu for ungrouping
+   * @default GridWorkspacesIcon
+   */
+  columnMenuUngroupIcon: React.JSXElementConstructor<any>;
+  /**
+   * Icon displayed in column menu for grouping
+   * @default GridGroupWorkIcon
+   */
+  columnMenuGroupIcon: React.JSXElementConstructor<any>;
+  /**
+   * Icon displayed in column menu for aggregation
+   * @default GridFunctionsIcon
+   */
+  columnMenuAggregationIcon: React.JSXElementConstructor<any>;
+  /**
+   * Icon used for the button that sends a prompt
+   * @default GridFunctionsIcon
+   */
+  toolbarPromptSendIcon: React.JSXElementConstructor<any>;
+  /**
+   * Icon used for the button that starts/stops recording the prompt
+   * @default GridFunctionsIcon
+   */
+  toolbarPromptRecordIcon: React.JSXElementConstructor<any>;
+}

package/esm/models/gridPremiumSlotsComponent.d.ts

@@ -0,0 +1,7 @@
+import { GridProSlotsComponent } from '@mui/x-data-grid-pro';
+import { GridPremiumIconSlotsComponent } from "./gridPremiumIconSlotsComponent.js";
+/**
+ * Grid components React prop interface containing all the overridable components
+ * for Premium package
+ */
+export interface GridPremiumSlotsComponent extends GridProSlotsComponent, GridPremiumIconSlotsComponent {}

package/esm/models/gridStatePremium.d.ts

@@ -0,0 +1,18 @@
+import { GridInitialState as GridInitialStatePro, GridState as GridStatePro } from '@mui/x-data-grid-pro';
+import type { GridRowGroupingState, GridRowGroupingInitialState, GridAggregationState, GridAggregationInitialState, GridCellSelectionModel } from '../hooks';
+/**
+ * The state of Data Grid Premium.
+ */
+export interface GridStatePremium extends GridStatePro {
+  rowGrouping: GridRowGroupingState;
+  aggregation: GridAggregationState;
+  cellSelection: GridCellSelectionModel;
+}
+/**
+ * The initial state of Data Grid Premium.
+ */
+export interface GridInitialStatePremium extends GridInitialStatePro {
+  rowGrouping?: GridRowGroupingInitialState;
+  aggregation?: GridAggregationInitialState;
+  cellSelection?: GridCellSelectionModel;
+}

package/esm/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./gridGroupingValueGetter.js";
+export * from "./gridPremiumIconSlotsComponent.js";
+export * from "./gridPremiumSlotsComponent.js";
+export * from "./gridPastedValueParser.js";

package/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/esm/setupExcelExportWebWorker.d.ts

@@ -0,0 +1 @@
+export { setupExcelExportWebWorker } from "./hooks/features/export/serializer/setupExcelExportWebWorker.js";

package/esm/setupExcelExportWebWorker.js

@@ -0,0 +1 @@
+export { setupExcelExportWebWorker } from "./hooks/features/export/serializer/setupExcelExportWebWorker.js";

package/esm/themeAugmentation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./overrides.js";
+export * from "./props.js";

package/esm/themeAugmentation/overrides.d.ts

@@ -0,0 +1,7 @@
+import { GridClassKey } from '@mui/x-data-grid';
+export interface DataGridPremiumComponentNameToClassKey {
+  MuiDataGrid: GridClassKey;
+}
+declare module '@mui/material/styles' {
+  interface ComponentNameToClassKey extends DataGridPremiumComponentNameToClassKey {}
+}

package/esm/themeAugmentation/props.d.ts

@@ -0,0 +1,15 @@
+import { ComponentsOverrides, ComponentsProps } from '@mui/material/styles';
+import { DataGridPremiumProps } from "../models/dataGridPremiumProps.js";
+export interface DataGridPremiumComponentsPropsList {
+  MuiDataGrid: DataGridPremiumProps;
+}
+export interface DataGridPremiumComponents<Theme = unknown> {
+  MuiDataGrid?: {
+    defaultProps?: ComponentsProps['MuiDataGrid'];
+    styleOverrides?: ComponentsOverrides<Theme>['MuiDataGrid'];
+  };
+}
+declare module '@mui/material/styles' {
+  interface ComponentsPropsList extends DataGridPremiumComponentsPropsList {}
+  interface Components<Theme = unknown> extends DataGridPremiumComponents<Theme> {}
+}

package/esm/typeOverloads/index.d.ts

@@ -0,0 +1,2 @@
+import '@mui/x-data-grid-pro/typeOverloads';
+export * from "./modules.js";

package/esm/typeOverloads/modules.d.ts

@@ -0,0 +1,97 @@
+import { GridExportDisplayOptions, GridValidRowModel } from '@mui/x-data-grid-pro';
+import type { GridControlledStateEventLookupPro, GridApiCachesPro, GridEventLookupPro } from '@mui/x-data-grid-pro/typeOverloads';
+import type { GridGroupingValueGetter, GridPastedValueParser } from '../models';
+import type { GridRowGroupingModel, GridAggregationModel, GridAggregationCellMeta, GridAggregationHeaderMeta, GridCellSelectionModel } from '../hooks';
+import { GridRowGroupingInternalCache } from "../hooks/features/rowGrouping/gridRowGroupingInterfaces.js";
+import { GridAggregationInternalCache } from "../hooks/features/aggregation/gridAggregationInterfaces.js";
+import type { GridExcelExportOptions } from '../hooks/features/export/gridExcelExportInterface';
+export interface GridControlledStateEventLookupPremium {
+  /**
+   * Fired when the aggregation model changes.
+   */
+  aggregationModelChange: {
+    params: GridAggregationModel;
+  };
+  /**
+   * Fired when the row grouping model changes.
+   */
+  rowGroupingModelChange: {
+    params: GridRowGroupingModel;
+  };
+  /**
+   * Fired when the selection state of one or multiple cells change.
+   */
+  cellSelectionChange: {
+    params: GridCellSelectionModel;
+  };
+  /**
+   * Fired when the state of the Excel export task changes
+   */
+  excelExportStateChange: {
+    params: 'pending' | 'finished';
+  };
+}
+interface GridEventLookupPremium extends GridEventLookupPro {
+  /**
+   * Fired when the clipboard paste operation starts.
+   */
+  clipboardPasteStart: {
+    params: {
+      data: string[][];
+    };
+  };
+  /**
+   * Fired when the clipboard paste operation ends.
+   */
+  clipboardPasteEnd: {};
+}
+export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F = V> {
+  /**
+   * If `true`, the cells of the column can be aggregated based.
+   * @default true
+   */
+  aggregable?: boolean;
+  /**
+   * Limit the aggregation function usable on this column.
+   * By default, the column will have all the aggregation functions that are compatible with its type.
+   */
+  availableAggregationFunctions?: string[];
+  /**
+   * Function that transforms a complex cell value into a key that be used for grouping the rows.
+   * @returns {GridKeyValue | null | undefined} The cell key.
+   */
+  groupingValueGetter?: GridGroupingValueGetter<R>;
+  /**
+   * Function that takes the clipboard-pasted value and converts it to a value used internally.
+   * @returns {V} The converted value.
+   */
+  pastedValueParser?: GridPastedValueParser<R, V, F>;
+}
+export interface GridRenderCellParamsPremium<R extends GridValidRowModel = any, V = any, F = V> {
+  aggregation?: GridAggregationCellMeta;
+}
+export interface GridColumnHeaderParamsPremium<R extends GridValidRowModel = any, V = any, F = V> {
+  aggregation?: GridAggregationHeaderMeta;
+}
+export interface GridApiCachesPremium extends GridApiCachesPro {
+  rowGrouping: GridRowGroupingInternalCache;
+  aggregation: GridAggregationInternalCache;
+}
+declare module '@mui/x-data-grid-pro' {
+  interface GridEventLookup extends GridEventLookupPremium {}
+  interface GridControlledStateEventLookup extends GridControlledStateEventLookupPro, GridControlledStateEventLookupPremium {}
+  interface GridRenderCellParams<R, V, F> extends GridRenderCellParamsPremium<R, V, F> {}
+  interface GridColumnHeaderParams<R, V, F> extends GridColumnHeaderParamsPremium<R, V, F> {}
+  interface GridApiCaches extends GridApiCachesPremium {}
+  interface GridToolbarExportProps {
+    excelOptions?: GridExcelExportOptions & GridExportDisplayOptions;
+  }
+  interface GridToolbarProps {
+    excelOptions?: GridExcelExportOptions & GridExportDisplayOptions;
+  }
+}
+declare module '@mui/x-data-grid-pro/internals' {
+  interface GridApiCaches extends GridApiCachesPremium {}
+  interface GridBaseColDef<R, V, F> extends GridColDefPremium<R, V, F> {}
+}
+export {};

package/esm/typeOverloads/reexports.d.ts

@@ -0,0 +1,17 @@
+import type { GridApiPremium } from '../models/gridApiPremium';
+import { GridInitialStatePremium, GridStatePremium } from "../models/gridStatePremium.js";
+export { useGridApiContext } from "../hooks/utils/useGridApiContext.js";
+export { useGridApiRef } from "../hooks/utils/useGridApiRef.js";
+export { useGridRootProps } from "../hooks/utils/useGridRootProps.js";
+/**
+ * The full grid API.
+ */
+export type GridApi = GridApiPremium;
+/**
+ * The state of Data Grid Premium.
+ */
+export type GridState = GridStatePremium;
+/**
+ * The initial state of Data Grid Premium.
+ */
+export type GridInitialState = GridInitialStatePremium;

package/esm/utils/releaseInfo.d.ts

@@ -0,0 +1 @@
+export declare const getReleaseInfo: () => any;

package/esm/utils/releaseInfo.js

@@ -1,6 +1,6 @@
 import { ponyfillGlobal } from '@mui/utils';
 export const getReleaseInfo = () => {
-  const releaseInfo = "MTczODg4MjgwMDAwMA==";
+  const releaseInfo = "MTc0MDY5NzIwMDAwMA==";
   if (process.env.NODE_ENV !== 'production') {
     // A simple hack to set the value in the test environment (has no build step).
     // eslint-disable-next-line no-useless-concat

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

@@ -1,11 +1,17 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiPremium } from '../../../models/gridApiPremium';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationLookup } from './gridAggregationInterfaces';
-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;
+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/hooks/features/aggregation/createAggregationLookup.js

@@ -26,7 +26,7 @@ const getGroupAggregatedValue = (groupId, apiRef, aggregationRowsScope, aggregat
     //   A.B
     //     A.B.A
     //     A.B.B
-    const rowNode = apiRef.current.getRowNode(rowId);
+    const rowNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, rowId);
     if (rowNode.type === 'group') {
       return;
     }
@@ -76,7 +76,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/hooks/features/aggregation/gridAggregationFunctions.d.ts

@@ -1,8 +1,8 @@
-import { GridAggregationFunction } from './gridAggregationInterfaces';
+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>;
-};
+  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/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);
 
 /**