@mui/x-data-grid 5.9.0 → 5.11.1

package/legacy/hooks/features/filter/gridFilterState.js

@@ -2,6 +2,8 @@ import { GridLinkOperator } from '../../../models/gridFilterItem';
 export var getDefaultGridFilterModel = function getDefaultGridFilterModel() {
   return {
     items: [],
-    linkOperator: GridLinkOperator.And
+    linkOperator: GridLinkOperator.And,
+    quickFilterValues: [],
+    quickFilterLogicOperator: GridLinkOperator.And
   };
 };

package/legacy/hooks/features/filter/gridFilterUtils.js

@@ -1,6 +1,7 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { GridLinkOperator } from '../../../models';
 import { buildWarning } from '../../../utils/warning';
+import { gridColumnFieldsSelector } from '../columns';
 
 /**
  * Adds default values to the optional fields of a filter items.
@@ -86,7 +87,7 @@ export var mergeStateWithFilterModel = function mergeStateWithFilterModel(filter
  * @returns {GridAggregatedFilterItemApplier | null} A method that checks if a row is matching the current filter model. If `null`, we consider that all the rows are matching the filters.
  */
 
-export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(filterModel, apiRef) {
+export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterItemsApplier(filterModel, apiRef) {
   var items = filterModel.items,
       _filterModel$linkOper = filterModel.linkOperator,
       linkOperator = _filterModel$linkOper === void 0 ? GridLinkOperator.And : _filterModel$linkOper;
@@ -160,7 +161,7 @@ export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(
 
   return function (rowId, shouldApplyFilter) {
     var filteredAppliers = shouldApplyFilter ? appliers.filter(function (applier) {
-      return shouldApplyFilter(applier.item);
+      return shouldApplyFilter(applier.item.columnField);
     }) : appliers; // Return `false` as soon as we have a failing filter
 
     if (linkOperator === GridLinkOperator.And) {
@@ -174,4 +175,97 @@ export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(
       return applier.fn(rowId);
     });
   };
+};
+/**
+ * Generates a method to easily check if a row is matching the current quick filter.
+ * @param {any[]} values The model with which we want to filter the rows.
+ * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
+ * @returns {GridAggregatedFilterItemApplier | null} A method that checks if a row is matching the current filter model. If `null`, we consider that all the rows are matching the filters.
+ */
+
+export var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilterApplier(filterModel, apiRef) {
+  var _filterModel$quickFil = filterModel.quickFilterValues,
+      quickFilterValues = _filterModel$quickFil === void 0 ? [] : _filterModel$quickFil,
+      _filterModel$quickFil2 = filterModel.quickFilterLogicOperator,
+      quickFilterLogicOperator = _filterModel$quickFil2 === void 0 ? GridLinkOperator.And : _filterModel$quickFil2;
+
+  if (quickFilterValues.length === 0) {
+    return null;
+  }
+
+  var columnsFields = gridColumnFieldsSelector(apiRef);
+  var appliersPerColumnField = {};
+  columnsFields.forEach(function (field) {
+    var column = apiRef.current.getColumn(field);
+    var getApplyQuickFilterFn = column == null ? void 0 : column.getApplyQuickFilterFn;
+
+    if (!getApplyQuickFilterFn) {
+      return;
+    }
+
+    appliersPerColumnField[field] = quickFilterValues.map(function (value) {
+      return getApplyQuickFilterFn(value, column, apiRef);
+    });
+  }); // If some value does not have an applier we ignore them
+
+  var sanitizedQuickFilterValues = quickFilterValues.filter(function (value, index) {
+    return Object.keys(appliersPerColumnField).some(function (field) {
+      return appliersPerColumnField[field][index] != null;
+    });
+  });
+  return function (rowId, shouldApplyFilter) {
+    var usedCellParams = {};
+    Object.keys(appliersPerColumnField).forEach(function (columnField) {
+      if (!shouldApplyFilter || shouldApplyFilter(columnField)) {
+        usedCellParams[columnField] = apiRef.current.getCellParams(rowId, columnField);
+      }
+    }); // Return `false` as soon as we have a quick filter value that does not match any column
+
+    if (quickFilterLogicOperator === GridLinkOperator.And) {
+      return sanitizedQuickFilterValues.every(function (value, index) {
+        return Object.keys(appliersPerColumnField).some(function (field) {
+          var _appliersPerColumnFie, _appliersPerColumnFie2;
+
+          if (appliersPerColumnField[field][index] == null) {
+            return false;
+          }
+
+          return (_appliersPerColumnFie = (_appliersPerColumnFie2 = appliersPerColumnField[field])[index]) == null ? void 0 : _appliersPerColumnFie.call(_appliersPerColumnFie2, usedCellParams[field]);
+        });
+      });
+    } // Return `true` as soon as we have have a quick filter value that match any column
+
+
+    return sanitizedQuickFilterValues.some(function (value, index) {
+      return Object.keys(appliersPerColumnField).some(function (field) {
+        var _appliersPerColumnFie3, _appliersPerColumnFie4;
+
+        if (appliersPerColumnField[field][index] == null) {
+          return false;
+        }
+
+        return (_appliersPerColumnFie3 = (_appliersPerColumnFie4 = appliersPerColumnField[field])[index]) == null ? void 0 : _appliersPerColumnFie3.call(_appliersPerColumnFie4, usedCellParams[field]);
+      });
+    });
+  };
+};
+export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(filterModel, apiRef) {
+  var isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(filterModel, apiRef);
+  var isRowMatchingQuickFilter = buildAggregatedQuickFilterApplier(filterModel, apiRef);
+
+  if (isRowMatchingFilterItems == null && isRowMatchingQuickFilter == null) {
+    return null;
+  }
+
+  if (isRowMatchingFilterItems == null) {
+    return isRowMatchingQuickFilter;
+  }
+
+  if (isRowMatchingQuickFilter == null) {
+    return isRowMatchingFilterItems;
+  }
+
+  return function (rowId, shouldApplyFilter) {
+    return isRowMatchingFilterItems(rowId, shouldApplyFilter) && isRowMatchingQuickFilter(rowId, shouldApplyFilter);
+  };
 };

package/legacy/hooks/features/filter/useGridFilter.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { GridEvents } from '../../../models/events';
 import { GridFeatureModeConstant } from '../../../models/gridFeatureMode';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
@@ -15,6 +14,7 @@ import { gridRowIdsSelector } from '../rows';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
 import { GRID_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from '../../core/strategyProcessing';
 import { buildAggregatedFilterApplier, sanitizeFilterModel, mergeStateWithFilterModel } from './gridFilterUtils';
+import { isDeepEqual } from '../../../utils/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var filterStateInitializer = function filterStateInitializer(state, props, apiRef) {
   var _ref, _props$filterModel, _props$initialState, _props$initialState$f;
@@ -43,7 +43,7 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
     propModel: props.filterModel,
     propOnChange: props.onFilterModelChange,
     stateSelector: gridFilterModelSelector,
-    changeEvent: GridEvents.filterModelChange
+    changeEvent: 'filterModelChange'
   });
   var updateFilteredRows = React.useCallback(function () {
     apiRef.current.setState(function (state) {
@@ -56,7 +56,7 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
         filter: _extends({}, state.filter, filteringResult)
       });
     });
-    apiRef.current.publishEvent(GridEvents.filteredRowsSet);
+    apiRef.current.publishEvent('filteredRowsSet');
   }, [props.filterMode, apiRef]);
   /**
    * API METHODS
@@ -146,6 +146,17 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
       linkOperator: linkOperator
     }));
   }, [apiRef]);
+  var setQuickFilterValues = React.useCallback(function (values) {
+    var filterModel = gridFilterModelSelector(apiRef);
+
+    if (isDeepEqual(filterModel.quickFilterValues, values)) {
+      return;
+    }
+
+    apiRef.current.setFilterModel(_extends({}, filterModel, {
+      quickFilterValues: _toConsumableArray(values)
+    }));
+  }, [apiRef]);
   var setFilterModel = React.useCallback(function (model) {
     var currentModel = gridFilterModelSelector(apiRef);
 
@@ -169,7 +180,8 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
     setFilterModel: setFilterModel,
     showFilterPanel: showFilterPanel,
     hideFilterPanel: hideFilterPanel,
-    getVisibleRowModels: getVisibleRowModels
+    getVisibleRowModels: getVisibleRowModels,
+    setQuickFilterValues: setQuickFilterValues
   };
   useGridApiMethod(apiRef, filterApi, 'GridFilterApi');
   /**
@@ -266,10 +278,10 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
   }, [apiRef]); // Do not call `apiRef.current.forceUpdate` to avoid re-render before updating the sorted rows.
   // Otherwise, the state is not consistent during the render
 
-  useGridApiEventHandler(apiRef, GridEvents.rowsSet, updateFilteredRows);
-  useGridApiEventHandler(apiRef, GridEvents.rowExpansionChange, apiRef.current.unstable_applyFilters);
-  useGridApiEventHandler(apiRef, GridEvents.columnsChange, handleColumnsChange);
-  useGridApiEventHandler(apiRef, GridEvents.activeStrategyProcessorChange, handleStrategyProcessorChange);
+  useGridApiEventHandler(apiRef, 'rowsSet', updateFilteredRows);
+  useGridApiEventHandler(apiRef, 'rowExpansionChange', apiRef.current.unstable_applyFilters);
+  useGridApiEventHandler(apiRef, 'columnsChange', handleColumnsChange);
+  useGridApiEventHandler(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
   /**
    * 1ST RENDER
    */

