@mui/x-data-grid 5.5.1 → 5.7.0

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

@@ -0,0 +1,270 @@
+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 { isEnterKey } from '../../../utils/keyboardUtils';
+import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+import { useGridLogger } from '../../utils/useGridLogger';
+import { gridColumnLookupSelector } from '../columns/gridColumnsSelector';
+import { gridSortedRowEntriesSelector, gridSortedRowIdsSelector, gridSortModelSelector } from './gridSortingSelector';
+import { gridRowIdsSelector, gridRowTreeSelector } from '../rows';
+import { useFirstRender } from '../../utils/useFirstRender';
+import { useGridRegisterStrategyProcessor, GRID_DEFAULT_STRATEGY } from '../../core/strategyProcessing';
+import { buildAggregatedSortingApplier, mergeStateWithSortModel, getNextGridSortDirection, sanitizeSortModel } from './gridSortingUtils';
+import { useGridRegisterPreProcessor } from '../../core/preProcessing';
+export var sortingStateInitializer = function sortingStateInitializer(state, props) {
+  var _ref, _props$sortModel, _props$initialState, _props$initialState$s;
+
+  var sortModel = (_ref = (_props$sortModel = props.sortModel) != null ? _props$sortModel : (_props$initialState = props.initialState) == null ? void 0 : (_props$initialState$s = _props$initialState.sorting) == null ? void 0 : _props$initialState$s.sortModel) != null ? _ref : [];
+  return _extends({}, state, {
+    sorting: {
+      sortModel: sanitizeSortModel(sortModel, props.disableMultipleColumnsSorting),
+      sortedRows: []
+    }
+  });
+};
+/**
+ * @requires useGridRows (event)
+ * @requires useGridColumns (event)
+ */
+
+export var useGridSorting = function useGridSorting(apiRef, props) {
+  var logger = useGridLogger(apiRef, 'useGridSorting');
+  apiRef.current.unstable_updateControlState({
+    stateId: 'sortModel',
+    propModel: props.sortModel,
+    propOnChange: props.onSortModelChange,
+    stateSelector: gridSortModelSelector,
+    changeEvent: GridEvents.sortModelChange
+  });
+  var upsertSortModel = React.useCallback(function (field, sortItem) {
+    var sortModel = gridSortModelSelector(apiRef);
+    var existingIdx = sortModel.findIndex(function (c) {
+      return c.field === field;
+    });
+
+    var newSortModel = _toConsumableArray(sortModel);
+
+    if (existingIdx > -1) {
+      if (!sortItem) {
+        newSortModel.splice(existingIdx, 1);
+      } else {
+        newSortModel.splice(existingIdx, 1, sortItem);
+      }
+    } else {
+      newSortModel = [].concat(_toConsumableArray(sortModel), [sortItem]);
+    }
+
+    return newSortModel;
+  }, [apiRef]);
+  var createSortItem = React.useCallback(function (col, directionOverride) {
+    var _col$sortingOrder2;
+
+    var sortModel = gridSortModelSelector(apiRef);
+    var existing = sortModel.find(function (c) {
+      return c.field === col.field;
+    });
+
+    if (existing) {
+      var _col$sortingOrder;
+
+      var nextSort = directionOverride === undefined ? getNextGridSortDirection((_col$sortingOrder = col.sortingOrder) != null ? _col$sortingOrder : props.sortingOrder, existing.sort) : directionOverride;
+      return nextSort == null ? undefined : _extends({}, existing, {
+        sort: nextSort
+      });
+    }
+
+    return {
+      field: col.field,
+      sort: directionOverride === undefined ? getNextGridSortDirection((_col$sortingOrder2 = col.sortingOrder) != null ? _col$sortingOrder2 : props.sortingOrder) : directionOverride
+    };
+  }, [apiRef, props.sortingOrder]);
+  /**
+   * API METHODS
+   */
+
+  var applySorting = React.useCallback(function () {
+    if (props.sortingMode === GridFeatureModeConstant.server) {
+      logger.debug('Skipping sorting rows as sortingMode = server');
+      apiRef.current.setState(function (state) {
+        return _extends({}, state, {
+          sorting: _extends({}, state.sorting, {
+            sortedRows: gridRowIdsSelector(state, apiRef.current.instanceId)
+          })
+        });
+      });
+      return;
+    }
+
+    apiRef.current.setState(function (state) {
+      var sortModel = gridSortModelSelector(state, apiRef.current.instanceId);
+      var sortRowList = buildAggregatedSortingApplier(sortModel, apiRef);
+      var sortedRows = apiRef.current.unstable_applyStrategyProcessor('sorting', {
+        sortRowList: sortRowList
+      });
+      return _extends({}, state, {
+        sorting: _extends({}, state.sorting, {
+          sortedRows: sortedRows
+        })
+      });
+    });
+    apiRef.current.forceUpdate();
+  }, [apiRef, logger, props.sortingMode]);
+  var setSortModel = React.useCallback(function (model) {
+    var currentModel = gridSortModelSelector(apiRef);
+
+    if (currentModel !== model) {
+      logger.debug("Setting sort model");
+      apiRef.current.setState(mergeStateWithSortModel(model, props.disableMultipleColumnsSorting));
+      apiRef.current.forceUpdate();
+      apiRef.current.applySorting();
+    }
+  }, [apiRef, logger, props.disableMultipleColumnsSorting]);
+  var sortColumn = React.useCallback(function (column, direction, allowMultipleSorting) {
+    if (!column.sortable) {
+      return;
+    }
+
+    var sortItem = createSortItem(column, direction);
+    var sortModel;
+
+    if (!allowMultipleSorting || props.disableMultipleColumnsSorting) {
+      sortModel = !sortItem ? [] : [sortItem];
+    } else {
+      sortModel = upsertSortModel(column.field, sortItem);
+    }
+
+    apiRef.current.setSortModel(sortModel);
+  }, [apiRef, upsertSortModel, createSortItem, props.disableMultipleColumnsSorting]);
+  var getSortModel = React.useCallback(function () {
+    return gridSortModelSelector(apiRef);
+  }, [apiRef]);
+  var getSortedRows = React.useCallback(function () {
+    var sortedRows = gridSortedRowEntriesSelector(apiRef);
+    return sortedRows.map(function (row) {
+      return row.model;
+    });
+  }, [apiRef]);
+  var getSortedRowIds = React.useCallback(function () {
+    return gridSortedRowIdsSelector(apiRef);
+  }, [apiRef]);
+  var getRowIndex = React.useCallback(function (id) {
+    return apiRef.current.getSortedRowIds().indexOf(id);
+  }, [apiRef]);
+  var getRowIdFromRowIndex = React.useCallback(function (index) {
+    return apiRef.current.getSortedRowIds()[index];
+  }, [apiRef]);
+  var sortApi = {
+    getSortModel: getSortModel,
+    getSortedRows: getSortedRows,
+    getSortedRowIds: getSortedRowIds,
+    getRowIndex: getRowIndex,
+    getRowIdFromRowIndex: getRowIdFromRowIndex,
+    setSortModel: setSortModel,
+    sortColumn: sortColumn,
+    applySorting: applySorting
+  };
+  useGridApiMethod(apiRef, sortApi, 'GridSortApi');
+  /**
+   * PRE-PROCESSING
+   */
+
+  var stateExportPreProcessing = React.useCallback(function (prevState) {
+    var sortModelToExport = gridSortModelSelector(apiRef);
+
+    if (sortModelToExport.length === 0) {
+      return prevState;
+    }
+
+    return _extends({}, prevState, {
+      sorting: {
+        sortModel: sortModelToExport
+      }
+    });
+  }, [apiRef]);
+  var stateRestorePreProcessing = React.useCallback(function (params, context) {
+    var _context$stateToResto;
+
+    var sortModel = (_context$stateToResto = context.stateToRestore.sorting) == null ? void 0 : _context$stateToResto.sortModel;
+
+    if (sortModel == null) {
+      return params;
+    }
+
+    apiRef.current.setState(mergeStateWithSortModel(sortModel, props.disableMultipleColumnsSorting));
+    return _extends({}, params, {
+      callbacks: [].concat(_toConsumableArray(params.callbacks), [apiRef.current.applySorting])
+    });
+  }, [apiRef, props.disableMultipleColumnsSorting]);
+  var flatSortingMethod = React.useCallback(function (params) {
+    if (!params.sortRowList) {
+      return gridRowIdsSelector(apiRef);
+    }
+
+    var rowTree = gridRowTreeSelector(apiRef);
+    return params.sortRowList(Object.values(rowTree));
+  }, [apiRef]);
+  useGridRegisterPreProcessor(apiRef, 'exportState', stateExportPreProcessing);
+  useGridRegisterPreProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
+  useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'sorting', flatSortingMethod);
+  /**
+   * EVENTS
+   */
+
+  var handleColumnHeaderClick = React.useCallback(function (_ref2, event) {
+    var colDef = _ref2.colDef;
+    var allowMultipleSorting = event.shiftKey || event.metaKey || event.ctrlKey;
+    sortColumn(colDef, undefined, allowMultipleSorting);
+  }, [sortColumn]);
+  var handleColumnHeaderKeyDown = React.useCallback(function (_ref3, event) {
+    var colDef = _ref3.colDef;
+
+    // CTRL + Enter opens the column menu
+    if (isEnterKey(event.key) && !event.ctrlKey && !event.metaKey) {
+      sortColumn(colDef, undefined, event.shiftKey);
+    }
+  }, [sortColumn]);
+  var handleColumnsChange = React.useCallback(function () {
+    // When the columns change we check that the sorted columns are still part of the dataset
+    var sortModel = gridSortModelSelector(apiRef);
+    var latestColumns = gridColumnLookupSelector(apiRef);
+
+    if (sortModel.length > 0) {
+      var newModel = sortModel.filter(function (sortItem) {
+        return latestColumns[sortItem.field];
+      });
+
+      if (newModel.length < sortModel.length) {
+        apiRef.current.setSortModel(newModel);
+      }
+    }
+  }, [apiRef]);
+  var handleStrategyProcessorChange = React.useCallback(function (methodName) {
+    if (methodName === 'sorting') {
+      apiRef.current.applySorting();
+    }
+  }, [apiRef]);
+  useGridApiEventHandler(apiRef, GridEvents.columnHeaderClick, handleColumnHeaderClick);
+  useGridApiEventHandler(apiRef, GridEvents.columnHeaderKeyDown, handleColumnHeaderKeyDown);
+  useGridApiEventHandler(apiRef, GridEvents.rowsSet, apiRef.current.applySorting);
+  useGridApiEventHandler(apiRef, GridEvents.columnsChange, handleColumnsChange);
+  useGridApiEventHandler(apiRef, GridEvents.activeStrategyProcessorChange, handleStrategyProcessorChange);
+  /**
+   * 1ST RENDER
+   */
+
+  useFirstRender(function () {
+    apiRef.current.applySorting();
+  });
+  /**
+   * EFFECTS
+   */
+
+  React.useEffect(function () {
+    if (props.sortModel !== undefined) {
+      apiRef.current.setSortModel(props.sortModel);
+    }
+  }, [apiRef, props.sortModel]);
+};

