@mui/x-data-grid-premium 5.13.0 → 5.15.0

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 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,10 @@
+import { createSelector } from '@mui/x-data-grid-pro/internals';
+export var gridAggregationStateSelector = function gridAggregationStateSelector(state) {
+  return state.aggregation;
+};
+export var gridAggregationModelSelector = createSelector(gridAggregationStateSelector, function (aggregationState) {
+  return aggregationState.model;
+});
+export var gridAggregationLookupSelector = createSelector(gridAggregationStateSelector, function (aggregationState) {
+  return aggregationState.lookup;
+});

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

@@ -0,0 +1,200 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { capitalize } from '@mui/material';
+import { addPinnedRow, isDeepEqual } from '@mui/x-data-grid-pro/internals';
+export var GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = 'auto-generated-group-footer-root';
+export var getAggregationFooterRowIdFromGroupId = function getAggregationFooterRowIdFromGroupId(groupId) {
+  if (groupId == null) {
+    return GRID_AGGREGATION_ROOT_FOOTER_ROW_ID;
+  }
+
+  return "auto-generated-group-footer-".concat(groupId);
+};
+export var canColumnHaveAggregationFunction = function canColumnHaveAggregationFunction(_ref) {
+  var column = _ref.column,
+      aggregationFunctionName = _ref.aggregationFunctionName,
+      aggregationFunction = _ref.aggregationFunction;
+
+  if (!column || !column.aggregable) {
+    return false;
+  }
+
+  if (!aggregationFunction) {
+    return false;
+  }
+
+  if (column.availableAggregationFunctions != null) {
+    return column.availableAggregationFunctions.includes(aggregationFunctionName);
+  }
+
+  if (!aggregationFunction.columnTypes) {
+    return true;
+  }
+
+  return aggregationFunction.columnTypes.includes(column.type);
+};
+export var getAvailableAggregationFunctions = function getAvailableAggregationFunctions(_ref2) {
+  var aggregationFunctions = _ref2.aggregationFunctions,
+      column = _ref2.column;
+  return Object.keys(aggregationFunctions).filter(function (aggregationFunctionName) {
+    return canColumnHaveAggregationFunction({
+      column: column,
+      aggregationFunctionName: aggregationFunctionName,
+      aggregationFunction: aggregationFunctions[aggregationFunctionName]
+    });
+  });
+};
+export var mergeStateWithAggregationModel = function mergeStateWithAggregationModel(aggregationModel) {
+  return function (state) {
+    return _extends({}, state, {
+      aggregation: _extends({}, state.aggregation, {
+        model: aggregationModel
+      })
+    });
+  };
+};
+export var getAggregationRules = function getAggregationRules(_ref3) {
+  var columnsLookup = _ref3.columnsLookup,
+      aggregationModel = _ref3.aggregationModel,
+      aggregationFunctions = _ref3.aggregationFunctions;
+  var aggregationRules = {};
+  Object.entries(aggregationModel).forEach(function (_ref4) {
+    var _ref5 = _slicedToArray(_ref4, 2),
+        field = _ref5[0],
+        columnItem = _ref5[1];
+
+    if (columnsLookup[field] && canColumnHaveAggregationFunction({
+      column: columnsLookup[field],
+      aggregationFunctionName: columnItem,
+      aggregationFunction: aggregationFunctions[columnItem]
+    })) {
+      aggregationRules[field] = {
+        aggregationFunctionName: columnItem,
+        aggregationFunction: aggregationFunctions[columnItem]
+      };
+    }
+  });
+  return aggregationRules;
+};
+/**
+ * Add a footer for each group that has at least one column with an aggregated value.
+ */
+
+export var addFooterRows = function addFooterRows(_ref6) {
+  var groupingParams = _ref6.groupingParams,
+      aggregationRules = _ref6.aggregationRules,
+      getAggregationPosition = _ref6.getAggregationPosition,
+      apiRef = _ref6.apiRef;
+
+  if (Object.keys(aggregationRules).length === 0) {
+    return groupingParams;
+  }
+
+  var ids = _toConsumableArray(groupingParams.ids);
+
+  var idRowsLookup = _extends({}, groupingParams.idRowsLookup);
+
+  var tree = _extends({}, groupingParams.tree);
+
+  var addGroupFooter = function addGroupFooter(groupNode) {
+    var _groupNode$id;
+
+    var groupId = (_groupNode$id = groupNode == null ? void 0 : groupNode.id) != null ? _groupNode$id : null;
+
+    if (getAggregationPosition(groupNode) !== 'footer') {
+      return;
+    }
+
+    var footerId = getAggregationFooterRowIdFromGroupId(groupId);
+    ids.push(footerId);
+    idRowsLookup[footerId] = {};
+    tree[footerId] = {
+      id: footerId,
+      isAutoGenerated: true,
+      parent: groupId,
+      depth: groupNode ? groupNode.depth + 1 : 0,
+      groupingKey: null,
+      groupingField: null,
+      position: 'footer'
+    };
+
+    if (groupId != null) {
+      tree[groupId] = _extends({}, tree[groupId], {
+        footerId: footerId
+      });
+    }
+  }; // If the tree is flat, we don't need to loop through the rows
+
+
+  if (groupingParams.treeDepth > 1) {
+    groupingParams.ids.forEach(function (parentId) {
+      var parentNode = tree[parentId];
+
+      if (parentNode.depth === groupingParams.treeDepth - 1) {
+        return;
+      }
+
+      addGroupFooter(parentNode);
+    });
+  }
+
+  var newGroupingParams = _extends({}, groupingParams, {
+    tree: tree,
+    idRowsLookup: idRowsLookup,
+    ids: ids
+  });
+
+  if (getAggregationPosition(null) === 'footer') {
+    newGroupingParams = addPinnedRow({
+      groupingParams: newGroupingParams,
+      rowModel: {},
+      rowId: getAggregationFooterRowIdFromGroupId(null),
+      position: 'bottom',
+      apiRef: apiRef
+    });
+  }
+
+  return _extends({}, groupingParams, newGroupingParams);
+};
+/**
+ * Compares two sets of aggregation rules to determine if they are equal or not.
+ */
+
+export var hasAggregationRulesChanged = function hasAggregationRulesChanged(previousValue, newValue) {
+  var previousFields = Object.keys(previousValue != null ? previousValue : {});
+  var newFields = Object.keys(newValue);
+
+  if (!isDeepEqual(previousFields, newFields)) {
+    return true;
+  }
+
+  return newFields.some(function (field) {
+    var previousRule = previousValue == null ? void 0 : previousValue[field];
+    var newRule = newValue[field];
+
+    if ((previousRule == null ? void 0 : previousRule.aggregationFunction) !== (newRule == null ? void 0 : newRule.aggregationFunction)) {
+      return true;
+    }
+
+    if ((previousRule == null ? void 0 : previousRule.aggregationFunctionName) !== (newRule == null ? void 0 : newRule.aggregationFunctionName)) {
+      return true;
+    }
+
+    return false;
+  });
+};
+export var getAggregationFunctionLabel = function getAggregationFunctionLabel(_ref7) {
+  var apiRef = _ref7.apiRef,
+      aggregationRule = _ref7.aggregationRule;
+
+  if (aggregationRule.aggregationFunction.label != null) {
+    return aggregationRule.aggregationFunction.label;
+  }
+
+  try {
+    return apiRef.current.getLocaleText("aggregationFunctionLabel".concat(capitalize(aggregationRule.aggregationFunctionName)));
+  } catch (e) {
+    return aggregationRule.aggregationFunctionName;
+  }
+};

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

