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

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

@@ -0,0 +1,189 @@
+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 { isDeepEqual } from '@mui/x-data-grid-pro/internals';
+export var PRIVATE_GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = 'auto-generated-group-footer-root'; // eslint-disable-next-line @typescript-eslint/naming-convention
+
+export var private_getAggregationFooterRowIdFromGroupId = function private_getAggregationFooterRowIdFromGroupId(groupId) {
+  if (groupId == null) {
+    return PRIVATE_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.private_aggregable) {
+    return false;
+  }
+
+  if (!aggregationFunction) {
+    return false;
+  }
+
+  if (column.private_availableAggregationFunctions != null) {
+    return column.private_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, {
+      private_aggregation: _extends({}, state.private_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;
+
+  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 = private_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
+      });
+    }
+  };
+
+  addGroupFooter(null); // 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);
+    });
+  }
+
+  return _extends({}, groupingParams, {
+    ids: ids,
+    idRowsLookup: idRowsLookup,
+    tree: tree
+  });
+};
+/**
+ * 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 { PRIVATE_GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, private_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$private_aggreg, _props$initialState, _props$initialState$p;
+
+  apiRef.current.unstable_caches.aggregation = {
+    rulesOnLastColumnHydration: {},
+    rulesOnLastRowHydration: {}
+  };
+  return _extends({}, state, {
+    private_aggregation: {
+      model: (_ref = (_props$private_aggreg = props.private_aggregationModel) != null ? _props$private_aggreg : (_props$initialState = props.initialState) == null ? void 0 : (_props$initialState$p = _props$initialState.private_aggregation) == null ? void 0 : _props$initialState$p.model) != null ? _ref : {}
+    }
+  });
+};
+export var useGridAggregation = function useGridAggregation(apiRef, props) {
+  apiRef.current.unstable_registerControlState({
+    stateId: 'aggregation',
+    propModel: props.private_aggregationModel,
+    propOnChange: props.private_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.private_getAggregationPosition,
+      aggregationFunctions: props.private_aggregationFunctions,
+      aggregationRowsScope: props.private_aggregationRowsScope
+    });
+    apiRef.current.setState(function (state) {
+      return _extends({}, state, {
+        private_aggregation: _extends({}, state.private_aggregation, {
+          lookup: aggregationLookup
+        })
+      });
+    });
+  }, [apiRef, props.private_getAggregationPosition, props.private_aggregationFunctions, props.private_aggregationRowsScope]);
+  var aggregationApi = {
+    private_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.private_disableAggregation ? {} : getAggregationRules({
+      columnsLookup: gridColumnLookupSelector(apiRef),
+      aggregationModel: gridAggregationModelSelector(apiRef),
+      aggregationFunctions: props.private_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.private_aggregationFunctions, props.private_disableAggregation]);
+  useGridApiEventHandler(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
+  useGridApiEventHandler(apiRef, 'columnsChange', checkAggregationRulesDiff);
+  useGridApiEventHandler(apiRef, 'filteredRowsSet', applyAggregation);
+  /**
+   * EFFECTS
+   */
+
+  React.useEffect(function () {
+    if (props.private_aggregationModel !== undefined) {
+      apiRef.current.private_setAggregationModel(props.private_aggregationModel);
+    }
+  }, [apiRef, props.private_aggregationModel]);
+};

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

