@mui/x-data-grid-premium 5.13.1 → 5.14.0

package/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -0,0 +1,137 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import MuiDivider from '@mui/material/Divider';
+import { gridColumnLookupSelector } from '@mui/x-data-grid-pro';
+import { useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
+import { getAvailableAggregationFunctions, addFooterRows, getAggregationRules, mergeStateWithAggregationModel } from './gridAggregationUtils';
+import { wrapColumnWithAggregationValue, unwrapColumnFromAggregation } from './wrapColumnWithAggregation';
+import { GridAggregationColumnMenuItem } from '../../../components/GridAggregationColumnMenuItem';
+import { gridAggregationModelSelector } from './gridAggregationSelectors';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+const Divider = () => /*#__PURE__*/_jsx(MuiDivider, {
+  onClick: event => event.stopPropagation()
+});
+
+export const useGridAggregationPreProcessors = (apiRef, props) => {
+  const updateAggregatedColumns = React.useCallback(columnsState => {
+    const {
+      rulesOnLastColumnHydration
+    } = apiRef.current.unstable_caches.aggregation;
+    const aggregationRules = props.private_disableAggregation ? {} : getAggregationRules({
+      columnsLookup: columnsState.lookup,
+      aggregationModel: gridAggregationModelSelector(apiRef),
+      aggregationFunctions: props.private_aggregationFunctions
+    });
+    columnsState.all.forEach(field => {
+      const shouldHaveAggregationValue = !!aggregationRules[field];
+      const haveAggregationColumnValue = !!rulesOnLastColumnHydration[field];
+      let column = columnsState.lookup[field];
+
+      if (haveAggregationColumnValue) {
+        column = unwrapColumnFromAggregation({
+          column
+        });
+      }
+
+      if (shouldHaveAggregationValue) {
+        column = wrapColumnWithAggregationValue({
+          column,
+          aggregationRule: aggregationRules[field],
+          apiRef
+        });
+      }
+
+      columnsState.lookup[field] = column;
+    });
+    apiRef.current.unstable_caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
+    return columnsState;
+  }, [apiRef, props.private_aggregationFunctions, props.private_disableAggregation]);
+  const addGroupFooterRows = React.useCallback(groupingParams => {
+    let newGroupingParams;
+    let rulesOnLastRowHydration;
+
+    if (props.private_disableAggregation) {
+      newGroupingParams = groupingParams;
+      rulesOnLastRowHydration = {};
+    } else {
+      const aggregationRules = getAggregationRules({
+        columnsLookup: gridColumnLookupSelector(apiRef),
+        aggregationModel: gridAggregationModelSelector(apiRef),
+        aggregationFunctions: props.private_aggregationFunctions
+      });
+      rulesOnLastRowHydration = aggregationRules; // If no column have an aggregation rule
+      // Then don't create the footer rows
+
+      if (Object.values(aggregationRules).length === 0) {
+        newGroupingParams = groupingParams;
+      } else {
+        newGroupingParams = addFooterRows({
+          groupingParams,
+          aggregationRules,
+          getAggregationPosition: props.private_getAggregationPosition
+        });
+      }
+    }
+
+    apiRef.current.unstable_caches.aggregation.rulesOnLastRowHydration = rulesOnLastRowHydration;
+    return newGroupingParams;
+  }, [apiRef, props.private_disableAggregation, props.private_getAggregationPosition, props.private_aggregationFunctions]);
+  const addColumnMenuButtons = React.useCallback((initialValue, column) => {
+    if (props.private_disableAggregation) {
+      return initialValue;
+    }
+
+    const availableAggregationFunctions = getAvailableAggregationFunctions({
+      aggregationFunctions: props.private_aggregationFunctions,
+      column
+    });
+
+    if (availableAggregationFunctions.length === 0) {
+      return initialValue;
+    }
+
+    return [...initialValue, /*#__PURE__*/_jsx(Divider, {}), /*#__PURE__*/_jsx(GridAggregationColumnMenuItem, {
+      column: column,
+      label: apiRef.current.getLocaleText('aggregationMenuItemHeader'),
+      availableAggregationFunctions: availableAggregationFunctions
+    })];
+  }, [apiRef, props.private_aggregationFunctions, props.private_disableAggregation]);
+  const stateExportPreProcessing = React.useCallback(prevState => {
+    if (props.private_disableAggregation) {
+      return prevState;
+    }
+
+    const aggregationModelToExport = gridAggregationModelSelector(apiRef);
+
+    if (Object.values(aggregationModelToExport).length === 0) {
+      return prevState;
+    }
+
+    return _extends({}, prevState, {
+      private_aggregation: {
+        model: aggregationModelToExport
+      }
+    });
+  }, [apiRef, props.private_disableAggregation]);
+  const stateRestorePreProcessing = React.useCallback((params, context) => {
+    var _context$stateToResto;
+
+    if (props.private_disableAggregation) {
+      return params;
+    }
+
+    const aggregationModel = (_context$stateToResto = context.stateToRestore.private_aggregation) == null ? void 0 : _context$stateToResto.model;
+
+    if (aggregationModel != null) {
+      apiRef.current.setState(mergeStateWithAggregationModel(aggregationModel));
+    }
+
+    return params;
+  }, [apiRef, props.private_disableAggregation]);
+  useGridRegisterPipeProcessor(apiRef, 'hydrateColumns', updateAggregatedColumns);
+  useGridRegisterPipeProcessor(apiRef, 'hydrateRows', addGroupFooterRows);
+  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButtons);
+  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
+  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
+};

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

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { GridColDef } from '@mui/x-data-grid-pro';
+import { GridApiPremium } from '../../../models/gridApiPremium';
+import { GridAggregationRule } from './gridAggregationInterfaces';
+declare const AGGREGATION_WRAPPABLE_PROPERTIES: readonly ["valueGetter", "valueFormatter", "renderCell", "renderHeader", "filterOperators"];
+declare type WrappableColumnProperty = typeof AGGREGATION_WRAPPABLE_PROPERTIES[number];
+interface GridColDefWithAggregationWrappers extends GridColDef {
+    aggregationWrappedProperties?: {
+        [P in WrappableColumnProperty]?: {
+            original: GridColDef[P];
+            wrapped: GridColDef[P];
+        };
+    };
+}
+/**
+ * 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: GridColDef;
+    apiRef: React.MutableRefObject<GridApiPremium>;
+    aggregationRule: GridAggregationRule;
+}) => GridColDef;
+/**
+ * Remove the aggregation wrappers around the wrappable properties of the column.
+ */
+export declare const unwrapColumnFromAggregation: ({ column, }: {
+    column: GridColDefWithAggregationWrappers;
+}) => GridColDef<any, any, any>;
+export {};