package/legacy/hooks/features/focus/useGridFocus.js

@@ -1,7 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { ownerDocument } from '@mui/material/utils';
-import { GridEvents } from '../../../models/events';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
@@ -32,14 +31,9 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
   var logger = useGridLogger(apiRef, 'useGridFocus');
   var lastClickedCell = React.useRef(null);
   var setCellFocus = React.useCallback(function (id, field) {
-    // The row might have been deleted
-    if (!apiRef.current.getRow(id)) {
-      return;
-    }
-
     var focusedCell = gridFocusCellSelector(apiRef);
 
-    if ((focusedCell == null ? void 0 : focusedCell.id) === id && focusedCell.field === field) {
+    if ((focusedCell == null ? void 0 : focusedCell.id) === id && (focusedCell == null ? void 0 : focusedCell.field) === field) {
       return;
     }
 
@@ -62,15 +56,20 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
         }
       });
     });
-    apiRef.current.forceUpdate();
-    apiRef.current.publishEvent(GridEvents.cellFocusIn, apiRef.current.getCellParams(id, field));
+    apiRef.current.forceUpdate(); // The row might have been deleted
+
+    if (!apiRef.current.getRow(id)) {
+      return;
+    }
+
+    apiRef.current.publishEvent('cellFocusIn', apiRef.current.getCellParams(id, field));
   }, [apiRef, logger]);
   var setColumnHeaderFocus = React.useCallback(function (field) {
     var event = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var cell = gridFocusCellSelector(apiRef);
 
     if (cell) {
-      apiRef.current.publishEvent(GridEvents.cellFocusOut, apiRef.current.getCellParams(cell.id, cell.field), event);
+      apiRef.current.publishEvent('cellFocusOut', apiRef.current.getCellParams(cell.id, cell.field), event);
     }
 
     apiRef.current.setState(function (state) {
@@ -200,7 +199,7 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
     // Publishes an event to notify that the focus was lost
 
 
-    apiRef.current.publishEvent(GridEvents.cellFocusOut, apiRef.current.getCellParams(focusedCell.id, focusedCell.field), event);
+    apiRef.current.publishEvent('cellFocusOut', apiRef.current.getCellParams(focusedCell.id, focusedCell.field), event);
 
     if (cellParams) {
       apiRef.current.setCellFocus(cellParams.id, cellParams.field);
@@ -227,29 +226,25 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
       apiRef.current.setCellFocus(params.id, params.field);
     }
   }, [apiRef]);
+  var handleRowSet = React.useCallback(function () {
+    var cell = gridFocusCellSelector(apiRef); // If the focused cell is in a row which does not exist anymore, then remove the focus
+
+    if (cell && !apiRef.current.getRow(cell.id)) {
+      apiRef.current.setState(function (state) {
+        return _extends({}, state, {
+          focus: {
+            cell: null,
+            columnHeader: null
+          }
+        });
+      });
+    }
+  }, [apiRef]);
   useGridApiMethod(apiRef, {
     setCellFocus: setCellFocus,
     setColumnHeaderFocus: setColumnHeaderFocus,
     unstable_moveFocusToRelativeCell: moveFocusToRelativeCell
   }, 'GridFocusApi');
-  React.useEffect(function () {
-    var cell = gridFocusCellSelector(apiRef);
-
-    if (cell) {
-      var updatedRow = apiRef.current.getRow(cell.id);
-
-      if (!updatedRow) {
-        apiRef.current.setState(function (state) {
-          return _extends({}, state, {
-            focus: {
-              cell: null,
-              columnHeader: null
-            }
-          });
-        });
-      }
-    }
-  }, [apiRef, props.rows]);
   React.useEffect(function () {
     var doc = ownerDocument(apiRef.current.rootElementRef.current);
     doc.addEventListener('click', handleDocumentClick);
@@ -257,10 +252,11 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
       doc.removeEventListener('click', handleDocumentClick);
     };
   }, [apiRef, handleDocumentClick]);
-  useGridApiEventHandler(apiRef, GridEvents.columnHeaderBlur, handleBlur);
-  useGridApiEventHandler(apiRef, GridEvents.cellDoubleClick, handleCellDoubleClick);
-  useGridApiEventHandler(apiRef, GridEvents.cellMouseUp, handleCellMouseUp);
-  useGridApiEventHandler(apiRef, GridEvents.cellKeyDown, handleCellKeyDown);
-  useGridApiEventHandler(apiRef, GridEvents.cellModeChange, handleCellModeChange);
-  useGridApiEventHandler(apiRef, GridEvents.columnHeaderFocus, handleColumnHeaderFocus);
+  useGridApiEventHandler(apiRef, 'columnHeaderBlur', handleBlur);
+  useGridApiEventHandler(apiRef, 'cellDoubleClick', handleCellDoubleClick);
+  useGridApiEventHandler(apiRef, 'cellMouseUp', handleCellMouseUp);
+  useGridApiEventHandler(apiRef, 'cellKeyDown', handleCellKeyDown);
+  useGridApiEventHandler(apiRef, 'cellModeChange', handleCellModeChange);
+  useGridApiEventHandler(apiRef, 'columnHeaderFocus', handleColumnHeaderFocus);
+  useGridApiEventHandler(apiRef, 'rowsSet', handleRowSet);
 };

