@mui/x-data-grid 5.6.0 → 5.8.0

package/node/hooks/features/selection/useGridSelection.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useGridSelection = void 0;
+exports.useGridSelection = exports.selectionStateInitializer = void 0;
 
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 
@@ -21,48 +21,64 @@ var _useGridLogger = require("../../utils/useGridLogger");
 
 var _gridRowsSelector = require("../rows/gridRowsSelector");
 
-var _domUtils = require("../../../utils/domUtils");
-
 var _gridSelectionSelector = require("./gridSelectionSelector");
 
 var _pagination = require("../pagination");
 
+var _gridFocusStateSelector = require("../focus/gridFocusStateSelector");
+
 var _gridFilterSelector = require("../filter/gridFilterSelector");
 
 var _colDef = require("../../../colDef");
 
-var _useGridStateInit = require("../../utils/useGridStateInit");
-
 var _gridEditRowModel = require("../../../models/gridEditRowModel");
 
 var _keyboardUtils = require("../../../utils/keyboardUtils");
 
-var _useCurrentPageRows = require("../../utils/useCurrentPageRows");
+var _useGridVisibleRows = require("../../utils/useGridVisibleRows");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
+const getSelectionModelPropValue = (selectionModelProp, prevSelectionModel) => {
+  if (selectionModelProp == null) {
+    return selectionModelProp;
+  }
+
+  if (Array.isArray(selectionModelProp)) {
+    return selectionModelProp;
+  }
+
+  if (prevSelectionModel && prevSelectionModel[0] === selectionModelProp) {
+    return prevSelectionModel;
+  }
+
+  return [selectionModelProp];
+};
+
+const selectionStateInitializer = (state, props) => {
+  var _getSelectionModelPro;
+
+  return (0, _extends2.default)({}, state, {
+    selection: (_getSelectionModelPro = getSelectionModelPropValue(props.selectionModel)) != null ? _getSelectionModelPro : []
+  });
+};
 /**
- * @requires useGridRows (state, method)
- * @requires useGridParamsApi (method)
+ * @requires useGridRows (state, method) - can be after
+ * @requires useGridParamsApi (method) - can be after
+ * @requires useGridFocus (state) - can be after
+ * @requires useGridKeyboardNavigation (`cellKeyDown` event must first be consumed by it)
  */