package/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -0,0 +1,257 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { gridAggregationLookupSelector } from './gridAggregationSelectors';
+import { GridFooterCell } from '../../../components/GridFooterCell';
+import { GridAggregationHeader } from '../../../components/GridAggregationHeader';
+import { jsx as _jsx } from "react/jsx-runtime";
+const AGGREGATION_WRAPPABLE_PROPERTIES = ['valueGetter', 'valueFormatter', 'renderCell', 'renderHeader', 'filterOperators'];
+
+const getAggregationValueWrappedValueGetter = ({
+  value: valueGetter,
+  getCellAggregationResult
+}) => {
+  const wrappedValueGetter = params => {
+    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+    if (cellAggregationResult != null) {
+      var _cellAggregationResul;
+
+      return (_cellAggregationResul = cellAggregationResult == null ? void 0 : cellAggregationResult.value) != null ? _cellAggregationResul : null;
+    }
+
+    if (valueGetter) {
+      return valueGetter(params);
+    }
+
+    return params.row[params.field];
+  };
+
+  return wrappedValueGetter;
+};
+
+const getAggregationValueWrappedValueFormatter = ({
+  value: valueFormatter,
+  aggregationRule,
+  getCellAggregationResult
+}) => {
+  // If neither the inline aggregation function nor the footer aggregation function have a custom value formatter,
+  // Then we don't wrap the column value formatter
+  if (!aggregationRule.aggregationFunction.valueFormatter) {
+    return valueFormatter;
+  }
+
+  const wrappedValueFormatter = params => {
+    if (params.id != null) {
+      const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+      if (cellAggregationResult != null) {
+        return aggregationRule.aggregationFunction.valueFormatter(params);
+      }
+    }
+
+    if (valueFormatter) {
+      return valueFormatter(params);
+    }
+
+    return params.value;
+  };
+
+  return wrappedValueFormatter;
+};
+
+const getAggregationValueWrappedRenderCell = ({
+  value: renderCell,
+  aggregationRule,
+  getCellAggregationResult
+}) => {
+  const wrappedRenderCell = params => {
+    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+    if (cellAggregationResult != null) {
+      var _aggregationFunction$;
+
+      if (!renderCell) {
+        if (cellAggregationResult.position === 'footer') {
+          return /*#__PURE__*/_jsx(GridFooterCell, _extends({}, params));
+        }
+
+        return params.formattedValue;
+      }
+
+      const aggregationMeta = {
+        hasCellUnit: (_aggregationFunction$ = aggregationRule.aggregationFunction.hasCellUnit) != null ? _aggregationFunction$ : true,
+        aggregationFunctionName: aggregationRule.aggregationFunctionName
+      };
+      return renderCell(_extends({}, params, {
+        aggregation: aggregationMeta
+      }));
+    }
+
+    if (!renderCell) {
+      return params.formattedValue;
+    }
+
+    return renderCell(params);
+  };
+
+  return wrappedRenderCell;
+};
+/**
+ * Skips the filtering for aggregated rows
+ */
+
+
+const getWrappedFilterOperators = ({
+  value: filterOperators,
+  getCellAggregationResult
+}) => filterOperators.map(operator => {
+  return _extends({}, operator, {
+    getApplyFilterFn: (filterItem, column) => {
+      const originalFn = operator.getApplyFilterFn(filterItem, column);
+
+      if (!originalFn) {
+        return null;
+      }
+
+      return params => {
+        if (getCellAggregationResult(params.id, params.field) != null) {
+          return true;
+        }
+
+        return originalFn(params);
+      };
+    }
+  });
+});
+/**
+ * Add the aggregation method around the header name
+ */
+
+
+const getWrappedRenderHeader = ({
+  value: renderHeader,
+  aggregationRule
+}) => {
+  const wrappedRenderCell = params => {
+    const aggregationMeta = {
+      aggregationRule
+    };
+
+    if (!renderHeader) {
+      return /*#__PURE__*/_jsx(GridAggregationHeader, _extends({}, params, {
+        aggregation: aggregationMeta
+      }));
+    }
+
+    return renderHeader(_extends({}, params, {
+      aggregation: aggregationMeta
+    }));
+  };
+
+  return wrappedRenderCell;
+};
+/**
+ * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
+ */
+
+
+export const wrapColumnWithAggregationValue = ({
+  column,
+  apiRef,
+  aggregationRule
+}) => {
+  const getCellAggregationResult = (id, field) => {
+    var _parent, _gridAggregationLooku;
+
+    let cellAggregationPosition = null;
+
+    if (id.toString().startsWith('auto-generated-row-')) {
+      cellAggregationPosition = 'inline';
+    } else if (id.toString().startsWith('auto-generated-group-footer-')) {
+      cellAggregationPosition = 'footer';
+    }
+
+    if (cellAggregationPosition == null) {
+      return null;
+    } // TODO: Add custom root id
+
+
+    const groupId = cellAggregationPosition === 'inline' ? id : (_parent = apiRef.current.getRowNode(id).parent) != null ? _parent : '';
+    const aggregationResult = (_gridAggregationLooku = gridAggregationLookupSelector(apiRef)[groupId]) == null ? void 0 : _gridAggregationLooku[field];
+
+    if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
+      return null;
+    }
+
+    return aggregationResult;
+  };
+
+  const aggregationWrappedProperties = {};
+
+  const wrappedColumn = _extends({}, column, {
+    aggregationWrappedProperties
+  });
+
+  const wrapColumnProperty = (property, wrapper) => {
+    const originalValue = column[property];
+    const wrappedProperty = wrapper({
+      apiRef,
+      value: originalValue,
+      colDef: column,
+      aggregationRule,
+      getCellAggregationResult
+    });
+
+    if (wrappedProperty !== originalValue) {
+      aggregationWrappedProperties[property] = {
+        original: originalValue,
+        wrapped: wrappedProperty
+      };
+      wrappedColumn[property] = wrappedProperty;
+    }
+  };
+
+  wrapColumnProperty('valueGetter', getAggregationValueWrappedValueGetter);
+  wrapColumnProperty('valueFormatter', getAggregationValueWrappedValueFormatter);
+  wrapColumnProperty('renderCell', getAggregationValueWrappedRenderCell);
+  wrapColumnProperty('renderHeader', getWrappedRenderHeader);
+  wrapColumnProperty('filterOperators', getWrappedFilterOperators);
+
+  if (Object.keys(aggregationWrappedProperties).length === 0) {
+    return column;
+  }
+
+  return wrappedColumn;
+};
+/**
+ * Remove the aggregation wrappers around the wrappable properties of the column.
+ */
+
+export const unwrapColumnFromAggregation = ({
+  column
+}) => {
+  if (!column.aggregationWrappedProperties) {
+    return column;
+  }
+
+  const originalProperties = Object.entries(column.aggregationWrappedProperties);
+
+  if (originalProperties.length === 0) {
+    return column;
+  }
+
+  const unwrappedColumn = _extends({}, column);
+
+  originalProperties.forEach(([propertyName, {
+    original,
+    wrapped
+  }]) => {
+    // The value changed since we wrapped it
+    if (wrapped !== column[propertyName]) {
+      return;
+    }
+
+    unwrappedColumn[propertyName] = original;
+  });
+  return unwrappedColumn;
+};