@@ -0,0 +1,140 @@
+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.private_disableAggregation ? {} : getAggregationRules({
+      columnsLookup: columnsState.lookup,
+      aggregationModel: gridAggregationModelSelector(apiRef),
+      aggregationFunctions: props.private_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.private_aggregationFunctions, props.private_disableAggregation]);
+  var addGroupFooterRows = React.useCallback(function (groupingParams) {
+    var newGroupingParams;
+    var rulesOnLastRowHydration;
+
+    if (props.private_disableAggregation) {
+      newGroupingParams = groupingParams;
+      rulesOnLastRowHydration = {};
+    } else {
+      var 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: groupingParams,
+          aggregationRules: aggregationRules,
+          getAggregationPosition: props.private_getAggregationPosition
+        });
+      }
+    }
+
+    apiRef.current.unstable_caches.aggregation.rulesOnLastRowHydration = rulesOnLastRowHydration;
+    return newGroupingParams;
+  }, [apiRef, props.private_disableAggregation, props.private_getAggregationPosition, props.private_aggregationFunctions]);
+  var addColumnMenuButtons = React.useCallback(function (initialValue, column) {
+    if (props.private_disableAggregation) {
+      return initialValue;
+    }
+
+    var availableAggregationFunctions = getAvailableAggregationFunctions({
+      aggregationFunctions: props.private_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.private_aggregationFunctions, props.private_disableAggregation]);
+  var stateExportPreProcessing = React.useCallback(function (prevState) {
+    if (props.private_disableAggregation) {
+      return prevState;
+    }
+
+    var aggregationModelToExport = gridAggregationModelSelector(apiRef);
+
+    if (Object.values(aggregationModelToExport).length === 0) {
+      return prevState;
+    }
+
+    return _extends({}, prevState, {
+      private_aggregation: {
+        model: aggregationModelToExport
+      }
+    });
+  }, [apiRef, props.private_disableAggregation]);
+  var stateRestorePreProcessing = React.useCallback(function (params, context) {
+    var _context$stateToResto;
+
+    if (props.private_disableAggregation) {
+      return params;
+    }
+
+    var 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/legacy/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -0,0 +1,262 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+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";
+var AGGREGATION_WRAPPABLE_PROPERTIES = ['valueGetter', 'valueFormatter', 'renderCell', 'renderHeader', 'filterOperators'];
+
+var getAggregationValueWrappedValueGetter = function getAggregationValueWrappedValueGetter(_ref) {
+  var valueGetter = _ref.value,
+      getCellAggregationResult = _ref.getCellAggregationResult;
+
+  var wrappedValueGetter = function wrappedValueGetter(params) {
+    var 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;
+};
+
+var getAggregationValueWrappedValueFormatter = function getAggregationValueWrappedValueFormatter(_ref2) {
+  var valueFormatter = _ref2.value,
+      aggregationRule = _ref2.aggregationRule,
+      getCellAggregationResult = _ref2.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;
+  }
+
+  var wrappedValueFormatter = function wrappedValueFormatter(params) {
+    if (params.id != null) {
+      var cellAggregationResult = getCellAggregationResult(params.id, params.field);
+
+      if (cellAggregationResult != null) {
+        return aggregationRule.aggregationFunction.valueFormatter(params);
+      }
+    }
+
+    if (valueFormatter) {
+      return valueFormatter(params);
+    }
+
+    return params.value;
+  };
+
+  return wrappedValueFormatter;
+};
+
+var getAggregationValueWrappedRenderCell = function getAggregationValueWrappedRenderCell(_ref3) {
+  var renderCell = _ref3.value,
+      aggregationRule = _ref3.aggregationRule,
+      getCellAggregationResult = _ref3.getCellAggregationResult;
+
+  var wrappedRenderCell = function wrappedRenderCell(params) {
+    var 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;
+      }
+
+      var 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
+ */
+
+
+var getWrappedFilterOperators = function getWrappedFilterOperators(_ref4) {
+  var filterOperators = _ref4.value,
+      getCellAggregationResult = _ref4.getCellAggregationResult;
+  return filterOperators.map(function (operator) {
+    return _extends({}, operator, {
+      getApplyFilterFn: function getApplyFilterFn(filterItem, column) {
+        var originalFn = operator.getApplyFilterFn(filterItem, column);
+
+        if (!originalFn) {
+          return null;
+        }
+
+        return function (params) {
+          if (getCellAggregationResult(params.id, params.field) != null) {
+            return true;
+          }
+
+          return originalFn(params);
+        };
+      }
+    });
+  });
+};
+/**
+ * Add the aggregation method around the header name
+ */
+
+
+var getWrappedRenderHeader = function getWrappedRenderHeader(_ref5) {
+  var renderHeader = _ref5.value,
+      aggregationRule = _ref5.aggregationRule;
+
+  var wrappedRenderCell = function wrappedRenderCell(params) {
+    var aggregationMeta = {
+      aggregationRule: 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 var wrapColumnWithAggregationValue = function wrapColumnWithAggregationValue(_ref6) {
+  var column = _ref6.column,
+      apiRef = _ref6.apiRef,
+      aggregationRule = _ref6.aggregationRule;
+
+  var getCellAggregationResult = function getCellAggregationResult(id, field) {
+    var _parent, _gridAggregationLooku;
+
+    var 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
+
+
+    var groupId = cellAggregationPosition === 'inline' ? id : (_parent = apiRef.current.getRowNode(id).parent) != null ? _parent : '';
+    var aggregationResult = (_gridAggregationLooku = gridAggregationLookupSelector(apiRef)[groupId]) == null ? void 0 : _gridAggregationLooku[field];
+
+    if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
+      return null;
+    }
+
+    return aggregationResult;
+  };
+
+  var aggregationWrappedProperties = {};
+
+  var wrappedColumn = _extends({}, column, {
+    aggregationWrappedProperties: aggregationWrappedProperties
+  });
+
+  var wrapColumnProperty = function wrapColumnProperty(property, wrapper) {
+    var originalValue = column[property];
+    var wrappedProperty = wrapper({
+      apiRef: apiRef,
+      value: originalValue,
+      colDef: column,
+      aggregationRule: aggregationRule,
+      getCellAggregationResult: 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 var unwrapColumnFromAggregation = function unwrapColumnFromAggregation(_ref7) {
+  var column = _ref7.column;
+
+  if (!column.aggregationWrappedProperties) {
+    return column;
+  }
+
+  var originalProperties = Object.entries(column.aggregationWrappedProperties);
+
+  if (originalProperties.length === 0) {
+    return column;
+  }
+
+  var unwrappedColumn = _extends({}, column);
+
+  originalProperties.forEach(function (_ref8) {
+    var _ref9 = _slicedToArray(_ref8, 2),
+        propertyName = _ref9[0],
+        _ref9$ = _ref9[1],
+        original = _ref9$.original,
+        wrapped = _ref9$.wrapped;
+
+    // The value changed since we wrapped it
+    if (wrapped !== column[propertyName]) {
+      return;
+    }
+
+    unwrappedColumn[propertyName] = original;
+  });
+  return unwrappedColumn;
+};