@mui/x-data-grid-pro 5.11.1 → 5.12.2

package/legacy/hooks/features/rowGrouping/createGroupingColDef.js

@@ -1,319 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
-import _extends from "@babel/runtime/helpers/esm/extends";
-var _excluded = ["leafField", "mainGroupingCriteria", "hideDescendantCount"],
-    _excluded2 = ["leafField", "mainGroupingCriteria", "hideDescendantCount"];
-import * as React from 'react';
-import { GRID_STRING_COL_DEF } from '@mui/x-data-grid';
-import { GridGroupingCriteriaCell } from '../../../components/GridGroupingCriteriaCell';
-import { GridGroupingColumnLeafCell } from '../../../components/GridGroupingColumnLeafCell';
-import { getRowGroupingFieldFromGroupingCriteria, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD } from './gridRowGroupingUtils';
-import { gridRowGroupingSanitizedModelSelector } from './gridRowGroupingSelector';
-import { jsx as _jsx } from "react/jsx-runtime";
-
-var GROUPING_COL_DEF_DEFAULT_PROPERTIES = _extends({}, GRID_STRING_COL_DEF, {
-  disableReorder: true
-});
-
-var GROUPING_COL_DEF_FORCED_PROPERTIES = {
-  type: 'rowGroupByColumnsGroup',
-  editable: false,
-  groupable: false
-};
-/**
- * When sorting two cells with different grouping criteria, we consider that the cell with the grouping criteria coming first in the model should be displayed below.
- * This can occur when some rows don't have all the fields. In which case we want the rows with the missing field to be displayed above.
- * TODO: Make this index comparator depth invariant, the logic should not be inverted when sorting in the "desc" direction (but the current return format of `sortComparator` does not support this behavior).
- */
-
-var groupingFieldIndexComparator = function groupingFieldIndexComparator(v1, v2, cellParams1, cellParams2) {
-  var model = gridRowGroupingSanitizedModelSelector(cellParams1.api.state, cellParams1.api.instanceId);
-  var groupingField1 = cellParams1.rowNode.groupingField;
-  var groupingField2 = cellParams2.rowNode.groupingField;
-
-  if (groupingField1 === groupingField2) {
-    return 0;
-  }
-
-  if (groupingField1 == null) {
-    return -1;
-  }
-
-  if (groupingField2 == null) {
-    return 1;
-  }
-
-  if (model.indexOf(groupingField1) < model.indexOf(groupingField2)) {
-    return -1;
-  }
-
-  return 1;
-};
-
-var getLeafProperties = function getLeafProperties(leafColDef) {
-  var _leafColDef$headerNam, _leafColDef$filterOpe;
-
-  return {
-    headerName: (_leafColDef$headerNam = leafColDef.headerName) != null ? _leafColDef$headerNam : leafColDef.field,
-    sortable: leafColDef.sortable,
-    filterable: leafColDef.filterable,
-    filterOperators: (_leafColDef$filterOpe = leafColDef.filterOperators) == null ? void 0 : _leafColDef$filterOpe.map(function (operator) {
-      return _extends({}, operator, {
-        getApplyFilterFn: function getApplyFilterFn(filterItem, column) {
-          var originalFn = operator.getApplyFilterFn(filterItem, column);
-
-          if (!originalFn) {
-            return null;
-          }
-
-          return function (params) {
-            // We only want to filter leaves
-            if (params.rowNode.groupingField != null) {
-              return true;
-            }
-
-            return originalFn(params);
-          };
-        }
-      });
-    }),
-    sortComparator: function sortComparator(v1, v2, cellParams1, cellParams2) {
-      // We only want to sort the leaves
-      if (cellParams1.rowNode.groupingField === null && cellParams2.rowNode.groupingField === null) {
-        return leafColDef.sortComparator(v1, v2, cellParams1, cellParams2);
-      }
-
-      return groupingFieldIndexComparator(v1, v2, cellParams1, cellParams2);
-    }
-  };
-};
-
-var getGroupingCriteriaProperties = function getGroupingCriteriaProperties(groupedByColDef, applyHeaderName) {
-  var _groupedByColDef$filt;
-
-  var properties = {
-    sortable: groupedByColDef.sortable,
-    filterable: groupedByColDef.filterable,
-    sortComparator: function sortComparator(v1, v2, cellParams1, cellParams2) {
-      // We only want to sort the groups of the current grouping criteria
-      if (cellParams1.rowNode.groupingField === groupedByColDef.field && cellParams2.rowNode.groupingField === groupedByColDef.field) {
-        return groupedByColDef.sortComparator(v1, v2, cellParams1, cellParams2);
-      }
-
-      return groupingFieldIndexComparator(v1, v2, cellParams1, cellParams2);
-    },
-    filterOperators: (_groupedByColDef$filt = groupedByColDef.filterOperators) == null ? void 0 : _groupedByColDef$filt.map(function (operator) {
-      return _extends({}, operator, {
-        getApplyFilterFn: function getApplyFilterFn(filterItem, column) {
-          var originalFn = operator.getApplyFilterFn(filterItem, column);
-
-          if (!originalFn) {
-            return null;
-          }
-
-          return function (params) {
-            // We only want to filter the groups of the current grouping criteria
-            if (params.rowNode.groupingField !== groupedByColDef.field) {
-              return true;
-            }
-
-            return originalFn(params);
-          };
-        }
-      });
-    })
-  };
-
-  if (applyHeaderName) {
-    var _groupedByColDef$head;
-
-    properties.headerName = (_groupedByColDef$head = groupedByColDef.headerName) != null ? _groupedByColDef$head : groupedByColDef.field;
-  }
-
-  return properties;
-};
-
-/**
- * Creates the `GridColDef` for a grouping column that only takes care of a single grouping criteria
- */
-export var createGroupingColDefForOneGroupingCriteria = function createGroupingColDefForOneGroupingCriteria(_ref) {
-  var _groupedByColDef$widt, _leafColDef$width;
-
-  var columnsLookup = _ref.columnsLookup,
-      groupedByColDef = _ref.groupedByColDef,
-      groupingCriteria = _ref.groupingCriteria,
-      colDefOverride = _ref.colDefOverride;
-
-  var _ref2 = colDefOverride != null ? colDefOverride : {},
-      leafField = _ref2.leafField,
-      mainGroupingCriteria = _ref2.mainGroupingCriteria,
-      hideDescendantCount = _ref2.hideDescendantCount,
-      colDefOverrideProperties = _objectWithoutProperties(_ref2, _excluded);
-
-  var leafColDef = leafField ? columnsLookup[leafField] : null; // The properties that do not depend on the presence of a `leafColDef` and that can be overridden by `colDefOverride`
-
-  var 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: function renderCell(params) {
-      // Render leaves
-      if (params.rowNode.groupingField == null) {
-        if (leafColDef) {
-          var leafParams = _extends({}, params.api.getCellParams(params.id, leafField), {
-            api: params.api
-          });
-
-          if (leafColDef.renderCell) {
-            return leafColDef.renderCell(leafParams);
-          }
-
-          return /*#__PURE__*/_jsx(GridGroupingColumnLeafCell, _extends({}, leafParams));
-        }
-
-        return '';
-      } // Render current grouping criteria groups
-
-
-      if (params.rowNode.groupingField === groupingCriteria) {
-        return /*#__PURE__*/_jsx(GridGroupingCriteriaCell, _extends({}, params, {
-          hideDescendantCount: hideDescendantCount
-        }));
-      }
-
-      return '';
-    },
-    valueGetter: function valueGetter(params) {
-      if (!params.rowNode) {
-        return undefined;
-      }
-
-      if (params.rowNode.groupingField == null) {
-        if (leafColDef) {
-          return params.api.getCellValue(params.id, leafField);
-        }
-
-        return undefined;
-      }
-
-      if (params.rowNode.groupingField === groupingCriteria) {
-        return params.rowNode.groupingKey;
-      }
-
-      return undefined;
-    }
-  }; // If we have a `mainGroupingCriteria` defined and matching the `groupingCriteria`
-  // Then we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `groupedByColDef`.
-  // It can be useful to define a `leafField` for leaves rendering but still use the grouping criteria for the sorting / filtering
-  //
-  // If we have a `leafField` defined and matching an existing column
-  // Then we apply the sorting / filtering on the leaves based on the properties of `leavesColDef`
-  //
-  // By default, we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `groupedColDef`.
-
-  var sourceProperties;
-
-  if (mainGroupingCriteria && mainGroupingCriteria === groupingCriteria) {
-    sourceProperties = getGroupingCriteriaProperties(groupedByColDef, true);
-  } else if (leafColDef) {
-    sourceProperties = getLeafProperties(leafColDef);
-  } else {
-    sourceProperties = getGroupingCriteriaProperties(groupedByColDef, true);
-  } // The properties that can't be overridden with `colDefOverride`
-
-
-  var forcedProperties = _extends({
-    field: getRowGroupingFieldFromGroupingCriteria(groupingCriteria)
-  }, GROUPING_COL_DEF_FORCED_PROPERTIES);
-
-  return _extends({}, GROUPING_COL_DEF_DEFAULT_PROPERTIES, commonProperties, sourceProperties, colDefOverrideProperties, forcedProperties);
-};
-
-/**
- * Creates the `GridColDef` for a grouping column that takes care of all the grouping criteria
- */
-export var createGroupingColDefForAllGroupingCriteria = function createGroupingColDefForAllGroupingCriteria(_ref3) {
-  var _leafColDef$width2;
-
-  var apiRef = _ref3.apiRef,
-      columnsLookup = _ref3.columnsLookup,
-      rowGroupingModel = _ref3.rowGroupingModel,
-      colDefOverride = _ref3.colDefOverride;
-
-  var _ref4 = colDefOverride != null ? colDefOverride : {},
-      leafField = _ref4.leafField,
-      mainGroupingCriteria = _ref4.mainGroupingCriteria,
-      hideDescendantCount = _ref4.hideDescendantCount,
-      colDefOverrideProperties = _objectWithoutProperties(_ref4, _excluded2);
-
-  var leafColDef = leafField ? columnsLookup[leafField] : null; // The properties that do not depend on the presence of a `leafColDef` and that can be overridden by `colDefOverride`
-
-  var commonProperties = {
-    headerName: apiRef.current.getLocaleText('groupingColumnHeaderName'),
-    width: Math.max.apply(Math, _toConsumableArray(rowGroupingModel.map(function (field) {
-      var _columnsLookup$field$;
-
-      return ((_columnsLookup$field$ = columnsLookup[field].width) != null ? _columnsLookup$field$ : GRID_STRING_COL_DEF.width) + 40;
-    })).concat([(_leafColDef$width2 = leafColDef == null ? void 0 : leafColDef.width) != null ? _leafColDef$width2 : 0])),
-    renderCell: function renderCell(params) {
-      // Render the leaves
-      if (params.rowNode.groupingField == null) {
-        if (leafColDef) {
-          var leafParams = _extends({}, params.api.getCellParams(params.id, leafField), {
-            api: params.api
-          });
-
-          if (leafColDef.renderCell) {
-            return leafColDef.renderCell(leafParams);
-          }
-
-          return /*#__PURE__*/_jsx(GridGroupingColumnLeafCell, _extends({}, leafParams));
-        }
-
-        return '';
-      } // Render the groups
-
-
-      return /*#__PURE__*/_jsx(GridGroupingCriteriaCell, _extends({}, params, {
-        hideDescendantCount: hideDescendantCount
-      }));
-    },
-    valueGetter: function valueGetter(params) {
-      if (!params.rowNode) {
-        return undefined;
-      }
-
-      if (params.rowNode.groupingField == null) {
-        if (leafColDef) {
-          return params.api.getCellValue(params.id, leafField);
-        }
-
-        return undefined;
-      }
-
-      return params.rowNode.groupingKey;
-    }
-  }; // If we have a `mainGroupingCriteria` defined and matching one of the `orderedGroupedByFields`
-  // Then we apply the sorting / filtering on the groups of this column's grouping criteria based on the properties of `columnsLookup[mainGroupingCriteria]`.
-  // It can be useful to use another grouping criteria than the top level one for the sorting / filtering
-  //
-  // If we have a `leafField` defined and matching an existing column
-  // Then we apply the sorting / filtering on the leaves based on the properties of `leavesColDef`
-  //
-  // By default, we apply the sorting / filtering on the groups of the top level grouping criteria based on the properties of `columnsLookup[orderedGroupedByFields[0]]`.
-
-  var sourceProperties;
-
-  if (mainGroupingCriteria && rowGroupingModel.includes(mainGroupingCriteria)) {
-    sourceProperties = getGroupingCriteriaProperties(columnsLookup[mainGroupingCriteria], true);
-  } else if (leafColDef) {
-    sourceProperties = getLeafProperties(leafColDef);
-  } else {
-    sourceProperties = getGroupingCriteriaProperties(columnsLookup[rowGroupingModel[0]], rowGroupingModel.length === 1);
-  } // The properties that can't be overridden with `colDefOverride`
-
-
-  var forcedProperties = _extends({
-    field: GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD
-  }, GROUPING_COL_DEF_FORCED_PROPERTIES);
-
-  return _extends({}, GROUPING_COL_DEF_DEFAULT_PROPERTIES, commonProperties, sourceProperties, colDefOverrideProperties, forcedProperties);
-};