package/legacy/hooks/features/statePersistence/gridStatePersistenceInterface.js

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

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

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

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

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { useGridApiMethod } from '../../utils';
+export var useGridStatePersistence = function useGridStatePersistence(apiRef) {
+  var exportState = React.useCallback(function () {
+    var stateToExport = apiRef.current.unstable_applyPreProcessors('exportState', {});
+    return stateToExport;
+  }, [apiRef]);
+  var restoreState = React.useCallback(function (stateToRestore) {
+    var response = apiRef.current.unstable_applyPreProcessors('restoreState', {
+      callbacks: []
+    }, {
+      stateToRestore: stateToRestore
+    });
+    response.callbacks.forEach(function (callback) {
+      callback();
+    });
+    apiRef.current.forceUpdate();
+  }, [apiRef]);
+  var statePersistenceApi = {
+    exportState: exportState,
+    restoreState: restoreState
+  };
+  useGridApiMethod(apiRef, statePersistenceApi, 'GridStatePersistenceApi');
+};

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

@@ -0,0 +1,385 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["style"];
+import * as React from 'react';
+import { useForkRef } from '@mui/material/utils';
+import { useGridApiContext } from '../../utils/useGridApiContext';
+import { useGridRootProps } from '../../utils/useGridRootProps';
+import { useGridSelector } from '../../utils/useGridSelector';
+import { gridVisibleColumnDefinitionsSelector, gridColumnsTotalWidthSelector, gridColumnPositionsSelector } from '../columns/gridColumnsSelector';
+import { gridDensityRowHeightSelector } from '../density/densitySelector';
+import { gridFocusCellSelector, gridTabIndexCellSelector } from '../focus/gridFocusStateSelector';
+import { gridEditRowsStateSelector } from '../editRows/gridEditRowsSelector';
+import { useGridVisibleRows } from '../../utils/useGridVisibleRows';
+import { GridEvents } from '../../../models/events';
+import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
+import { clamp } from '../../../utils/utils';
+import { selectedIdsLookupSelector } from '../selection/gridSelectionSelector';
+import { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';
+import { jsx as _jsx } from "react/jsx-runtime";
+// Uses binary search to avoid looping through all possible positions
+export function getIndexFromScroll(offset, positions) {
+  var sliceStart = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var sliceEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : positions.length;
+
+  if (positions.length <= 0) {
+    return -1;
+  }
+
+  if (sliceStart >= sliceEnd) {
+    return sliceStart;
+  }
+
+  var pivot = sliceStart + Math.floor((sliceEnd - sliceStart) / 2);
+  var itemOffset = positions[pivot];
+  return offset <= itemOffset ? getIndexFromScroll(offset, positions, sliceStart, pivot) : getIndexFromScroll(offset, positions, pivot + 1, sliceEnd);
+}
+export var useGridVirtualScroller = function useGridVirtualScroller(props) {
+  var _currentPage$range2;
+
+  var apiRef = useGridApiContext();
+  var rootProps = useGridRootProps();
+  var visibleColumns = useGridSelector(apiRef, gridVisibleColumnDefinitionsSelector);
+  var ref = props.ref,
+      disableVirtualization = props.disableVirtualization,
+      onRenderZonePositioning = props.onRenderZonePositioning,
+      _props$renderZoneMinC = props.renderZoneMinColumnIndex,
+      renderZoneMinColumnIndex = _props$renderZoneMinC === void 0 ? 0 : _props$renderZoneMinC,
+      _props$renderZoneMaxC = props.renderZoneMaxColumnIndex,
+      renderZoneMaxColumnIndex = _props$renderZoneMaxC === void 0 ? visibleColumns.length : _props$renderZoneMaxC,
+      getRowProps = props.getRowProps;
+  var columnPositions = useGridSelector(apiRef, gridColumnPositionsSelector);
+  var columnsTotalWidth = useGridSelector(apiRef, gridColumnsTotalWidthSelector);
+  var rowHeight = useGridSelector(apiRef, gridDensityRowHeightSelector);
+  var cellFocus = useGridSelector(apiRef, gridFocusCellSelector);
+  var cellTabIndex = useGridSelector(apiRef, gridTabIndexCellSelector);
+  var rowsMeta = useGridSelector(apiRef, gridRowsMetaSelector);
+  var editRowsState = useGridSelector(apiRef, gridEditRowsStateSelector);
+  var selectedRowsLookup = useGridSelector(apiRef, selectedIdsLookupSelector);
+  var currentPage = useGridVisibleRows(apiRef, rootProps);
+  var renderZoneRef = React.useRef(null);
+  var rootRef = React.useRef(null);
+  var handleRef = useForkRef(ref, rootRef);
+
+  var _React$useState = React.useState(null),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      renderContext = _React$useState2[0],
+      setRenderContext = _React$useState2[1];
+
+  var prevRenderContext = React.useRef(renderContext);
+  var scrollPosition = React.useRef({
+    top: 0,
+    left: 0
+  });
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      containerWidth = _React$useState4[0],
+      setContainerWidth = _React$useState4[1];
+
+  var prevTotalWidth = React.useRef(columnsTotalWidth);
+  var computeRenderContext = React.useCallback(function () {
+    if (disableVirtualization) {
+      return {
+        firstRowIndex: 0,
+        lastRowIndex: currentPage.rows.length,
+        firstColumnIndex: 0,
+        lastColumnIndex: visibleColumns.length
+      };
+    }
+
+    var _ref = scrollPosition.current,
+        top = _ref.top,
+        left = _ref.left;
+    var firstRowIndex = getIndexFromScroll(top, rowsMeta.positions);
+    var lastRowIndex = rootProps.autoHeight ? firstRowIndex + currentPage.rows.length : getIndexFromScroll(top + rootRef.current.clientHeight, rowsMeta.positions);
+    var firstColumnIndex = getIndexFromScroll(left, columnPositions);
+    var lastColumnIndex = getIndexFromScroll(left + containerWidth, columnPositions);
+    return {
+      firstRowIndex: firstRowIndex,
+      lastRowIndex: lastRowIndex,
+      firstColumnIndex: firstColumnIndex,
+      lastColumnIndex: lastColumnIndex
+    };
+  }, [disableVirtualization, rowsMeta.positions, rootProps.autoHeight, currentPage.rows.length, columnPositions, containerWidth, visibleColumns.length]);
+  React.useEffect(function () {
+    if (disableVirtualization) {
+      renderZoneRef.current.style.transform = "translate3d(0px, 0px, 0px)";
+    } else {
+      // TODO a scroll reset should not be necessary
+      rootRef.current.scrollLeft = 0;
+      rootRef.current.scrollTop = 0;
+    }
+  }, [disableVirtualization]);
+  React.useEffect(function () {
+    setContainerWidth(rootRef.current.clientWidth);
+  }, [rowsMeta.currentPageTotalHeight]);
+  var handleResize = React.useCallback(function () {
+    if (rootRef.current) {
+      setContainerWidth(rootRef.current.clientWidth);
+    }
+  }, []);
+  useGridApiEventHandler(apiRef, GridEvents.resize, handleResize);
+
+  var getRenderableIndexes = function getRenderableIndexes(_ref2) {
+    var firstIndex = _ref2.firstIndex,
+        lastIndex = _ref2.lastIndex,
+        buffer = _ref2.buffer,
+        minFirstIndex = _ref2.minFirstIndex,
+        maxLastIndex = _ref2.maxLastIndex;
+    return [clamp(firstIndex - buffer, minFirstIndex, maxLastIndex), clamp(lastIndex + buffer, minFirstIndex, maxLastIndex)];
+  };
+
+  var updateRenderZonePosition = React.useCallback(function (nextRenderContext) {
+    var _currentPage$range;
+
+    var _getRenderableIndexes = getRenderableIndexes({
+      firstIndex: nextRenderContext.firstRowIndex,
+      lastIndex: nextRenderContext.lastRowIndex,
+      minFirstIndex: 0,
+      maxLastIndex: ((_currentPage$range = currentPage.range) == null ? void 0 : _currentPage$range.lastRowIndex) || 0,
+      buffer: rootProps.rowBuffer
+    }),
+        _getRenderableIndexes2 = _slicedToArray(_getRenderableIndexes, 1),
+        firstRowToRender = _getRenderableIndexes2[0];
+
+    var _getRenderableIndexes3 = getRenderableIndexes({
+      firstIndex: nextRenderContext.firstColumnIndex,
+      lastIndex: nextRenderContext.lastColumnIndex,
+      minFirstIndex: renderZoneMinColumnIndex,
+      maxLastIndex: renderZoneMaxColumnIndex,
+      buffer: rootProps.columnBuffer
+    }),
+        _getRenderableIndexes4 = _slicedToArray(_getRenderableIndexes3, 1),
+        firstColumnToRender = _getRenderableIndexes4[0];
+
+    var top = gridRowsMetaSelector(apiRef.current.state).positions[firstRowToRender];
+    var left = gridColumnPositionsSelector(apiRef)[firstColumnToRender]; // Call directly the selector because it might be outdated when this method is called
+
+    renderZoneRef.current.style.transform = "translate3d(".concat(left, "px, ").concat(top, "px, 0px)");
+
+    if (typeof onRenderZonePositioning === 'function') {
+      onRenderZonePositioning({
+        top: top,
+        left: left
+      });
+    }
+  }, [apiRef, (_currentPage$range2 = currentPage.range) == null ? void 0 : _currentPage$range2.lastRowIndex, onRenderZonePositioning, renderZoneMaxColumnIndex, renderZoneMinColumnIndex, rootProps.columnBuffer, rootProps.rowBuffer]);
+  var updateRenderContext = React.useCallback(function (nextRenderContext) {
+    setRenderContext(nextRenderContext);
+    updateRenderZonePosition(nextRenderContext);
+    prevRenderContext.current = nextRenderContext;
+  }, [setRenderContext, prevRenderContext, updateRenderZonePosition]);
+  React.useEffect(function () {
+    if (containerWidth == null) {
+      return;
+    }
+
+    var initialRenderContext = computeRenderContext();
+    prevRenderContext.current = initialRenderContext;
+    updateRenderContext(initialRenderContext);
+    var _ref3 = scrollPosition.current,
+        top = _ref3.top,
+        left = _ref3.left;
+    var params = {
+      top: top,
+      left: left,
+      renderContext: initialRenderContext
+    };
+    apiRef.current.publishEvent(GridEvents.rowsScroll, params);
+  }, [apiRef, computeRenderContext, containerWidth, updateRenderContext]);
+
+  var handleScroll = function handleScroll(event) {
+    var _event$currentTarget = event.currentTarget,
+        scrollTop = _event$currentTarget.scrollTop,
+        scrollLeft = _event$currentTarget.scrollLeft;
+    scrollPosition.current.top = scrollTop;
+    scrollPosition.current.left = scrollLeft; // On iOS and macOS, negative offsets are possible when swiping past the start
+
+    if (scrollLeft < 0 || scrollTop < 0 || !prevRenderContext.current) {
+      return;
+    } // When virtualization is disabled, the context never changes during scroll
+
+
+    var nextRenderContext = disableVirtualization ? prevRenderContext.current : computeRenderContext();
+    var topRowsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstRowIndex - prevRenderContext.current.firstRowIndex);
+    var bottomRowsScrolledSincePreviousRender = Math.abs(nextRenderContext.lastRowIndex - prevRenderContext.current.lastRowIndex);
+    var topColumnsScrolledSincePreviousRender = Math.abs(nextRenderContext.firstColumnIndex - prevRenderContext.current.firstColumnIndex);
+    var bottomColumnsScrolledSincePreviousRender = Math.abs(nextRenderContext.lastColumnIndex - prevRenderContext.current.lastColumnIndex);
+    var 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(GridEvents.rowsScroll, {
+      top: scrollTop,
+      left: scrollLeft,
+      renderContext: shouldSetState ? nextRenderContext : prevRenderContext.current
+    });
+
+    if (shouldSetState) {
+      updateRenderContext(nextRenderContext);
+      prevTotalWidth.current = columnsTotalWidth;
+    }
+  };
+
+  var getRows = function getRows() {
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      renderContext: renderContext
+    };
+    var nextRenderContext = params.renderContext,
+        _params$minFirstColum = params.minFirstColumn,
+        minFirstColumn = _params$minFirstColum === void 0 ? renderZoneMinColumnIndex : _params$minFirstColum,
+        _params$maxLastColumn = params.maxLastColumn,
+        maxLastColumn = _params$maxLastColumn === void 0 ? renderZoneMaxColumnIndex : _params$maxLastColumn,
+        _params$availableSpac = params.availableSpace,
+        availableSpace = _params$availableSpac === void 0 ? containerWidth : _params$availableSpac;
+
+    if (!currentPage.range || !nextRenderContext || availableSpace == null) {
+      return null;
+    }
+
+    var rowBuffer = !disableVirtualization ? rootProps.rowBuffer : 0;
+    var columnBuffer = !disableVirtualization ? rootProps.columnBuffer : 0;
+
+    var _getRenderableIndexes5 = getRenderableIndexes({
+      firstIndex: nextRenderContext.firstRowIndex,
+      lastIndex: nextRenderContext.lastRowIndex,
+      minFirstIndex: 0,
+      maxLastIndex: currentPage.rows.length,
+      buffer: rowBuffer
+    }),
+        _getRenderableIndexes6 = _slicedToArray(_getRenderableIndexes5, 2),
+        firstRowToRender = _getRenderableIndexes6[0],
+        lastRowToRender = _getRenderableIndexes6[1];
+
+    var _getRenderableIndexes7 = getRenderableIndexes({
+      firstIndex: nextRenderContext.firstColumnIndex,
+      lastIndex: nextRenderContext.lastColumnIndex,
+      minFirstIndex: minFirstColumn,
+      maxLastIndex: maxLastColumn,
+      buffer: columnBuffer
+    }),
+        _getRenderableIndexes8 = _slicedToArray(_getRenderableIndexes7, 2),
+        firstColumnToRender = _getRenderableIndexes8[0],
+        lastColumnToRender = _getRenderableIndexes8[1];
+
+    var renderedRows = currentPage.rows.slice(firstRowToRender, lastRowToRender);
+    var renderedColumns = visibleColumns.slice(firstColumnToRender, lastColumnToRender);
+    var rows = [];
+
+    for (var i = 0; i < renderedRows.length; i += 1) {
+      var _rootProps$components;
+
+      var _renderedRows$i = renderedRows[i],
+          _id = _renderedRows$i.id,
+          _model = _renderedRows$i.model;
+      var lastVisibleRowIndex = firstRowToRender + i === currentPage.rows.length - 1;
+      var targetRowHeight = apiRef.current.unstable_getRowHeight(_id);
+      var isSelected = void 0;
+
+      if (selectedRowsLookup[_id] == null) {
+        isSelected = false;
+      } else if (typeof rootProps.isRowSelectable === 'function') {
+        isSelected = rootProps.isRowSelectable(apiRef.current.getRowParams(_id));
+      } else {
+        isSelected = true;
+      }
+
+      rows.push( /*#__PURE__*/_jsx(rootProps.components.Row, _extends({
+        row: _model,
+        rowId: _id,
+        rowHeight: targetRowHeight,
+        cellFocus: cellFocus // TODO move to inside the row
+        ,
+        cellTabIndex: cellTabIndex // TODO move to inside the row
+        ,
+        editRowsState: editRowsState // TODO move to inside the row
+        ,
+        renderedColumns: renderedColumns,
+        visibleColumns: visibleColumns,
+        firstColumnToRender: firstColumnToRender,
+        lastColumnToRender: lastColumnToRender,
+        selected: isSelected,
+        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));
+    }
+
+    return rows;
+  };
+
+  var needsHorizontalScrollbar = containerWidth && columnsTotalWidth > containerWidth;
+  var contentSize = React.useMemo(function () {
+    // In cases where the columns exceed the available width,
+    // the horizontal scrollbar should be shown even when there're no rows.
+    // Keeping 1px as minimum height ensures that the scrollbar will visible if necessary.
+    var height = Math.max(rowsMeta.currentPageTotalHeight, 1);
+    var shouldExtendContent = false;
+
+    if (rootRef != null && rootRef.current && height <= (rootRef == null ? void 0 : rootRef.current.clientHeight)) {
+      shouldExtendContent = true;
+    }
+
+    var size = {
+      width: needsHorizontalScrollbar ? columnsTotalWidth : 'auto',
+      height: height,
+      minHeight: shouldExtendContent ? '100%' : 'auto'
+    };
+
+    if (rootProps.autoHeight && currentPage.rows.length === 0) {
+      size.height = 2 * rowHeight; // Give room to show the overlay when there's no row.
+    }
+
+    return size;
+  }, [rootRef, columnsTotalWidth, rowsMeta.currentPageTotalHeight, currentPage.rows.length, needsHorizontalScrollbar, rootProps.autoHeight, rowHeight]);
+  React.useEffect(function () {
+    apiRef.current.publishEvent(GridEvents.virtualScrollerContentSizeChange);
+  }, [apiRef, contentSize]);
+
+  if (rootProps.autoHeight && currentPage.rows.length === 0) {
+    contentSize.height = 2 * rowHeight; // Give room to show the overlay when there no rows.
+  }
+
+  var rootStyle = {};
+
+  if (!needsHorizontalScrollbar) {
+    rootStyle.overflowX = 'hidden';
+  }
+
+  var getRenderContext = React.useCallback(function () {
+    return prevRenderContext.current;
+  }, []);
+  apiRef.current.unstable_getRenderContext = getRenderContext;
+  return {
+    renderContext: renderContext,
+    updateRenderZonePosition: updateRenderZonePosition,
+    getRows: getRows,
+    getRootProps: function getRootProps() {
+      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      var _ref4$style = _ref4.style,
+          style = _ref4$style === void 0 ? {} : _ref4$style,
+          other = _objectWithoutProperties(_ref4, _excluded);
+
+      return _extends({
+        ref: handleRef,
+        onScroll: handleScroll,
+        style: _extends({}, style, rootStyle)
+      }, other);
+    },
+    getContentProps: function getContentProps() {
+      var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          _ref5$style = _ref5.style,
+          style = _ref5$style === void 0 ? {} : _ref5$style;
+
+      return {
+        style: _extends({}, style, contentSize)
+      };
+    },
+    getRenderZoneProps: function getRenderZoneProps() {
+      return {
+        ref: renderZoneRef
+      };
+    }
+  };
+};

package/legacy/hooks/index.js

@@ -0,0 +1,3 @@
+export * from './features';
+export * from './utils';
+export * from './core';