package/legacy/hooks/features/keyboardNavigation/useGridKeyboardNavigation.js

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { GridEvents } from '../../../models/events';
 import { gridVisibleColumnDefinitionsSelector } from '../columns/gridColumnsSelector';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
@@ -319,10 +318,10 @@ export var useGridKeyboardNavigation = function useGridKeyboardNavigation(apiRef
     var cellParams = apiRef.current.getCellParams(params.id, params.field);
 
     if (cellParams.cellMode !== GridCellModes.Edit && isNavigationKey(event.key)) {
-      apiRef.current.publishEvent(GridEvents.cellNavigationKeyDown, cellParams, event);
+      apiRef.current.publishEvent('cellNavigationKeyDown', cellParams, event);
     }
   }, [apiRef]);
-  useGridApiEventHandler(apiRef, GridEvents.cellNavigationKeyDown, handleCellNavigationKeyDown);
-  useGridApiEventHandler(apiRef, GridEvents.columnHeaderKeyDown, handleColumnHeaderKeyDown);
-  useGridApiEventHandler(apiRef, GridEvents.cellKeyDown, handleCellKeyDown);
+  useGridApiEventHandler(apiRef, 'cellNavigationKeyDown', handleCellNavigationKeyDown);
+  useGridApiEventHandler(apiRef, 'columnHeaderKeyDown', handleColumnHeaderKeyDown);
+  useGridApiEventHandler(apiRef, 'cellKeyDown', handleCellKeyDown);
 };