package/legacy/hooks/features/rowGrouping/gridRowGroupingInterfaces.js

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

package/legacy/hooks/features/rowGrouping/gridRowGroupingSelector.js

@@ -1,13 +0,0 @@
-import { gridColumnLookupSelector } from '@mui/x-data-grid';
-import { createSelector } from '@mui/x-data-grid/internals';
-export var gridRowGroupingStateSelector = function gridRowGroupingStateSelector(state) {
-  return state.rowGrouping;
-};
-export var gridRowGroupingModelSelector = createSelector(gridRowGroupingStateSelector, function (rowGrouping) {
-  return rowGrouping.model;
-});
-export var gridRowGroupingSanitizedModelSelector = createSelector(gridRowGroupingModelSelector, gridColumnLookupSelector, function (model, columnsLookup) {
-  return model.filter(function (field) {
-    return !!columnsLookup[field] && columnsLookup[field].groupable;
-  });
-});

package/legacy/hooks/features/rowGrouping/gridRowGroupingUtils.js

@@ -1,147 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { gridRowGroupingSanitizedModelSelector } from './gridRowGroupingSelector';
-export var GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = '__row_group_by_columns_group__';
-export var ROW_GROUPING_STRATEGY = 'grouping-columns';
-export var getRowGroupingFieldFromGroupingCriteria = function getRowGroupingFieldFromGroupingCriteria(groupingCriteria) {
-  if (groupingCriteria === null) {
-    return GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
-  }
-
-  return "__row_group_by_columns_group_".concat(groupingCriteria, "__");
-};
-export var getRowGroupingCriteriaFromGroupingField = function getRowGroupingCriteriaFromGroupingField(groupingColDefField) {
-  var match = groupingColDefField.match(/^__row_group_by_columns_group_(.*)__$/);
-
-  if (!match) {
-    return null;
-  }
-
-  return match[1];
-};
-export var isGroupingColumn = function isGroupingColumn(field) {
-  return field === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD || getRowGroupingCriteriaFromGroupingField(field) !== null;
-};
-
-/**
- * When filtering a group, we only want to filter according to the items related to this grouping column.
- */
-var shouldApplyFilterItemOnGroup = function shouldApplyFilterItemOnGroup(columnField, node) {
-  if (columnField === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
-    return true;
-  }
-
-  var groupingCriteriaField = getRowGroupingCriteriaFromGroupingField(columnField);
-  return groupingCriteriaField === node.groupingField;
-};
-/**
- * A leaf is visible if it passed the filter
- * A group is visible if all the following criteria are met:
- * - One of its children is passing the filter
- * - It is passing the filter
- */
-
-
-export var filterRowTreeFromGroupingColumns = function filterRowTreeFromGroupingColumns(params) {
-  var rowTree = params.rowTree,
-      isRowMatchingFilters = params.isRowMatchingFilters;
-  var visibleRowsLookup = {};
-  var filteredRowsLookup = {};
-  var filteredDescendantCountLookup = {};
-
-  var filterTreeNode = function filterTreeNode(node, areAncestorsPassingChildren, areAncestorsExpanded) {
-    var _node$children, _node$children2;
-
-    var isMatchingFilters;
-
-    if (!isRowMatchingFilters) {
-      isMatchingFilters = true;
-    } else {
-      var shouldApplyItem = node.isAutoGenerated ? function (columnField) {
-        return shouldApplyFilterItemOnGroup(columnField, node);
-      } : undefined;
-      isMatchingFilters = isRowMatchingFilters(node.id, shouldApplyItem);
-    }
-
-    var filteredDescendantCount = 0;
-    (_node$children = node.children) == null ? void 0 : _node$children.forEach(function (childId) {
-      var childNode = rowTree[childId];
-      var childSubTreeSize = filterTreeNode(childNode, areAncestorsPassingChildren && isMatchingFilters, areAncestorsExpanded && !!node.childrenExpanded);
-      filteredDescendantCount += childSubTreeSize;
-    });
-    var shouldPassFilters;
-
-    if (!areAncestorsPassingChildren) {
-      shouldPassFilters = false;
-    } else if ((_node$children2 = node.children) != null && _node$children2.length) {
-      shouldPassFilters = isMatchingFilters && filteredDescendantCount > 0;
-    } else {
-      shouldPassFilters = isMatchingFilters;
-    }
-
-    visibleRowsLookup[node.id] = shouldPassFilters && areAncestorsExpanded;
-    filteredRowsLookup[node.id] = shouldPassFilters;
-
-    if (!shouldPassFilters) {
-      return 0;
-    }
-
-    filteredDescendantCountLookup[node.id] = filteredDescendantCount;
-
-    if (!node.children) {
-      return filteredDescendantCount + 1;
-    }
-
-    return filteredDescendantCount;
-  };
-
-  var nodes = Object.values(rowTree);
-
-  for (var i = 0; i < nodes.length; i += 1) {
-    var node = nodes[i];
-
-    if (node.depth === 0) {
-      filterTreeNode(node, true, true);
-    }
-  }
-
-  return {
-    visibleRowsLookup: visibleRowsLookup,
-    filteredRowsLookup: filteredRowsLookup,
-    filteredDescendantCountLookup: filteredDescendantCountLookup
-  };
-};
-export var getColDefOverrides = function getColDefOverrides(groupingColDefProp, fields) {
-  if (typeof groupingColDefProp === 'function') {
-    return groupingColDefProp({
-      groupingName: ROW_GROUPING_STRATEGY,
-      fields: fields
-    });
-  }
-
-  return groupingColDefProp;
-};
-export var mergeStateWithRowGroupingModel = function mergeStateWithRowGroupingModel(rowGroupingModel) {
-  return function (state) {
-    return _extends({}, state, {
-      rowGrouping: _extends({}, state.rowGrouping, {
-        model: rowGroupingModel
-      })
-    });
-  };
-};
-export var setStrategyAvailability = function setStrategyAvailability(apiRef, disableRowGrouping) {
-  var isAvailable;
-
-  if (disableRowGrouping) {
-    isAvailable = function isAvailable() {
-      return false;
-    };
-  } else {
-    isAvailable = function isAvailable() {
-      var rowGroupingSanitizedModel = gridRowGroupingSanitizedModelSelector(apiRef);
-      return rowGroupingSanitizedModel.length > 0;
-    };
-  }
-
-  apiRef.current.unstable_setStrategyAvailability('rowTree', ROW_GROUPING_STRATEGY, isAvailable);
-};

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