+
+
+exports.selectionStateInitializer = selectionStateInitializer;
+
 const useGridSelection = (apiRef, props) => {
   const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridSelection');
   const propSelectionModel = React.useMemo(() => {
-    if (props.selectionModel == null) {
-      return props.selectionModel;
-    }
-
-    if (Array.isArray(props.selectionModel)) {
-      return props.selectionModel;
-    }
-
-    return [props.selectionModel];
-  }, [props.selectionModel]);
-  (0, _useGridStateInit.useGridStateInit)(apiRef, state => (0, _extends2.default)({}, state, {
-    selection: propSelectionModel != null ? propSelectionModel : []
-  }));
+    return getSelectionModelPropValue(props.selectionModel, (0, _gridSelectionSelector.gridSelectionStateSelector)(apiRef.current.state));
+  }, [apiRef, props.selectionModel]);
   const lastRowToggled = React.useRef(null);
   apiRef.current.unstable_updateControlState({
     stateId: 'selection',
@@ -80,7 +96,8 @@ const useGridSelection = (apiRef, props) => {
     paginationMode
   } = props;
   const canHaveMultipleSelection = !disableMultipleSelection || checkboxSelection;
-  const expandRowRangeSelection = React.useCallback(id => {
+  const visibleRows = (0, _useGridVisibleRows.useGridVisibleRows)(apiRef, props);
+  const expandMouseRowRangeSelection = React.useCallback(id => {
     var _lastRowToggled$curre;
 
     let endId = id;
@@ -92,6 +109,10 @@ const useGridSelection = (apiRef, props) => {
       const startIndex = visibleRowIds.findIndex(rowId => rowId === startId);
       const endIndex = visibleRowIds.findIndex(rowId => rowId === endId);
 
+      if (startIndex === endIndex) {
+        return;
+      }
+
       if (startIndex > endIndex) {
         endId = visibleRowIds[endIndex + 1];
       } else {
@@ -182,12 +203,13 @@ const useGridSelection = (apiRef, props) => {
       return;
     }
 
-    logger.debug(`Expanding selection from row ${startId} to row ${endId}`);
-    const visibleRowIds = (0, _gridFilterSelector.gridVisibleSortedRowIdsSelector)(apiRef);
-    const startIndex = visibleRowIds.indexOf(startId);
-    const endIndex = visibleRowIds.indexOf(endId);
+    logger.debug(`Expanding selection from row ${startId} to row ${endId}`); // Using rows from all pages allow to select a range across several pages
+
+    const allPagesRowIds = (0, _gridFilterSelector.gridVisibleSortedRowIdsSelector)(apiRef);
+    const startIndex = allPagesRowIds.indexOf(startId);
+    const endIndex = allPagesRowIds.indexOf(endId);
     const [start, end] = startIndex > endIndex ? [endIndex, startIndex] : [startIndex, endIndex];
-    const rowsBetweenStartAndEnd = visibleRowIds.slice(start, end + 1);
+    const rowsBetweenStartAndEnd = allPagesRowIds.slice(start, end + 1);
     apiRef.current.selectRows(rowsBetweenStartAndEnd, isSelected, resetSelection);
   }, [apiRef, logger]);
   const selectionApi = {
@@ -260,11 +282,11 @@ const useGridSelection = (apiRef, props) => {
     }
 
     if (event.shiftKey && (canHaveMultipleSelection || checkboxSelection)) {
-      expandRowRangeSelection(params.id);
+      expandMouseRowRangeSelection(params.id);
     } else {
       handleSingleRowSelection(params.id, event);
     }
-  }, [disableSelectionOnClick, canHaveMultipleSelection, checkboxSelection, apiRef, expandRowRangeSelection, handleSingleRowSelection]);
+  }, [disableSelectionOnClick, canHaveMultipleSelection, checkboxSelection, apiRef, expandMouseRowRangeSelection, handleSingleRowSelection]);
   const preventSelectionOnShift = React.useCallback((params, event) => {
     if (canHaveMultipleSelection && event.shiftKey) {
       var _window$getSelection;
@@ -274,35 +296,78 @@ const useGridSelection = (apiRef, props) => {
   }, [canHaveMultipleSelection]);
   const handleRowSelectionCheckboxChange = React.useCallback((params, event) => {
     if (event.nativeEvent.shiftKey) {
-      expandRowRangeSelection(params.id);
+      expandMouseRowRangeSelection(params.id);
     } else {
       apiRef.current.selectRow(params.id, params.value);
     }
-  }, [apiRef, expandRowRangeSelection]);
+  }, [apiRef, expandMouseRowRangeSelection]);
   const handleHeaderSelectionCheckboxChange = React.useCallback(params => {
     const shouldLimitSelectionToCurrentPage = props.checkboxSelectionVisibleOnly && props.pagination;
     const rowsToBeSelected = shouldLimitSelectionToCurrentPage ? (0, _pagination.gridPaginatedVisibleSortedGridRowIdsSelector)(apiRef) : (0, _gridFilterSelector.gridVisibleSortedRowIdsSelector)(apiRef);
     apiRef.current.selectRows(rowsToBeSelected, params.value);
   }, [apiRef, props.checkboxSelectionVisibleOnly, props.pagination]);
   const handleCellKeyDown = React.useCallback((params, event) => {
-    // Ignore portal
+    // Get the most recent cell mode because it may have been changed by another listener
+    if (apiRef.current.getCellMode(params.id, params.field) === _gridEditRowModel.GridCellModes.Edit) {
+      return;
+    } // Ignore portal
     // Do not apply shortcuts if the focus is not on the cell root component
-    // TODO replace with !event.currentTarget.contains(event.target as Element)
-    if (!(0, _domUtils.isGridCellRoot)(event.target)) {
+
+
+    if (!event.currentTarget.contains(event.target)) {
       return;
-    } // Get the most recent params because the cell mode may have changed by another listener
+    }
 
+    if ((0, _keyboardUtils.isNavigationKey)(event.key) && event.shiftKey) {
+      // The cell that has focus after the keyboard navigation
+      const focusCell = (0, _gridFocusStateSelector.gridFocusCellSelector)(apiRef);
 
-    const cellParams = apiRef.current.getCellParams(params.id, params.field);
-    const isEditMode = cellParams.cellMode === _gridEditRowModel.GridCellModes.Edit;
+      if (focusCell && focusCell.id !== params.id) {
+        event.preventDefault();
+        const isNextRowSelected = apiRef.current.isRowSelected(focusCell.id);
 
-    if (isEditMode) {
-      return;
+        if (!canHaveMultipleSelection) {
+          apiRef.current.selectRow(focusCell.id, !isNextRowSelected, true);
+          return;
+        }
+
+        const newRowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(focusCell.id);
+        const previousRowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(params.id);
+        let start;
+        let end;
+
+        if (newRowIndex > previousRowIndex) {
+          if (isNextRowSelected) {
+            // We are navigating to the bottom of the page and adding selected rows
+            start = previousRowIndex;
+            end = newRowIndex - 1;
+          } else {
+            // We are navigating to the bottom of the page and removing selected rows
+            start = previousRowIndex;
+            end = newRowIndex;
+          }
+        } else {
+          // eslint-disable-next-line no-lonely-if
+          if (isNextRowSelected) {
+            // We are navigating to the top of the page and removing selected rows
+            start = newRowIndex + 1;
+            end = previousRowIndex;
+          } else {
+            // We are navigating to the top of the page and adding selected rows
+            start = newRowIndex;
+            end = previousRowIndex;
+          }
+        }
+
+        const rowsBetweenStartAndEnd = visibleRows.rows.slice(start, end + 1).map(row => row.id);
+        apiRef.current.selectRows(rowsBetweenStartAndEnd, !isNextRowSelected);
+        return;
+      }
     }
 
     if (event.key === ' ' && event.shiftKey) {
       event.preventDefault();
-      handleSingleRowSelection(cellParams.id, event);
+      handleSingleRowSelection(params.id, event);
       return;
     }
 
@@ -310,7 +375,7 @@ const useGridSelection = (apiRef, props) => {
       event.preventDefault();
       selectRows(apiRef.current.getAllRowIds(), true);
     }
-  }, [apiRef, handleSingleRowSelection, selectRows]);
+  }, [apiRef, handleSingleRowSelection, selectRows, visibleRows.rows, canHaveMultipleSelection]);
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.visibleRowsSet, removeOutdatedSelection);
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.cellClick, handleCellClick);
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.rowSelectionCheckboxChange, handleRowSelectionCheckboxChange);
@@ -349,7 +414,7 @@ const useGridSelection = (apiRef, props) => {
     if (!canHaveMultipleSelection && currentSelection.length > 1) {
       const {
         rows: currentPageRows
-      } = (0, _useCurrentPageRows.getCurrentPageRows)(apiRef, {
+      } = (0, _useGridVisibleRows.getVisibleRows)(apiRef, {
         pagination,
         paginationMode
       });

package/node/hooks/features/selection/useGridSelectionPreProcessors.js

@@ -13,7 +13,7 @@ var React = _interopRequireWildcard(require("react"));
 
 var _material = require("@mui/material");
 
-var _preProcessing = require("../../core/preProcessing");
+var _pipeProcessing = require("../../core/pipeProcessing");
 
 var _constants = require("../../../constants");
 
@@ -60,7 +60,7 @@ const useGridSelectionPreProcessors = (apiRef, props) => {
 
     return columnsState;
   }, [apiRef, classes, props.checkboxSelection]);
-  (0, _preProcessing.useGridRegisterPreProcessor)(apiRef, 'hydrateColumns', updateSelectionColumn);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'hydrateColumns', updateSelectionColumn);
 };
 
 exports.useGridSelectionPreProcessors = useGridSelectionPreProcessors;