package/legacy/hooks/features/pagination/useGridPage.js

@@ -1,7 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useGridLogger, useGridSelector, useGridApiMethod, useGridApiEventHandler } from '../../utils';
-import { GridEvents } from '../../../models/events';
 import { gridVisibleTopLevelRowCountSelector } from '../filter';
 import { gridPageSelector, gridPageSizeSelector } from './gridPaginationSelector';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
@@ -49,7 +48,7 @@ export var useGridPage = function useGridPage(apiRef, props) {
     propModel: props.page,
     propOnChange: props.onPageChange,
     stateSelector: gridPageSelector,
-    changeEvent: GridEvents.pageChange
+    changeEvent: 'pageChange'
   });
   /**
    * API METHODS
@@ -120,8 +119,8 @@ export var useGridPage = function useGridPage(apiRef, props) {
     });
   };
 
-  useGridApiEventHandler(apiRef, GridEvents.pageSizeChange, handlePageSizeChange);
-  useGridApiEventHandler(apiRef, GridEvents.pageChange, handlePageChange);
+  useGridApiEventHandler(apiRef, 'pageSizeChange', handlePageSizeChange);
+  useGridApiEventHandler(apiRef, 'pageChange', handlePageChange);
   /**
    * EFFECTS
    */

package/legacy/hooks/features/pagination/useGridPageSize.js