@@ -1,3 +0,0 @@
-export * from './gridRowGroupingSelector';
-export * from './gridRowGroupingInterfaces';
-export { GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, getRowGroupingFieldFromGroupingCriteria } from './gridRowGroupingUtils';

package/legacy/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -1,206 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import Divider from '@mui/material/Divider';
-import { useGridApiEventHandler, useGridApiMethod, gridFilteredDescendantCountLookupSelector } from '@mui/x-data-grid';
-import { useGridRegisterPipeProcessor, isDeepEqual } from '@mui/x-data-grid/internals';
-import { gridRowGroupingModelSelector, gridRowGroupingSanitizedModelSelector, gridRowGroupingStateSelector } from './gridRowGroupingSelector';
-import { getRowGroupingFieldFromGroupingCriteria, ROW_GROUPING_STRATEGY, isGroupingColumn, mergeStateWithRowGroupingModel, setStrategyAvailability } from './gridRowGroupingUtils';
-import { GridRowGroupableColumnMenuItems } from '../../../components/GridRowGroupableColumnMenuItems';
-import { GridRowGroupingColumnMenuItems } from '../../../components/GridRowGroupingColumnMenuItems';
-import { jsx as _jsx } from "react/jsx-runtime";
-export var rowGroupingStateInitializer = function rowGroupingStateInitializer(state, props) {
-  var _ref, _props$rowGroupingMod, _props$initialState, _props$initialState$r;
-
-  return _extends({}, state, {
-    rowGrouping: {
-      model: (_ref = (_props$rowGroupingMod = props.rowGroupingModel) != null ? _props$rowGroupingMod : (_props$initialState = props.initialState) == null ? void 0 : (_props$initialState$r = _props$initialState.rowGrouping) == null ? void 0 : _props$initialState$r.model) != null ? _ref : [],
-      unstable_sanitizedModelOnLastRowTreeCreation: []
-    }
-  });
-};
-/**
- * @requires useGridColumns (state, method) - can be after, async only
- * @requires useGridRows (state, method) - can be after, async only
- * @requires useGridParamsApi (method) - can be after, async only
- */
-
-export var useGridRowGrouping = function useGridRowGrouping(apiRef, props) {
-  apiRef.current.unstable_updateControlState({
-    stateId: 'rowGrouping',
-    propModel: props.rowGroupingModel,
-    propOnChange: props.onRowGroupingModelChange,
-    stateSelector: gridRowGroupingModelSelector,
-    changeEvent: 'rowGroupingModelChange'
-  });
-  /**
-   * API METHODS
-   */
-
-  var setRowGroupingModel = React.useCallback(function (model) {
-    var currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (currentModel !== model) {
-      apiRef.current.setState(mergeStateWithRowGroupingModel(model));
-      setStrategyAvailability(apiRef, props.disableRowGrouping);
-      apiRef.current.forceUpdate();
-    }
-  }, [apiRef, props.disableRowGrouping]);
-  var addRowGroupingCriteria = React.useCallback(function (field, groupingIndex) {
-    var currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (currentModel.includes(field)) {
-      return;
-    }
-
-    var cleanGroupingIndex = groupingIndex != null ? groupingIndex : currentModel.length;
-    var updatedModel = [].concat(_toConsumableArray(currentModel.slice(0, cleanGroupingIndex)), [field], _toConsumableArray(currentModel.slice(cleanGroupingIndex)));
-    apiRef.current.setRowGroupingModel(updatedModel);
-  }, [apiRef]);
-  var removeRowGroupingCriteria = React.useCallback(function (field) {
-    var currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (!currentModel.includes(field)) {
-      return;
-    }
-
-    apiRef.current.setRowGroupingModel(currentModel.filter(function (el) {
-      return el !== field;
-    }));
-  }, [apiRef]);
-  var setRowGroupingCriteriaIndex = React.useCallback(function (field, targetIndex) {
-    var currentModel = gridRowGroupingModelSelector(apiRef);
-    var currentTargetIndex = currentModel.indexOf(field);
-
-    if (currentTargetIndex === -1) {
-      return;
-    }
-
-    var updatedModel = _toConsumableArray(currentModel);
-
-    updatedModel.splice(targetIndex, 0, updatedModel.splice(currentTargetIndex, 1)[0]);
-    apiRef.current.setRowGroupingModel(updatedModel);
-  }, [apiRef]);
-  var rowGroupingApi = {
-    setRowGroupingModel: setRowGroupingModel,
-    addRowGroupingCriteria: addRowGroupingCriteria,
-    removeRowGroupingCriteria: removeRowGroupingCriteria,
-    setRowGroupingCriteriaIndex: setRowGroupingCriteriaIndex
-  };
-  useGridApiMethod(apiRef, rowGroupingApi, 'GridRowGroupingApi');
-  /**
-   * PRE-PROCESSING
-   */
-
-  var addColumnMenuButtons = React.useCallback(function (initialValue, columns) {
-    if (props.disableRowGrouping) {
-      return initialValue;
-    }
-
-    var menuItems;
-
-    if (isGroupingColumn(columns.field)) {
-      menuItems = /*#__PURE__*/_jsx(GridRowGroupingColumnMenuItems, {});
-    } else if (columns.groupable) {
-      menuItems = /*#__PURE__*/_jsx(GridRowGroupableColumnMenuItems, {});
-    } else {
-      menuItems = null;
-    }
-
-    if (menuItems == null) {
-      return initialValue;
-    }
-
-    return [].concat(_toConsumableArray(initialValue), [/*#__PURE__*/_jsx(Divider, {}), menuItems]);
-  }, [props.disableRowGrouping]);
-  var stateExportPreProcessing = React.useCallback(function (prevState) {
-    if (props.disableRowGrouping) {
-      return prevState;
-    }
-
-    var rowGroupingModelToExport = gridRowGroupingModelSelector(apiRef);
-
-    if (rowGroupingModelToExport.length === 0) {
-      return prevState;
-    }
-
-    return _extends({}, prevState, {
-      rowGrouping: {
-        model: rowGroupingModelToExport
-      }
-    });
-  }, [apiRef, props.disableRowGrouping]);
-  var stateRestorePreProcessing = React.useCallback(function (params, context) {
-    var _context$stateToResto;
-
-    if (props.disableRowGrouping) {
-      return params;
-    }
-
-    var rowGroupingModel = (_context$stateToResto = context.stateToRestore.rowGrouping) == null ? void 0 : _context$stateToResto.model;
-
-    if (rowGroupingModel != null) {
-      apiRef.current.setState(mergeStateWithRowGroupingModel(rowGroupingModel));
-    }
-
-    return params;
-  }, [apiRef, props.disableRowGrouping]);
-  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButtons);
-  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
-  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
-  /**
-   * EVENTS
-   */
-
-  var handleCellKeyDown = React.useCallback(function (params, event) {
-    var cellParams = apiRef.current.getCellParams(params.id, params.field);
-
-    if (isGroupingColumn(cellParams.field) && event.key === ' ' && !event.shiftKey) {
-      var _gridFilteredDescenda;
-
-      event.stopPropagation();
-      event.preventDefault();
-      var filteredDescendantCount = (_gridFilteredDescenda = gridFilteredDescendantCountLookupSelector(apiRef)[params.id]) != null ? _gridFilteredDescenda : 0;
-      var isOnGroupingCell = props.rowGroupingColumnMode === 'single' || getRowGroupingFieldFromGroupingCriteria(params.rowNode.groupingField) === params.field;
-
-      if (!isOnGroupingCell || filteredDescendantCount === 0) {
-        return;
-      }
-
-      apiRef.current.setRowChildrenExpansion(params.id, !params.rowNode.childrenExpanded);
-    }
-  }, [apiRef, props.rowGroupingColumnMode]);
-  var checkGroupingColumnsModelDiff = React.useCallback(function () {
-    var rowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
-    var lastGroupingColumnsModelApplied = gridRowGroupingStateSelector(apiRef.current.state).unstable_sanitizedModelOnLastRowTreeCreation;
-
-    if (!isDeepEqual(lastGroupingColumnsModelApplied, rowGroupingModel)) {
-      apiRef.current.setState(function (state) {
-        return _extends({}, state, {
-          rowGrouping: _extends({}, state.rowGrouping, {
-            unstable_sanitizedModelOnLastRowTreeCreation: rowGroupingModel
-          })
-        });
-      });
-      apiRef.current.unstable_requestPipeProcessorsApplication('hydrateColumns');
-      setStrategyAvailability(apiRef, props.disableRowGrouping); // Refresh the row tree creation strategy processing
-      // TODO: Add a clean way to re-run a strategy processing without publishing a private event
-
-      if (apiRef.current.unstable_getActiveStrategy('rowTree') === ROW_GROUPING_STRATEGY) {
-        apiRef.current.publishEvent('activeStrategyProcessorChange', 'rowTreeCreation');
-      }
-    }
-  }, [apiRef, props.disableRowGrouping]);
-  useGridApiEventHandler(apiRef, 'cellKeyDown', handleCellKeyDown);
-  useGridApiEventHandler(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
-  useGridApiEventHandler(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);
-  /**
-   * EFFECTS
-   */
-
-  React.useEffect(function () {
-    if (props.rowGroupingModel !== undefined) {
-      apiRef.current.setRowGroupingModel(props.rowGroupingModel);
-    }
-  }, [apiRef, props.rowGroupingModel]);
-};