package/node/hooks/features/sorting/useGridSorting.js

@@ -31,11 +31,11 @@ var _rows = require("../rows");
 
 var _useFirstRender = require("../../utils/useFirstRender");
 
-var _gridSortingUtils = require("./gridSortingUtils");
+var _strategyProcessing = require("../../core/strategyProcessing");
 
-var _preProcessing = require("../../core/preProcessing");
+var _gridSortingUtils = require("./gridSortingUtils");
 
-var _useGridRegisterSortingMethod = require("./useGridRegisterSortingMethod");
+var _pipeProcessing = require("../../core/pipeProcessing");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
@@ -62,8 +62,6 @@ exports.sortingStateInitializer = sortingStateInitializer;
 
 const useGridSorting = (apiRef, props) => {
   const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridSorting');
-  const sortingMethodCollectionRef = React.useRef({});
-  const lastSortingMethodApplied = React.useRef(null);
   apiRef.current.unstable_updateControlState({
     stateId: 'sortModel',
     propModel: props.sortModel,
@@ -124,16 +122,9 @@ const useGridSorting = (apiRef, props) => {
     }
 
     apiRef.current.setState(state => {
-      const rowGroupingName = (0, _rows.gridRowGroupingNameSelector)(state, apiRef.current.instanceId);
-      const sortingMethod = sortingMethodCollectionRef.current[rowGroupingName];
-
-      if (!sortingMethod) {
-        throw new Error('MUI: Invalid sorting method.');
-      }
-
       const sortModel = (0, _gridSortingSelector.gridSortModelSelector)(state, apiRef.current.instanceId);
       const sortRowList = (0, _gridSortingUtils.buildAggregatedSortingApplier)(sortModel, apiRef);
-      const sortedRows = sortingMethod({
+      const sortedRows = apiRef.current.unstable_applyStrategyProcessor('sorting', {
         sortRowList
       });
       return (0, _extends2.default)({}, state, {
@@ -228,9 +219,9 @@ const useGridSorting = (apiRef, props) => {
     const rowTree = (0, _rows.gridRowTreeSelector)(apiRef);
     return params.sortRowList(Object.values(rowTree));
   }, [apiRef]);
-  (0, _preProcessing.useGridRegisterPreProcessor)(apiRef, 'exportState', stateExportPreProcessing);
-  (0, _preProcessing.useGridRegisterPreProcessor)(apiRef, 'restoreState', stateRestorePreProcessing);
-  (0, _useGridRegisterSortingMethod.useGridRegisterSortingMethod)(apiRef, 'none', flatSortingMethod);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'exportState', stateExportPreProcessing);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'restoreState', stateRestorePreProcessing);
+  (0, _strategyProcessing.useGridRegisterStrategyProcessor)(apiRef, _strategyProcessing.GRID_DEFAULT_STRATEGY, 'sorting', flatSortingMethod);
   /**
    * EVENTS
    */
@@ -262,15 +253,8 @@ const useGridSorting = (apiRef, props) => {
       }
     }
   }, [apiRef]);
-  const handlePreProcessorRegister = React.useCallback(name => {
-    if (name !== 'sortingMethod') {
-      return;
-    }
-
-    sortingMethodCollectionRef.current = apiRef.current.unstable_applyPreProcessors('sortingMethod', {});
-    const rowGroupingName = (0, _rows.gridRowGroupingNameSelector)(apiRef);
-
-    if (lastSortingMethodApplied.current !== sortingMethodCollectionRef.current[rowGroupingName]) {
+  const handleStrategyProcessorChange = React.useCallback(methodName => {
+    if (methodName === 'sorting') {
       apiRef.current.applySorting();
     }
   }, [apiRef]);
@@ -278,15 +262,12 @@ const useGridSorting = (apiRef, props) => {
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.columnHeaderKeyDown, handleColumnHeaderKeyDown);
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.rowsSet, apiRef.current.applySorting);
   (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.columnsChange, handleColumnsChange);
-  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.preProcessorRegister, handlePreProcessorRegister);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, _events.GridEvents.activeStrategyProcessorChange, handleStrategyProcessorChange);
   /**
    * 1ST RENDER
    */
 
   (0, _useFirstRender.useFirstRender)(() => {
-    // This line of pre-processor initialization should always come after the registration of `flatSortingMethod`
-    // Otherwise on the 1st render there would be no sorting method registered
-    sortingMethodCollectionRef.current = apiRef.current.unstable_applyPreProcessors('sortingMethod', {});
     apiRef.current.applySorting();
   });
   /**

package/node/hooks/features/statePersistence/useGridStatePersistence.js

@@ -15,11 +15,11 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 const useGridStatePersistence = apiRef => {
   const exportState = React.useCallback(() => {
-    const stateToExport = apiRef.current.unstable_applyPreProcessors('exportState', {});
+    const stateToExport = apiRef.current.unstable_applyPipeProcessors('exportState', {});
     return stateToExport;
   }, [apiRef]);
   const restoreState = React.useCallback(stateToRestore => {
-    const response = apiRef.current.unstable_applyPreProcessors('restoreState', {
+    const response = apiRef.current.unstable_applyPipeProcessors('restoreState', {
       callbacks: []
     }, {
       stateToRestore

package/node/hooks/features/virtualization/useGridVirtualScroller.js

@@ -30,7 +30,7 @@ var _gridFocusStateSelector = require("../focus/gridFocusStateSelector");
 
 var _gridEditRowsSelector = require("../editRows/gridEditRowsSelector");
 
-var _useCurrentPageRows = require("../../utils/useCurrentPageRows");
+var _useGridVisibleRows = require("../../utils/useGridVisibleRows");
 
 var _events = require("../../../models/events");
 
@@ -87,7 +87,7 @@ const useGridVirtualScroller = props => {
   const rowsMeta = (0, _useGridSelector.useGridSelector)(apiRef, _gridRowsMetaSelector.gridRowsMetaSelector);
   const editRowsState = (0, _useGridSelector.useGridSelector)(apiRef, _gridEditRowsSelector.gridEditRowsStateSelector);
   const selectedRowsLookup = (0, _useGridSelector.useGridSelector)(apiRef, _gridSelectionSelector.selectedIdsLookupSelector);
-  const currentPage = (0, _useCurrentPageRows.useCurrentPageRows)(apiRef, rootProps);
+  const currentPage = (0, _useGridVisibleRows.useGridVisibleRows)(apiRef, rootProps);
   const renderZoneRef = React.useRef(null);
   const rootRef = React.useRef(null);
   const handleRef = (0, _utils.useForkRef)(ref, rootRef);
@@ -160,7 +160,7 @@ const useGridVirtualScroller = props => {
       firstIndex: nextRenderContext.firstRowIndex,
       lastIndex: nextRenderContext.lastRowIndex,
       minFirstIndex: 0,
-      maxLastIndex: (_currentPage$range = currentPage.range) == null ? void 0 : _currentPage$range.lastRowIndex,
+      maxLastIndex: ((_currentPage$range = currentPage.range) == null ? void 0 : _currentPage$range.lastRowIndex) || 0,
       buffer: rootProps.rowBuffer
     });
     const [firstColumnToRender] = getRenderableIndexes({
@@ -221,9 +221,11 @@ const useGridVirtualScroller = props => {
 
 
     const nextRenderContext = disableVirtualization ? prevRenderContext.current : computeRenderContext();
-    const rowsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstRowIndex - prevRenderContext.current.firstRowIndex);
-    const columnsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstColumnIndex - prevRenderContext.current.firstColumnIndex);
-    const shouldSetState = rowsScrolledSincePreviousRender >= rootProps.rowThreshold || columnsScrolledSincePreviousRender >= rootProps.columnThreshold || prevTotalWidth.current !== columnsTotalWidth; // TODO v6: rename event to a wider name, it's not only fired for row scrolling
+    const topRowsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstRowIndex - prevRenderContext.current.firstRowIndex);
+    const bottomRowsScrolledSincePreviousRender = Math.abs(nextRenderContext.lastRowIndex - prevRenderContext.current.lastRowIndex);
+    const topColumnsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstColumnIndex - prevRenderContext.current.firstColumnIndex);
+    const bottomColumnsScrolledSincePreviousRender = Math.abs(nextRenderContext.lastColumnIndex - prevRenderContext.current.lastColumnIndex);
+    const shouldSetState = topRowsScrolledSincePreviousRender >= rootProps.rowThreshold || bottomRowsScrolledSincePreviousRender >= rootProps.rowThreshold || topColumnsScrolledSincePreviousRender >= rootProps.columnThreshold || bottomColumnsScrolledSincePreviousRender >= rootProps.columnThreshold || prevTotalWidth.current !== columnsTotalWidth; // TODO v6: rename event to a wider name, it's not only fired for row scrolling
 
     apiRef.current.publishEvent(_events.GridEvents.rowsScroll, {
       top: scrollTop,
@@ -305,7 +307,7 @@ const useGridVirtualScroller = props => {
         firstColumnToRender: firstColumnToRender,
         lastColumnToRender: lastColumnToRender,
         selected: isSelected,
-        index: currentPage.range.firstRowIndex + nextRenderContext.firstRowIndex + i,
+        index: currentPage.range.firstRowIndex + firstRowToRender + i,
         containerWidth: availableSpace,
         isLastVisible: lastVisibleRowIndex
       }, typeof getRowProps === 'function' ? getRowProps(id, model) : {}, (_rootProps$components = rootProps.componentsProps) == null ? void 0 : _rootProps$components.row), id));

package/node/hooks/utils/useGridApi.js

@@ -5,9 +5,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useGridApi = void 0;
 
+var _warning = require("../../utils/warning");
+
+const deprecationWarning = (0, _warning.buildWarning)(['MUI: The hook useGridApi is deprecated and will be removed in the next major version.', 'Access the ref content with apiRef.current instead']);
 /**
  * @deprecated Use `apiRef.current` instead.
  */
-const useGridApi = apiRef => apiRef.current;
+
+const useGridApi = apiRef => {
+  if (process.env.NODE_ENV !== 'production') {
+    deprecationWarning();
+  }
+
+  return apiRef.current;
+};
 
 exports.useGridApi = useGridApi;

package/node/hooks/utils/useGridSelector.js

@@ -4,17 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useGridSelector = void 0;
-let warnedOnceStateNotInitialized = false;
+
+var _warning = require("../../utils/warning");
 
 function isOutputSelector(selector) {
   return selector.cache;
 }
 
+const stateNotInitializedWarning = (0, _warning.buildWarning)(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.']);
+
 const useGridSelector = (apiRef, selector) => {
   if (process.env.NODE_ENV !== 'production') {
-    if (!warnedOnceStateNotInitialized && !apiRef.current.state) {
-      warnedOnceStateNotInitialized = true;
-      console.warn(['MUI: `useGridSelector` has been called before the initialization of the state.', 'This hook can only be used inside the context of the grid.'].join('\n'));
+    if (!apiRef.current.state) {
+      stateNotInitializedWarning();
     }
   }
 

package/node/hooks/utils/useGridState.js

@@ -5,9 +5,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useGridState = void 0;
 
+var _warning = require("../../utils/warning");
+
+const deprecationWarning = (0, _warning.buildWarning)(['MUI: The hook useGridState is deprecated and will be removed in the next major version.', 'The two lines below are equivalent', '', 'const [state, setState, forceUpdate] = useGridState(apiRef);', 'const { state, setState, forceUpdate } = apiRef.current']);
 /**
  * @deprecated Use `apiRef.current.state`, `apiRef.current.setState` and `apiRef.current.forceUpdate` instead.
  */
-const useGridState = apiRef => [apiRef.current.state, apiRef.current.setState, apiRef.current.forceUpdate];
+
+const useGridState = apiRef => {
+  if (process.env.NODE_ENV !== 'production') {
+    deprecationWarning();
+  }
+
+  return [apiRef.current.state, apiRef.current.setState, apiRef.current.forceUpdate];
+};
 
 exports.useGridState = useGridState;

package/node/hooks/utils/{useCurrentPageRows.js → useGridVisibleRows.js}

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.useCurrentPageRows = exports.getCurrentPageRows = void 0;
+exports.useGridVisibleRows = exports.getVisibleRows = void 0;
 
 var React = _interopRequireWildcard(require("react"));
 
@@ -15,7 +15,7 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const getCurrentPageRows = (apiRef, props) => {
+const getVisibleRows = (apiRef, props) => {
   let rows;
   let range;
 
@@ -41,21 +41,22 @@ const getCurrentPageRows = (apiRef, props) => {
   };
 };
 /**
- * Compute the list of the rows in the current page
- * - If the pagination is disabled or in server mode, it equals all the visible rows
- * - If the row tree has several layers, it contains up to `state.pageSize` top level rows and all their descendants
- * - If the row tree is flat, it only contains up to `state.pageSize` rows
+ * Computes the list of rows that are reachable by scroll.
+ * Depending on whether pagination is enabled, it will return the rows in the current page.
+ * - If the pagination is disabled or in server mode, it equals all the visible rows.
+ * - If the row tree has several layers, it contains up to `state.pageSize` top level rows and all their descendants.
+ * - If the row tree is flat, it only contains up to `state.pageSize` rows.
  */
 
 
-exports.getCurrentPageRows = getCurrentPageRows;
+exports.getVisibleRows = getVisibleRows;
 
-const useCurrentPageRows = (apiRef, props) => {
-  const response = getCurrentPageRows(apiRef, props);
+const useGridVisibleRows = (apiRef, props) => {
+  const response = getVisibleRows(apiRef, props);
   return React.useMemo(() => ({
     rows: response.rows,
     range: response.range
   }), [response.rows, response.range]);
 };
 
-exports.useCurrentPageRows = useCurrentPageRows;
+exports.useGridVisibleRows = useGridVisibleRows;

package/node/index.js

@@ -1,4 +1,4 @@
-/** @license MUI v5.6.0
+/** @license MUI v5.8.0
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.