@@ -1,6 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { GridEvents } from '../../../models/events';
 import { useGridLogger, useGridApiMethod, useGridApiEventHandler, useGridSelector } from '../../utils';
 import { gridPageSizeSelector } from './gridPaginationSelector';
 import { gridDensityRowHeightSelector } from '../density';
@@ -33,7 +32,7 @@ export var useGridPageSize = function useGridPageSize(apiRef, props) {
     propModel: props.pageSize,
     propOnChange: props.onPageSizeChange,
     stateSelector: gridPageSizeSelector,
-    changeEvent: GridEvents.pageSizeChange
+    changeEvent: 'pageSizeChange'
   });
   /**
    * API METHODS
@@ -106,7 +105,7 @@ export var useGridPageSize = function useGridPageSize(apiRef, props) {
     var maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);
     apiRef.current.setPageSize(maximumPageSizeWithoutScrollBar);
   }, [apiRef, props.autoPageSize, rowHeight]);
-  useGridApiEventHandler(apiRef, GridEvents.viewportInnerSizeChange, handleUpdateAutoPageSize);
+  useGridApiEventHandler(apiRef, 'viewportInnerSizeChange', handleUpdateAutoPageSize);
   /**
    * EFFECTS
    */

package/legacy/hooks/features/preferencesPanel/useGridPreferencesPanel.js

@@ -1,11 +1,9 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { GridEvents } from '../../../models/events';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
 import { gridPreferencePanelStateSelector } from './gridPreferencePanelSelector';