@@ -0,0 +1,4 @@
+export * from './gridAggregationInterfaces';
+export * from './gridAggregationSelectors';
+export * from './gridAggregationFunctions';
+export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId } from './gridAggregationUtils';

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

@@ -0,0 +1,95 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { gridColumnLookupSelector, useGridApiEventHandler, useGridApiMethod } from '@mui/x-data-grid-pro';
+import { gridAggregationModelSelector } from './gridAggregationSelectors';
+import { getAggregationRules, mergeStateWithAggregationModel, hasAggregationRulesChanged } from './gridAggregationUtils';
+import { createAggregationLookup } from './createAggregationLookup';
+export var aggregationStateInitializer = function aggregationStateInitializer(state, props, apiRef) {
+  var _ref, _props$aggregationMod, _props$initialState, _props$initialState$a;
+
+  apiRef.current.unstable_caches.aggregation = {
+    rulesOnLastColumnHydration: {},
+    rulesOnLastRowHydration: {}
+  };
+  return _extends({}, state, {
+    aggregation: {
+      model: (_ref = (_props$aggregationMod = props.aggregationModel) != null ? _props$aggregationMod : (_props$initialState = props.initialState) == null ? void 0 : (_props$initialState$a = _props$initialState.aggregation) == null ? void 0 : _props$initialState$a.model) != null ? _ref : {}
+    }
+  });
+};
+export var useGridAggregation = function useGridAggregation(apiRef, props) {
+  apiRef.current.unstable_registerControlState({
+    stateId: 'aggregation',
+    propModel: props.aggregationModel,
+    propOnChange: props.onAggregationModelChange,
+    stateSelector: gridAggregationModelSelector,
+    changeEvent: 'aggregationModelChange'
+  });
+  /**
+   * API METHODS
+   */
+
+  var setAggregationModel = React.useCallback(function (model) {
+    var currentModel = gridAggregationModelSelector(apiRef);
+
+    if (currentModel !== model) {
+      apiRef.current.setState(mergeStateWithAggregationModel(model));
+      apiRef.current.forceUpdate();
+    }
+  }, [apiRef]);
+  var applyAggregation = React.useCallback(function () {
+    var aggregationLookup = createAggregationLookup({
+      apiRef: apiRef,
+      getAggregationPosition: props.getAggregationPosition,
+      aggregationFunctions: props.aggregationFunctions,
+      aggregationRowsScope: props.aggregationRowsScope
+    });
+    apiRef.current.setState(function (state) {
+      return _extends({}, state, {
+        aggregation: _extends({}, state.aggregation, {
+          lookup: aggregationLookup
+        })
+      });
+    });
+  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope]);
+  var aggregationApi = {
+    setAggregationModel: setAggregationModel
+  };
+  useGridApiMethod(apiRef, aggregationApi, 'GridAggregationApi');
+  /**
+   * EVENTS
+   */
+
+  var checkAggregationRulesDiff = React.useCallback(function () {
+    var _apiRef$current$unsta = apiRef.current.unstable_caches.aggregation,
+        rulesOnLastRowHydration = _apiRef$current$unsta.rulesOnLastRowHydration,
+        rulesOnLastColumnHydration = _apiRef$current$unsta.rulesOnLastColumnHydration;
+    var aggregationRules = props.disableAggregation ? {} : getAggregationRules({
+      columnsLookup: gridColumnLookupSelector(apiRef),
+      aggregationModel: gridAggregationModelSelector(apiRef),
+      aggregationFunctions: props.aggregationFunctions
+    }); // Re-apply the row hydration to add / remove the aggregation footers
+
+    if (hasAggregationRulesChanged(rulesOnLastRowHydration, aggregationRules)) {
+      apiRef.current.unstable_requestPipeProcessorsApplication('hydrateRows');
+      applyAggregation();
+    } // Re-apply the column hydration to wrap / unwrap the aggregated columns
+
+
+    if (hasAggregationRulesChanged(rulesOnLastColumnHydration, aggregationRules)) {
+      apiRef.current.unstable_requestPipeProcessorsApplication('hydrateColumns');
+    }
+  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation]);
+  useGridApiEventHandler(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
+  useGridApiEventHandler(apiRef, 'columnsChange', checkAggregationRulesDiff);
+  useGridApiEventHandler(apiRef, 'filteredRowsSet', applyAggregation);
+  /**
+   * EFFECTS
+   */
+
+  React.useEffect(function () {
+    if (props.aggregationModel !== undefined) {
+      apiRef.current.setAggregationModel(props.aggregationModel);
+    }
+  }, [apiRef, props.aggregationModel]);
+};

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

@@ -0,0 +1,141 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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";
+
+var Divider = function Divider() {
+  return /*#__PURE__*/_jsx(MuiDivider, {
+    onClick: function onClick(event) {
+      return event.stopPropagation();
+    }
+  });
+};
+
+export var useGridAggregationPreProcessors = function useGridAggregationPreProcessors(apiRef, props) {
+  var updateAggregatedColumns = React.useCallback(function (columnsState) {
+    var rulesOnLastColumnHydration = apiRef.current.unstable_caches.aggregation.rulesOnLastColumnHydration;
+    var aggregationRules = props.disableAggregation ? {} : getAggregationRules({
+      columnsLookup: columnsState.lookup,
+      aggregationModel: gridAggregationModelSelector(apiRef),
+      aggregationFunctions: props.aggregationFunctions
+    });
+    columnsState.all.forEach(function (field) {
+      var shouldHaveAggregationValue = !!aggregationRules[field];
+      var haveAggregationColumnValue = !!rulesOnLastColumnHydration[field];
+      var column = columnsState.lookup[field];
+
+      if (haveAggregationColumnValue) {
+        column = unwrapColumnFromAggregation({
+          column: column
+        });
+      }
+
+      if (shouldHaveAggregationValue) {
+        column = wrapColumnWithAggregationValue({
+          column: column,
+          aggregationRule: aggregationRules[field],
+          apiRef: apiRef
+        });
+      }
+
+      columnsState.lookup[field] = column;
+    });
+    apiRef.current.unstable_caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
+    return columnsState;
+  }, [apiRef, props.aggregationFunctions, props.disableAggregation]);
+  var addGroupFooterRows = React.useCallback(function (groupingParams) {
+    var newGroupingParams;
+    var rulesOnLastRowHydration;
+
+    if (props.disableAggregation) {
+      newGroupingParams = groupingParams;
+      rulesOnLastRowHydration = {};
+    } else {
+      var aggregationRules = getAggregationRules({
+        columnsLookup: gridColumnLookupSelector(apiRef),
+        aggregationModel: gridAggregationModelSelector(apiRef),
+        aggregationFunctions: props.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: groupingParams,
+          aggregationRules: aggregationRules,
+          getAggregationPosition: props.getAggregationPosition,
+          apiRef: apiRef
+        });
+      }
+    }
+
+    apiRef.current.unstable_caches.aggregation.rulesOnLastRowHydration = rulesOnLastRowHydration;
+    return newGroupingParams;
+  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions]);
+  var addColumnMenuButtons = React.useCallback(function (initialValue, column) {
+    if (props.disableAggregation) {
+      return initialValue;
+    }
+
+    var availableAggregationFunctions = getAvailableAggregationFunctions({
+      aggregationFunctions: props.aggregationFunctions,
+      column: column
+    });
+
+    if (availableAggregationFunctions.length === 0) {
+      return initialValue;
+    }
+
+    return [].concat(_toConsumableArray(initialValue), [/*#__PURE__*/_jsx(Divider, {}), /*#__PURE__*/_jsx(GridAggregationColumnMenuItem, {
+      column: column,
+      label: apiRef.current.getLocaleText('aggregationMenuItemHeader'),
+      availableAggregationFunctions: availableAggregationFunctions
+    })]);
+  }, [apiRef, props.aggregationFunctions, props.disableAggregation]);
+  var stateExportPreProcessing = React.useCallback(function (prevState) {
+    if (props.disableAggregation) {
+      return prevState;
+    }
+
+    var aggregationModelToExport = gridAggregationModelSelector(apiRef);
+
+    if (Object.values(aggregationModelToExport).length === 0) {
+      return prevState;
+    }
+
+    return _extends({}, prevState, {
+      aggregation: {
+        model: aggregationModelToExport
+      }
+    });
+  }, [apiRef, props.disableAggregation]);
+  var stateRestorePreProcessing = React.useCallback(function (params, context) {
+    var _context$stateToResto;
+
+    if (props.disableAggregation) {
+      return params;
+    }
+
+    var aggregationModel = (_context$stateToResto = context.stateToRestore.aggregation) == null ? void 0 : _context$stateToResto.model;
+
+    if (aggregationModel != null) {
+      apiRef.current.setState(mergeStateWithAggregationModel(aggregationModel));
+    }
+
+    return params;
+  }, [apiRef, props.disableAggregation]);
+  useGridRegisterPipeProcessor(apiRef, 'hydrateColumns', updateAggregatedColumns);
+  useGridRegisterPipeProcessor(apiRef, 'hydrateRows', addGroupFooterRows);
+  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButtons);
+  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
+  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
+};