@mui/x-data-grid-premium 5.11.0

package/legacy/hooks/features/export/useGridExcelExport.js

@@ -0,0 +1,111 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import * as React from 'react';
+import { useGridApiMethod, useGridLogger } from '@mui/x-data-grid';
+import { useGridRegisterPipeProcessor, exportAs, getColumnsToExport, defaultGetRowsToExport } from '@mui/x-data-grid/internals';
+import { buildExcel } from './serializer/excelSerializer';
+import { GridExcelExportMenuItem } from '../../../components';
+/**
+ * @requires useGridColumns (state)
+ * @requires useGridFilter (state)
+ * @requires useGridSorting (state)
+ * @requires useGridSelection (state)
+ * @requires useGridParamsApi (method)
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+export var useGridExcelExport = function useGridExcelExport(apiRef) {
+  var logger = useGridLogger(apiRef, 'useGridExcelExport');
+  var getDataAsExcel = React.useCallback(function () {
+    var _options$getRowsToExp, _options$includeHeade;
+
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    logger.debug("Get data as excel");
+    var getRowsToExport = (_options$getRowsToExp = options.getRowsToExport) != null ? _options$getRowsToExp : defaultGetRowsToExport;
+    var exportedRowIds = getRowsToExport({
+      apiRef: apiRef
+    });
+    var exportedColumns = getColumnsToExport({
+      apiRef: apiRef,
+      options: options
+    });
+    return buildExcel({
+      columns: exportedColumns,
+      rowIds: exportedRowIds,
+      includeHeaders: (_options$includeHeade = options.includeHeaders) != null ? _options$includeHeade : true,
+      valueOptionsSheetName: (options == null ? void 0 : options.valueOptionsSheetName) || 'Options',
+      columnsStyles: options == null ? void 0 : options.columnsStyles,
+      exceljsPreProcess: options == null ? void 0 : options.exceljsPreProcess,
+      exceljsPostProcess: options == null ? void 0 : options.exceljsPostProcess
+    }, apiRef.current);
+  }, [logger, apiRef]);
+  var exportDataAsExcel = React.useCallback( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
+      var workbook, content, blob;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              logger.debug("Export data as excel");
+              _context.next = 3;
+              return getDataAsExcel(options);
+
+            case 3:
+              workbook = _context.sent;
+
+              if (!(workbook === null)) {
+                _context.next = 6;
+                break;
+              }
+
+              return _context.abrupt("return");
+
+            case 6:
+              _context.next = 8;
+              return workbook.xlsx.writeBuffer();
+
+            case 8:
+              content = _context.sent;
+              blob = new Blob([content], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+              });
+              exportAs(blob, 'xlsx', options == null ? void 0 : options.fileName);
+
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [logger, getDataAsExcel]);
+  var excelExportApi = {
+    getDataAsExcel: getDataAsExcel,
+    exportDataAsExcel: exportDataAsExcel
+  };
+  useGridApiMethod(apiRef, excelExportApi, 'GridExcelExportApi');
+  /**
+   * PRE-PROCESSING
+   */
+
+  var addExportMenuButtons = React.useCallback(function (initialValue, options) {
+    var _options$excelOptions;
+
+    if ((_options$excelOptions = options.excelOptions) != null && _options$excelOptions.disableToolbarButton) {
+      return initialValue;
+    }
+
+    return [].concat(_toConsumableArray(initialValue), [{
+      component: /*#__PURE__*/_jsx(GridExcelExportMenuItem, {
+        options: options.excelOptions
+      }),
+      componentName: 'excelExport'
+    }]);
+  }, []);
+  useGridRegisterPipeProcessor(apiRef, 'exportMenu', addExportMenuButtons);
+};

package/legacy/hooks/features/index.js

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

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

@@ -0,0 +1,319 @@
+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-pro';
+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

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

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

@@ -0,0 +1,13 @@
+import { gridColumnLookupSelector } from '@mui/x-data-grid-pro';
+import { createSelector } from '@mui/x-data-grid-pro/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

@@ -0,0 +1,147 @@
+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

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