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

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 = "MTczODI5OTYwMDAwMA==";
+  const releaseInfo = "MTczOTc0NjgwMDAwMA==";
   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);
 
 /**

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/gridAggregationUtils.js

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

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

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

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

@@ -1,6 +1,6 @@
 import { 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/useGridAggregation.js

@@ -41,7 +41,6 @@ const useGridAggregation = (apiRef, props) => {
     const currentModel = (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef);
     if (currentModel !== model) {
       apiRef.current.setState((0, _gridAggregationUtils.mergeStateWithAggregationModel)(model));
-      apiRef.current.forceUpdate();
     }
   }, [apiRef]);
   const applyAggregation = React.useCallback(() => {
@@ -95,7 +94,6 @@ const useGridAggregation = (apiRef, props) => {
 
     // Re-apply the column hydration to wrap / unwrap the aggregated columns
     if (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastColumnHydration, aggregationRules)) {
-      apiRef.current.caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
       apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
     }
   }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);

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;