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

package/legacy/DataGridPremium/useDataGridPremiumComponent.js

@@ -1,5 +1,7 @@
 import { useGridInitialization, useGridInitializeState, useGridClipboard, useGridColumnMenu, useGridColumns, columnsStateInitializer, useGridDensity, useGridCsvExport, useGridPrintExport, useGridFilter, filterStateInitializer, useGridFocus, useGridKeyboardNavigation, useGridPagination, paginationStateInitializer, useGridPreferencesPanel, useGridEditing_new, useGridEditing_old, editingStateInitializer_old, editingStateInitializer_new, useGridRows, useGridRowsPreProcessors, rowsStateInitializer, useGridRowsMeta, useGridParamsApi, useGridSelection, useGridSorting, sortingStateInitializer, useGridScroll, useGridEvents, useGridDimensions, useGridStatePersistence, useGridSelectionPreProcessors, columnMenuStateInitializer, densityStateInitializer, focusStateInitializer, preferencePanelStateInitializer, rowsMetaStateInitializer, selectionStateInitializer, useGridColumnReorder, columnReorderStateInitializer, useGridColumnResize, columnResizeStateInitializer, useGridTreeData, useGridTreeDataPreProcessors, useGridColumnPinning, columnPinningStateInitializer, useGridColumnPinningPreProcessors, useGridDetailPanel, detailPanelStateInitializer, useGridDetailPanelPreProcessors, useGridInfiniteLoader, useGridColumnSpanning, useGridRowReorder, useGridRowReorderPreProcessors } from '@mui/x-data-grid-pro/internals';
 // Premium-only features
+import { useGridAggregation, aggregationStateInitializer } from '../hooks/features/aggregation/useGridAggregation';
+import { useGridAggregationPreProcessors } from '../hooks/features/aggregation/useGridAggregationPreProcessors';
 import { useGridRowGrouping, rowGroupingStateInitializer } from '../hooks/features/rowGrouping/useGridRowGrouping';
 import { useGridRowGroupingPreProcessors } from '../hooks/features/rowGrouping/useGridRowGroupingPreProcessors';
 import { useGridExcelExport } from '../hooks/features/export/useGridExcelExport';