package/hooks/features/export/serializer/excelSerializer.js

@@ -46,7 +46,8 @@ const serializeRow = (id, columns, api, defaultValueOptionsFormulae) => {
   api.unstable_calculateColSpan({
     rowId: id,
     minFirstColumn: 0,
-    maxLastColumn: columns.length - 1
+    maxLastColumn: columns.length,
+    columns
   });
   columns.forEach((column, colIndex) => {
     const colSpanInfo = api.unstable_getCellColSpanInfo(id, colIndex);

package/hooks/features/index.d.ts

@@ -1,2 +1,3 @@
+export * from './aggregation';
 export * from './rowGrouping';
 export * from './export';

package/hooks/features/index.js

@@ -1,3 +1,4 @@
 // Only export the variable and types that should be publicly exposed and re-exported from `@mui/x-data-grid-premium`
+export * from './aggregation';
 export * from './rowGrouping';
 export * from './export';

package/hooks/features/rowGrouping/createGroupingColDef.js

@@ -4,6 +4,7 @@ const _excluded = ["leafField", "mainGroupingCriteria", "hideDescendantCount"],
       _excluded2 = ["leafField", "mainGroupingCriteria", "hideDescendantCount"];
 import * as React from 'react';
 import { GRID_STRING_COL_DEF } from '@mui/x-data-grid-pro';
+import { GridGroupingColumnFooterCell } from '../../../components/GridGroupingColumnFooterCell';
 import { GridGroupingCriteriaCell } from '../../../components/GridGroupingCriteriaCell';
 import { GridGroupingColumnLeafCell } from '../../../components/GridGroupingColumnLeafCell';
 import { getRowGroupingFieldFromGroupingCriteria, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD } from './gridRowGroupingUtils';
@@ -152,7 +153,12 @@ export const createGroupingColDefForOneGroupingCriteria = ({
   const commonProperties = {
     width: Math.max(((_groupedByColDef$widt = groupedByColDef.width) != null ? _groupedByColDef$widt : GRID_STRING_COL_DEF.width) + 40, (_leafColDef$width = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width : 0),
     renderCell: params => {
-      // Render leaves
+      // Render footer
+      if (params.rowNode.position === 'footer') {
+        return /*#__PURE__*/_jsx(GridGroupingColumnFooterCell, _extends({}, params));
+      } // Render leaves
+
+
       if (params.rowNode.groupingField == null) {
         if (leafColDef) {
           const leafParams = _extends({}, params.api.getCellParams(params.id, leafField), {
@@ -253,7 +259,12 @@ export const createGroupingColDefForAllGroupingCriteria = ({
       return ((_columnsLookup$field$ = columnsLookup[field].width) != null ? _columnsLookup$field$ : GRID_STRING_COL_DEF.width) + 40;
     }), (_leafColDef$width2 = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width2 : 0),
     renderCell: params => {
-      // Render the leaves
+      // Render footer
+      if (params.rowNode.position === 'footer') {
+        return /*#__PURE__*/_jsx(GridGroupingColumnFooterCell, _extends({}, params));
+      } // Render the leaves
+
+
       if (params.rowNode.groupingField == null) {
         if (leafColDef) {
           const leafParams = _extends({}, params.api.getCellParams(params.id, leafField), {

package/hooks/features/rowGrouping/gridRowGroupingUtils.js

@@ -79,13 +79,17 @@ export const filterRowTreeFromGroupingColumns = params => {
     visibleRowsLookup[node.id] = shouldPassFilters && areAncestorsExpanded;
     filteredRowsLookup[node.id] = shouldPassFilters;
 
+    if (node.footerId != null) {
+      visibleRowsLookup[node.footerId] = shouldPassFilters && areAncestorsExpanded && !!node.childrenExpanded;
+    }
+
     if (!shouldPassFilters) {
       return 0;
     }
 
     filteredDescendantCountLookup[node.id] = filteredDescendantCount;
 
-    if (!node.children) {
+    if (!node.children && !node.isAutoGenerated) {
       return filteredDescendantCount + 1;
     }
 

package/hooks/features/rowGrouping/useGridRowGrouping.d.ts

@@ -8,4 +8,4 @@ export declare const rowGroupingStateInitializer: GridStateInitializer<Pick<Data
  * @requires useGridRows (state, method) - can be after, async only
  * @requires useGridParamsApi (method) - can be after, async only
  */
-export declare const useGridRowGrouping: (apiRef: React.MutableRefObject<GridApiPremium>, props: Pick<DataGridPremiumProcessedProps, 'rowGroupingModel' | 'onRowGroupingModelChange' | 'defaultGroupingExpansionDepth' | 'isGroupExpandedByDefault' | 'groupingColDef' | 'rowGroupingColumnMode' | 'disableRowGrouping'>) => void;
+export declare const useGridRowGrouping: (apiRef: React.MutableRefObject<GridApiPremium>, props: Pick<DataGridPremiumProcessedProps, 'initialState' | 'rowGroupingModel' | 'onRowGroupingModelChange' | 'defaultGroupingExpansionDepth' | 'isGroupExpandedByDefault' | 'groupingColDef' | 'rowGroupingColumnMode' | 'disableRowGrouping'>) => void;

package/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import Divider from '@mui/material/Divider';
+import MuiDivider from '@mui/material/Divider';
 import { useGridApiEventHandler, useGridApiMethod, gridFilteredDescendantCountLookupSelector } from '@mui/x-data-grid-pro';
 import { useGridRegisterPipeProcessor, isDeepEqual } from '@mui/x-data-grid-pro/internals';
 import { gridRowGroupingModelSelector, gridRowGroupingSanitizedModelSelector } from './gridRowGroupingSelector';
@@ -8,6 +8,11 @@ import { getRowGroupingFieldFromGroupingCriteria, ROW_GROUPING_STRATEGY, isGroup
 import { GridRowGroupableColumnMenuItems } from '../../../components/GridRowGroupableColumnMenuItems';
 import { GridRowGroupingColumnMenuItems } from '../../../components/GridRowGroupingColumnMenuItems';
 import { jsx as _jsx } from "react/jsx-runtime";
+
+const Divider = () => /*#__PURE__*/_jsx(MuiDivider, {
+  onClick: event => event.stopPropagation()
+});
+
 export const rowGroupingStateInitializer = (state, props, apiRef) => {
   var _ref, _props$rowGroupingMod, _props$initialState, _props$initialState$r;
 
@@ -27,6 +32,8 @@ export const rowGroupingStateInitializer = (state, props, apiRef) => {
  */
 
 export const useGridRowGrouping = (apiRef, props) => {
+  var _props$initialState3, _props$initialState3$;
+
   apiRef.current.unstable_registerControlState({
     stateId: 'rowGrouping',
     propModel: props.rowGroupingModel,
@@ -90,16 +97,16 @@ export const useGridRowGrouping = (apiRef, props) => {
    * PRE-PROCESSING
    */
 
-  const addColumnMenuButtons = React.useCallback((initialValue, columns) => {
+  const addColumnMenuButtons = React.useCallback((initialValue, column) => {
     if (props.disableRowGrouping) {
       return initialValue;
     }
 
     let menuItems;
 
-    if (isGroupingColumn(columns.field)) {
+    if (isGroupingColumn(column.field)) {
       menuItems = /*#__PURE__*/_jsx(GridRowGroupingColumnMenuItems, {});
-    } else if (columns.groupable) {
+    } else if (column.groupable) {
       menuItems = /*#__PURE__*/_jsx(GridRowGroupableColumnMenuItems, {});
     } else {
       menuItems = null;
@@ -111,14 +118,17 @@ export const useGridRowGrouping = (apiRef, props) => {
 
     return [...initialValue, /*#__PURE__*/_jsx(Divider, {}), menuItems];
   }, [props.disableRowGrouping]);
-  const stateExportPreProcessing = React.useCallback(prevState => {
-    if (props.disableRowGrouping) {
-      return prevState;
-    }
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
+    var _props$initialState2, _props$initialState2$;
 
     const rowGroupingModelToExport = gridRowGroupingModelSelector(apiRef);
+    const shouldExportRowGroupingModel = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the model is controlled
+    props.rowGroupingModel != null || // Always export if the model has been initialized
+    ((_props$initialState2 = props.initialState) == null ? void 0 : (_props$initialState2$ = _props$initialState2.rowGrouping) == null ? void 0 : _props$initialState2$.model) != null || // Export if the model is not empty
+    Object.keys(rowGroupingModelToExport).length > 0;
 
-    if (rowGroupingModelToExport.length === 0) {
+    if (!shouldExportRowGroupingModel) {
       return prevState;
     }
 
@@ -127,7 +137,7 @@ export const useGridRowGrouping = (apiRef, props) => {
         model: rowGroupingModelToExport
       }
     });
-  }, [apiRef, props.disableRowGrouping]);
+  }, [apiRef, props.rowGroupingModel, (_props$initialState3 = props.initialState) == null ? void 0 : (_props$initialState3$ = _props$initialState3.rowGrouping) == null ? void 0 : _props$initialState3$.model]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     var _context$stateToResto;
 

package/index.js

@@ -1,4 +1,4 @@
-/** @license MUI v5.13.1
+/** @license MUI v5.14.0
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.

package/legacy/DataGridPremium/DataGridPremium.js

@@ -275,6 +275,7 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
   experimentalFeatures: PropTypes.shape({
     newEditingApi: PropTypes.bool,
     preventCommitWhileValidating: PropTypes.bool,
+    private_aggregation: PropTypes.bool,
     warnIfFocusStateIsNotSynced: PropTypes.bool
   }),
 
@@ -866,6 +867,52 @@ process.env.NODE_ENV !== "production" ? DataGridPremiumRaw.propTypes = {
     right: PropTypes.arrayOf(PropTypes.string)
   }),
 
+  /**
+   * Aggregation functions available on the grid.
+   * @default GRID_AGGREGATION_FUNCTIONS
+   * @ignore - do not document.
+   */
+  private_aggregationFunctions: PropTypes.object,
+
+  /**
+   * Set the aggregation model of the grid.
+   * @ignore - do not document.
+   */
+  private_aggregationModel: PropTypes.object,
+
+  /**
+   * Rows used to generate the aggregated value.
+   * If `filtered`, the aggregated values will be generated using only the rows currently passing the filtering process.
+   * If `all`, the aggregated values will be generated using all the rows.
+   * @default "filtered"
+   * @ignore - do not document.
+   */
+  private_aggregationRowsScope: PropTypes.oneOf(['all', 'filtered']),
+
+  /**
+   * If `true`, aggregation is disabled.
+   * @default false
+   * @ignore - do not document.
+   */
+  private_disableAggregation: PropTypes.bool,
+
+  /**
+   * Determines the position of an aggregated value.
+   * @param {GridRowTreeNodeConfig | null} groupNode The current group (`null` being the top level group).
+   * @returns {GridAggregationPosition | null} Position of the aggregated value (if `null`, the group will not be aggregated).
+   * @default `(groupNode) => groupNode == null ? 'footer' : 'inline'`
+   * @ignore - do not document.
+   */
+  private_getAggregationPosition: PropTypes.func,
+
+  /**
+   * Callback fired when the row grouping model changes.
+   * @param {GridAggregationModel} model The aggregated columns.
+   * @param {GridCallbackDetails} details Additional details for this callback.
+   * @ignore - do not document.
+   */
+  private_onAggregationModelChange: PropTypes.func,
+
   /**
    * Callback called before updating a row with new values in the row and cell editing.
    * Only applied if `props.experimentalFeatures.newEditingApi: true`.