-import { useGridSelector } from '../../utils/useGridSelector';
 export var preferencePanelStateInitializer = function preferencePanelStateInitializer(state, props) {
   var _props$initialState$p, _props$initialState;
 
@@ -21,7 +19,6 @@ export var preferencePanelStateInitializer = function preferencePanelStateInitia
 
 export var useGridPreferencesPanel = function useGridPreferencesPanel(apiRef) {
   var logger = useGridLogger(apiRef, 'useGridPreferencesPanel');
-  var preferencePanelState = useGridSelector(apiRef, gridPreferencePanelStateSelector);
   var hideTimeout = React.useRef();
   var immediateTimeout = React.useRef();
   /**
@@ -30,9 +27,10 @@ export var useGridPreferencesPanel = function useGridPreferencesPanel(apiRef) {
 
   var hidePreferences = React.useCallback(function () {
     logger.debug('Hiding Preferences Panel');
+    var preferencePanelState = gridPreferencePanelStateSelector(apiRef.current.state);
 
     if (preferencePanelState.openedPanelValue) {
-      apiRef.current.publishEvent(GridEvents.preferencePanelClose, {
+      apiRef.current.publishEvent('preferencePanelClose', {
         openedPanelValue: preferencePanelState.openedPanelValue
       });
     }
@@ -45,7 +43,7 @@ export var useGridPreferencesPanel = function useGridPreferencesPanel(apiRef) {
       });
     });
     apiRef.current.forceUpdate();
-  }, [apiRef, logger, preferencePanelState.openedPanelValue]); // This is to prevent the preferences from closing when you open a select box or another panel,
+  }, [apiRef, logger]); // This is to prevent the preferences from closing when you open a select box or another panel,
   // The issue is in MUI core V4 => Fixed in V5
 
   var doNotHidePanel = React.useCallback(function () {
@@ -69,7 +67,7 @@ export var useGridPreferencesPanel = function useGridPreferencesPanel(apiRef) {
         })
       });
     });
-    apiRef.current.publishEvent(GridEvents.preferencePanelOpen, {
+    apiRef.current.publishEvent('preferencePanelOpen', {
       openedPanelValue: newValue
     });
     apiRef.current.forceUpdate();

package/legacy/hooks/features/rows/gridRowsSelector.js

@@ -14,6 +14,9 @@ export var gridTopLevelRowCountSelector = createSelector(gridRowsStateSelector,
 export var gridRowsLookupSelector = createSelector(gridRowsStateSelector, function (rows) {
   return rows.idRowsLookup;
 });
+export var gridRowsIdToIdLookupSelector = createSelector(gridRowsStateSelector, function (rows) {
+  return rows.idToIdLookup;
+});
 export var gridRowTreeSelector = createSelector(gridRowsStateSelector, function (rows) {
   return rows.tree;
 });

package/legacy/hooks/features/rows/gridRowsUtils.js

@@ -1,3 +1,8 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["rowsBeforePartialUpdates"];
+
 /**
  * A helper function to check if the id provided is valid.
  * @param {GridRowId} id Id as [[GridRowId]].
@@ -10,4 +15,80 @@ export function checkGridRowIdIsValid(id, row) {
   if (id == null) {
     throw new Error(['MUI: The data grid component requires all rows to have a unique `id` property.', 'Alternatively, you can use the `getRowId` prop to specify a custom id for each row.', detailErrorMessage, JSON.stringify(row)].join('\n'));
   }
-}
+}
+export var getRowIdFromRowModel = function getRowIdFromRowModel(rowModel, getRowId, detailErrorMessage) {
+  var id = getRowId ? getRowId(rowModel) : rowModel.id;
+  checkGridRowIdIsValid(id, rowModel, detailErrorMessage);
+  return id;
+};
+export var createRowsInternalCache = function createRowsInternalCache(_ref) {
+  var rows = _ref.rows,
+      getRowId = _ref.getRowId,
+      loading = _ref.loading;
+  var cache = {
+    rowsBeforePartialUpdates: rows,
+    loadingPropBeforePartialUpdates: loading,
+    idRowsLookup: {},
+    idToIdLookup: {},
+    ids: []
+  };
+
+  for (var i = 0; i < rows.length; i += 1) {
+    var row = rows[i];
+    var id = getRowIdFromRowModel(row, getRowId);
+    cache.idRowsLookup[id] = row;
+    cache.idToIdLookup[id] = id;
+    cache.ids.push(id);
+  }
+
+  return cache;
+};
+export var getRowsStateFromCache = function getRowsStateFromCache(_ref2) {
+  var apiRef = _ref2.apiRef,
+      previousTree = _ref2.previousTree,
+      rowCountProp = _ref2.rowCountProp,
+      loadingProp = _ref2.loadingProp;
+
+  var _apiRef$current$unsta = apiRef.current.unstable_caches.rows,
+      rowsBeforePartialUpdates = _apiRef$current$unsta.rowsBeforePartialUpdates,
+      cacheForGrouping = _objectWithoutProperties(_apiRef$current$unsta, _excluded);
+
+  var rowCount = rowCountProp != null ? rowCountProp : 0;
+  var groupingResponse = apiRef.current.unstable_applyStrategyProcessor('rowTreeCreation', _extends({}, cacheForGrouping, {
+    previousTree: previousTree
+  }));
+  var processedGroupingResponse = apiRef.current.unstable_applyPipeProcessors('hydrateRows', groupingResponse);
+  var dataTopLevelRowCount = processedGroupingResponse.treeDepth === 1 ? processedGroupingResponse.ids.length : Object.values(processedGroupingResponse.tree).filter(function (node) {
+    return node.parent == null;
+  }).length;
+  return _extends({}, processedGroupingResponse, {
+    groupingResponseBeforeRowHydration: groupingResponse,
+    loading: loadingProp,
+    totalRowCount: Math.max(rowCount, processedGroupingResponse.ids.length),
+    totalTopLevelRowCount: Math.max(rowCount, dataTopLevelRowCount)
+  });
+};
+export var getTreeNodeDescendants = function getTreeNodeDescendants(tree, parentId, skipAutoGeneratedRows) {
+  var _tree$parentId;
+
+  var children = (_tree$parentId = tree[parentId]) == null ? void 0 : _tree$parentId.children;
+
+  if (children == null) {
+    return [];
+  }
+
+  var validDescendants = [];
+
+  for (var i = 0; i < children.length; i += 1) {
+    var child = children[i];
+    var childNode = tree[child];
+
+    if (!skipAutoGeneratedRows || !childNode.isAutoGenerated) {
+      validDescendants.push(child);
+    }
+
+    validDescendants.push.apply(validDescendants, _toConsumableArray(getTreeNodeDescendants(tree, childNode.id, skipAutoGeneratedRows)));
+  }
+
+  return validDescendants;
+};