@@ -15,6 +17,7 @@ export var useDataGridPremiumComponent = function useDataGridPremiumComponent(in
   useGridRowReorderPreProcessors(apiRef, props);
   useGridRowGroupingPreProcessors(apiRef, props);
   useGridTreeDataPreProcessors(apiRef, props);
+  useGridAggregationPreProcessors(apiRef, props);
   useGridDetailPanelPreProcessors(apiRef, props); // The column pinning `hydrateColumns` pre-processor must be after every other `hydrateColumns` pre-processors
   // Because it changes the order of the columns.
 
@@ -25,6 +28,7 @@ export var useDataGridPremiumComponent = function useDataGridPremiumComponent(in
    */
 
   useGridInitializeState(rowGroupingStateInitializer, apiRef, props);
+  useGridInitializeState(aggregationStateInitializer, apiRef, props);
   useGridInitializeState(selectionStateInitializer, apiRef, props);
   useGridInitializeState(detailPanelStateInitializer, apiRef, props);
   useGridInitializeState(columnPinningStateInitializer, apiRef, props);
@@ -43,6 +47,7 @@ export var useDataGridPremiumComponent = function useDataGridPremiumComponent(in
   useGridInitializeState(columnMenuStateInitializer, apiRef, props);
   useGridRowGrouping(apiRef, props);
   useGridTreeData(apiRef);
+  useGridAggregation(apiRef, props);
   useGridKeyboardNavigation(apiRef, props);
   useGridSelection(apiRef, props);
   useGridColumnPinning(apiRef, props);
@@ -54,7 +59,7 @@ export var useDataGridPremiumComponent = function useDataGridPremiumComponent(in
   var useGridEditing = (_props$experimentalFe2 = props.experimentalFeatures) != null && _props$experimentalFe2.newEditingApi ? useGridEditing_new : useGridEditing_old;
   useGridEditing(apiRef, props);
   useGridFocus(apiRef, props);
-  useGridPreferencesPanel(apiRef);
+  useGridPreferencesPanel(apiRef, props);
   useGridFilter(apiRef, props);
   useGridSorting(apiRef, props);
   useGridDensity(apiRef, props);

package/legacy/DataGridPremium/useDataGridPremiumProps.js

@@ -3,13 +3,20 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useThemeProps } from '@mui/material/styles';
 import { DATA_GRID_PRO_PROPS_DEFAULT_VALUES, DATA_GRID_DEFAULT_SLOTS_COMPONENTS, GRID_DEFAULT_LOCALE_TEXT } from '@mui/x-data-grid-pro';
-
+import { PRIVATE_GRID_AGGREGATION_FUNCTIONS } from '../hooks/features/aggregation';
 /**
  * The default values of `DataGridPremiumPropsWithDefaultValue` to inject in the props of DataGridPremium.
  */
+
 export var DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES = _extends({}, DATA_GRID_PRO_PROPS_DEFAULT_VALUES, {
+  private_disableAggregation: false,
   disableRowGrouping: false,
-  rowGroupingColumnMode: 'single'
+  rowGroupingColumnMode: 'single',
+  private_aggregationFunctions: PRIVATE_GRID_AGGREGATION_FUNCTIONS,
+  private_aggregationRowsScope: 'filtered',
+  private_getAggregationPosition: function private_getAggregationPosition(groupNode) {
+    return groupNode == null ? 'footer' : 'inline';
+  }
 });
 export var useDataGridPremiumProps = function useDataGridPremiumProps(inProps) {
   var themedProps = useThemeProps({
@@ -37,7 +44,10 @@ export var useDataGridPremiumProps = function useDataGridPremiumProps(inProps) {
     return mergedComponents;
   }, [themedProps.components]);
   return React.useMemo(function () {
+    var _themedProps$experime;
+
     return _extends({}, DATA_GRID_PREMIUM_PROPS_DEFAULT_VALUES, themedProps, {
+      private_disableAggregation: themedProps.private_disableAggregation || !((_themedProps$experime = themedProps.experimentalFeatures) != null && _themedProps$experime.private_aggregation),
       localeText: localeText,
       components: components,
       signature: 'DataGridPremium'

package/legacy/components/GridAggregationColumnMenuItem.js

@@ -0,0 +1,95 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import * as React from 'react';
+import { useGridSelector } from '@mui/x-data-grid-pro';
+import MenuItem from '@mui/material/MenuItem';
+import FormControl from '@mui/material/FormControl';
+import InputLabel from '@mui/material/InputLabel';
+import { unstable_useId as useId } from '@mui/material/utils';
+import Select from '@mui/material/Select';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { canColumnHaveAggregationFunction, getAggregationFunctionLabel } from '../hooks/features/aggregation/gridAggregationUtils';
+import { gridAggregationModelSelector } from '../hooks/features/aggregation/gridAggregationSelectors';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var GridAggregationColumnMenuItem = function GridAggregationColumnMenuItem(props) {
+  var column = props.column,
+      label = props.label,
+      availableAggregationFunctions = props.availableAggregationFunctions;
+  var apiRef = useGridApiContext();
+  var rootProps = useGridRootProps();
+  var id = useId();
+  var aggregationModel = useGridSelector(apiRef, gridAggregationModelSelector);
+  var selectedAggregationRule = React.useMemo(function () {
+    if (!column || !aggregationModel[column.field]) {
+      return '';
+    }
+
+    var aggregationFunctionName = aggregationModel[column.field];
+
+    if (canColumnHaveAggregationFunction({
+      column: column,
+      aggregationFunctionName: aggregationFunctionName,
+      aggregationFunction: rootProps.private_aggregationFunctions[aggregationFunctionName]
+    })) {
+      return aggregationFunctionName;
+    }
+
+    return '';
+  }, [rootProps.private_aggregationFunctions, aggregationModel, column]);
+
+  var handleAggregationItemChange = function handleAggregationItemChange(event) {
+    var newAggregationItem = event.target.value || undefined;
+    var currentModel = gridAggregationModelSelector(apiRef);
+
+    var _column$field = column.field,
+        columnItem = currentModel[_column$field],
+        otherColumnItems = _objectWithoutProperties(currentModel, [_column$field].map(_toPropertyKey));
+
+    var newModel = newAggregationItem == null ? otherColumnItems : _extends({}, otherColumnItems, _defineProperty({}, column.field, newAggregationItem));
+    apiRef.current.private_setAggregationModel(newModel);
+    apiRef.current.hideColumnMenu();
+  };
+
+  return /*#__PURE__*/_jsx(MenuItem, {
+    disableRipple: true,
+    children: /*#__PURE__*/_jsxs(FormControl, {
+      size: "small",
+      sx: {
+        width: 150
+      },
+      children: [/*#__PURE__*/_jsx(InputLabel, {
+        id: "".concat(id, "-label"),
+        children: label
+      }), /*#__PURE__*/_jsxs(Select, {
+        labelId: "".concat(id, "-label"),
+        id: "".concat(id, "-input"),
+        value: selectedAggregationRule,
+        label: label,
+        onChange: handleAggregationItemChange,
+        onBlur: function onBlur(e) {
+          return e.stopPropagation();
+        },
+        fullWidth: true,
+        children: [/*#__PURE__*/_jsx(MenuItem, {
+          value: "",
+          children: "..."
+        }), availableAggregationFunctions.map(function (aggFunc) {
+          return /*#__PURE__*/_jsx(MenuItem, {
+            value: aggFunc,
+            children: getAggregationFunctionLabel({
+              apiRef: apiRef,
+              aggregationRule: {
+                aggregationFunctionName: aggFunc,
+                aggregationFunction: rootProps.private_aggregationFunctions[aggFunc]
+              }
+            })
+          }, aggFunc);
+        })]
+      })]
+    })
+  });
+};

package/legacy/components/GridAggregationHeader.js

@@ -0,0 +1,95 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+var _styled;
+
+import * as React from 'react';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import Box from '@mui/material/Box';
+import { styled } from '@mui/material/styles';
+import { getDataGridUtilityClass, gridClasses, GridColumnHeaderTitle, gridDensityHeaderHeightSelector, useGridSelector } from '@mui/x-data-grid';
+import { getAggregationFunctionLabel } from '../hooks/features/aggregation/gridAggregationUtils';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var GridAggregationHeaderRoot = styled(Box, {
+  name: 'MuiDataGrid',
+  slot: 'AggregationColumnHeader',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.aggregationColumnHeader;
+  }
+})((_styled = {
+  display: 'flex',
+  flexDirection: 'column'
+}, _defineProperty(_styled, "&.".concat(gridClasses['aggregationColumnHeader--alignRight']), {
+  alignItems: 'flex-end'
+}), _defineProperty(_styled, "&.".concat(gridClasses['aggregationColumnHeader--alignCenter']), {
+  alignItems: 'center'
+}), _styled));
+var GridAggregationFunctionLabel = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'AggregationColumnHeaderLabel',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.aggregationColumnHeaderLabel;
+  }
+})(function (_ref) {
+  var theme = _ref.theme;
+  return {
+    fontSize: theme.typography.caption.fontSize,
+    lineHeight: theme.typography.caption.fontSize,
+    marginTop: "calc(-2px - ".concat(theme.typography.caption.fontSize, ")"),
+    fontWeight: theme.typography.fontWeightMedium,
+    color: theme.palette.primary.dark,
+    textTransform: 'uppercase'
+  };
+});
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes,
+      colDef = ownerState.colDef;
+  var slots = {
+    root: ['aggregationColumnHeader', colDef.headerAlign === 'left' && 'aggregationColumnHeader--alignLeft', colDef.headerAlign === 'center' && 'aggregationColumnHeader--alignCenter', colDef.headerAlign === 'right' && 'aggregationColumnHeader--alignRight'],
+    aggregationLabel: ['aggregationColumnHeaderLabel']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var GridAggregationHeader = function GridAggregationHeader(props) {
+  var _colDef$headerName;
+
+  var colDef = props.colDef,
+      aggregation = props.aggregation;
+  var apiRef = useGridApiContext();
+  var rootProps = useGridRootProps();
+  var headerHeight = useGridSelector(apiRef, gridDensityHeaderHeightSelector);
+  var ownerState = {
+    classes: rootProps.classes,
+    headerHeight: headerHeight,
+    colDef: colDef
+  };
+  var classes = useUtilityClasses(ownerState);
+
+  if (!aggregation) {
+    return null;
+  }
+
+  var aggregationLabel = getAggregationFunctionLabel({
+    apiRef: apiRef,
+    aggregationRule: aggregation.aggregationRule
+  });
+  return /*#__PURE__*/_jsxs(GridAggregationHeaderRoot, {
+    ownerState: ownerState,
+    className: classes.root,
+    children: [/*#__PURE__*/_jsx(GridColumnHeaderTitle, {
+      label: (_colDef$headerName = colDef.headerName) != null ? _colDef$headerName : colDef.field,
+      description: colDef.description,
+      columnWidth: colDef.computedWidth
+    }), /*#__PURE__*/_jsx(GridAggregationFunctionLabel, {
+      ownerState: ownerState,
+      className: classes.aggregationLabel,
+      children: aggregationLabel
+    })]
+  });
+};
+
+export { GridAggregationHeader };

package/legacy/components/GridExcelExportMenuItem.js

@@ -1,3 +1,6 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["hideMenu", "options"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import MenuItem from '@mui/material/MenuItem';
@@ -6,15 +9,19 @@ import { jsx as _jsx } from "react/jsx-runtime";
 
 var GridExcelExportMenuItem = function GridExcelExportMenuItem(props) {
   var apiRef = useGridApiContext();
+
   var hideMenu = props.hideMenu,
-      options = props.options;
-  return /*#__PURE__*/_jsx(MenuItem, {
+      options = props.options,
+      other = _objectWithoutProperties(props, _excluded);
+
+  return /*#__PURE__*/_jsx(MenuItem, _extends({
     onClick: function onClick() {
       apiRef.current.exportDataAsExcel(options);
       hideMenu == null ? void 0 : hideMenu();
-    },
+    }
+  }, other, {
     children: apiRef.current.getLocaleText('toolbarExportExcel')
-  });
+  }));
 };
 
 process.env.NODE_ENV !== "production" ? GridExcelExportMenuItem.propTypes = {

package/legacy/components/GridFooterCell.js

@@ -0,0 +1,63 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["formattedValue", "colDef", "cellMode", "row", "api", "getValue", "id", "value", "rowNode", "field", "focusElementRef", "hasFocus", "tabIndex", "isEditable"];
+import * as React from 'react';
+import { getDataGridUtilityClass } from '@mui/x-data-grid';
+import { styled } from '@mui/material/styles';
+import Box from '@mui/material/Box';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { jsx as _jsx } from "react/jsx-runtime";
+var GridFooterCellRoot = styled(Box, {
+  name: 'MuiDataGrid',
+  slot: 'FooterCell',
+  overridesResolver: function overridesResolver(_, styles) {
+    return styles.footerCell;
+  }
+})(function (_ref) {
+  var theme = _ref.theme;
+  return {
+    fontWeight: theme.typography.fontWeightMedium,
+    color: theme.palette.primary.dark
+  };
+});
+
+var useUtilityClasses = function useUtilityClasses(ownerState) {
+  var classes = ownerState.classes;
+  var slots = {
+    root: ['footerCell']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+var GridFooterCell = function GridFooterCell(props) {
+  var formattedValue = props.formattedValue,
+      colDef = props.colDef,
+      cellMode = props.cellMode,
+      row = props.row,
+      api = props.api,
+      getValue = props.getValue,
+      id = props.id,
+      value = props.value,
+      rowNode = props.rowNode,
+      field = props.field,
+      focusElementRef = props.focusElementRef,
+      hasFocus = props.hasFocus,
+      tabIndex = props.tabIndex,
+      isEditable = props.isEditable,
+      other = _objectWithoutProperties(props, _excluded);
+
+  var rootProps = useGridRootProps();
+  var ownerState = {
+    classes: rootProps.classes
+  };
+  var classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/_jsx(GridFooterCellRoot, _extends({
+    ownerState: ownerState,
+    className: classes.root
+  }, other, {
+    children: formattedValue
+  }));
+};
+
+export { GridFooterCell };

package/legacy/components/GridGroupingColumnFooterCell.js

@@ -0,0 +1,27 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { GridFooterCell } from './GridFooterCell';
+import { jsx as _jsx } from "react/jsx-runtime";
+
+var GridGroupingColumnFooterCell = function GridGroupingColumnFooterCell(props) {
+  var rowNode = props.rowNode;
+  var rootProps = useGridRootProps();
+  var marginLeft;
+
+  if (rowNode.parent == null) {
+    marginLeft = 0;
+  } else if (rootProps.rowGroupingColumnMode === 'multiple') {
+    marginLeft = 2;
+  } else {
+    marginLeft = rowNode.depth * 2;
+  }
+
+  return /*#__PURE__*/_jsx(GridFooterCell, _extends({
+    sx: {
+      ml: marginLeft
+    }
+  }, props));
+};
+
+export { GridGroupingColumnFooterCell };

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

@@ -0,0 +1,127 @@
+import { gridColumnLookupSelector, gridFilteredRowsLookupSelector, gridRowIdsSelector, gridRowTreeSelector } from '@mui/x-data-grid-pro';
+import { getAggregationRules } from './gridAggregationUtils';
+import { gridAggregationModelSelector } from './gridAggregationSelectors';
+
+var getAggregationCellValue = function getAggregationCellValue(_ref) {
+  var apiRef = _ref.apiRef,
+      groupId = _ref.groupId,
+      field = _ref.field,
+      aggregationFunction = _ref.aggregationFunction,
+      aggregationRowsScope = _ref.aggregationRowsScope;
+  var rowTree = gridRowTreeSelector(apiRef);
+  var filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
+  var rowIds; // TODO: Add custom root id
+
+  if (groupId === '') {
+    rowIds = gridRowIdsSelector(apiRef).filter(function (rowId) {
+      return !rowTree[rowId].isAutoGenerated;
+    });
+  } else {
+    rowIds = apiRef.current.getRowGroupChildren({
+      groupId: groupId
+    });
+  }
+
+  var values = [];
+  rowIds.forEach(function (rowId) {
+    if (aggregationRowsScope === 'filtered' && filteredRowsLookup[rowId] === false) {
+      return;
+    }
+
+    values.push(apiRef.current.getCellValue(rowId, field));
+  });
+  return aggregationFunction.apply({
+    values: values
+  });
+};
+
+var getGroupAggregatedValue = function getGroupAggregatedValue(_ref2) {
+  var groupId = _ref2.groupId,
+      apiRef = _ref2.apiRef,
+      aggregationRowsScope = _ref2.aggregationRowsScope,
+      aggregatedFields = _ref2.aggregatedFields,
+      aggregationRules = _ref2.aggregationRules,
+      position = _ref2.position;
+  var groupAggregationLookup = {};
+
+  for (var j = 0; j < aggregatedFields.length; j += 1) {
+    var aggregatedField = aggregatedFields[j];
+    var columnAggregationRules = aggregationRules[aggregatedField];
+    groupAggregationLookup[aggregatedField] = {
+      position: position,
+      value: getAggregationCellValue({
+        apiRef: apiRef,
+        groupId: groupId,
+        field: aggregatedField,
+        aggregationFunction: columnAggregationRules.aggregationFunction,
+        aggregationRowsScope: aggregationRowsScope
+      })
+    };
+  }
+
+  return groupAggregationLookup;
+};
+
+export var createAggregationLookup = function createAggregationLookup(_ref3) {
+  var apiRef = _ref3.apiRef,
+      aggregationFunctions = _ref3.aggregationFunctions,
+      aggregationRowsScope = _ref3.aggregationRowsScope,
+      getAggregationPosition = _ref3.getAggregationPosition;
+  var aggregationRules = getAggregationRules({
+    columnsLookup: gridColumnLookupSelector(apiRef),
+    aggregationModel: gridAggregationModelSelector(apiRef),
+    aggregationFunctions: aggregationFunctions
+  });
+  var aggregatedFields = Object.keys(aggregationRules);
+
+  if (aggregatedFields.length === 0) {
+    return {};
+  }
+
+  var aggregationLookup = {};
+  var rowIds = gridRowIdsSelector(apiRef);
+  var rowTree = gridRowTreeSelector(apiRef);
+
+  for (var i = 0; i < rowIds.length; i += 1) {
+    var _node$children;
+
+    var rowId = rowIds[i];
+    var node = rowTree[rowId];
+    var hasChildren = (_node$children = node.children) == null ? void 0 : _node$children.some(function (childId) {
+      var _rowTree$childId$posi;
+
+      return ((_rowTree$childId$posi = rowTree[childId].position) != null ? _rowTree$childId$posi : 'body') === 'body';
+    });
+
+    if (hasChildren) {
+      var _position = getAggregationPosition(node);
+
+      if (_position != null) {
+        aggregationLookup[rowId] = getGroupAggregatedValue({
+          groupId: rowId,
+          apiRef: apiRef,
+          aggregatedFields: aggregatedFields,
+          aggregationRowsScope: aggregationRowsScope,
+          aggregationRules: aggregationRules,
+          position: _position
+        });
+      }
+    }
+  } // TODO: Add custom root id
+
+
+  var position = getAggregationPosition(null);
+
+  if (position != null) {
+    aggregationLookup[''] = getGroupAggregatedValue({
+      groupId: '',
+      apiRef: apiRef,
+      aggregatedFields: aggregatedFields,
+      aggregationRowsScope: aggregationRowsScope,
+      aggregationRules: aggregationRules,
+      position: position
+    });
+  }
+
+  return aggregationLookup;
+};

package/legacy/hooks/features/aggregation/gridAggregationFunctions.js

@@ -0,0 +1,94 @@
+import { isNumber } from '@mui/x-data-grid-pro/internals';
+var sumAgg = {
+  apply: function apply(_ref) {
+    var values = _ref.values;
+    var sum = 0;
+
+    for (var i = 0; i < values.length; i += 1) {
+      var value = values[i];
+
+      if (value != null) {
+        sum += value;
+      }
+    }
+
+    return sum;
+  },
+  columnTypes: ['number']
+};
+var avgAgg = {
+  apply: function apply(params) {
+    if (params.values.length === 0) {
+      return null;
+    }
+
+    var sum = sumAgg.apply(params);
+    return sum / params.values.length;
+  },
+  columnTypes: ['number']
+};
+var minAgg = {
+  apply: function apply(_ref2) {
+    var values = _ref2.values;
+
+    if (values.length === 0) {
+      return null;
+    }
+
+    var min = +Infinity;
+
+    for (var i = 0; i < values.length; i += 1) {
+      var value = values[i];
+
+      if (value != null && value < min) {
+        min = value;
+      }
+    }
+
+    return min;
+  },
+  columnTypes: ['number', 'date', 'dateTime']
+};
+var maxAgg = {
+  apply: function apply(_ref3) {
+    var values = _ref3.values;
+
+    if (values.length === 0) {
+      return null;
+    }
+
+    var max = -Infinity;
+
+    for (var i = 0; i < values.length; i += 1) {
+      var value = values[i];
+
+      if (value != null && value > max) {
+        max = value;
+      }
+    }
+
+    return max;
+  },
+  columnTypes: ['number', 'date', 'dateTime']
+};
+var sizeAgg = {
+  apply: function apply(_ref4) {
+    var values = _ref4.values;
+    return values.length;
+  },
+  valueFormatter: function valueFormatter(params) {
+    if (params.value == null || !isNumber(params.value)) {
+      return params.value;
+    }
+
+    return params.value.toLocaleString();
+  },
+  hasCellUnit: false
+};
+export var PRIVATE_GRID_AGGREGATION_FUNCTIONS = {
+  sum: sumAgg,
+  avg: avgAgg,
+  min: minAgg,
+  max: maxAgg,
+  size: sizeAgg
+};

package/legacy/hooks/features/aggregation/gridAggregationInterfaces.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import { createSelector } from '@mui/x-data-grid-pro/internals';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export var private_gridAggregationStateSelector = function private_gridAggregationStateSelector(state) {
+  return state.private_aggregation;
+};
+export var gridAggregationModelSelector = createSelector(private_gridAggregationStateSelector, function (aggregationState) {
+  return aggregationState.model;
+});
+export var gridAggregationLookupSelector = createSelector(private_gridAggregationStateSelector, function (aggregationState) {
+  return aggregationState.lookup;
+});