@mui/x-data-grid 7.0.0-alpha.8 → 7.0.0-alpha.9

package/modern/hooks/features/dimensions/useGridDimensions.js

@@ -1,136 +1,94 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { unstable_debounce as debounce, unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect, unstable_ownerWindow as ownerWindow } from '@mui/utils';
+import { unstable_debounce as debounce, unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect, unstable_useEventCallback as useEventCallback, unstable_ownerWindow as ownerWindow } from '@mui/utils';
 import { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
-import { gridColumnsTotalWidthSelector } from '../columns';
+import { gridColumnsTotalWidthSelector, gridVisiblePinnedColumnDefinitionsSelector } from '../columns';
+import { gridDimensionsSelector } from './gridDimensionsSelectors';
 import { gridDensityFactorSelector } from '../density';
+import { gridRenderContextSelector } from '../virtualization';
 import { useGridSelector } from '../../utils';
 import { getVisibleRows } from '../../utils/useGridVisibleRows';
 import { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';
 import { calculatePinnedRowsHeight } from '../rows/gridRowsUtils';
 import { getTotalHeaderHeight } from '../columns/gridColumnsUtils';
-const isTestEnvironment = process.env.NODE_ENV === 'test';
-const hasScroll = ({
-  content,
-  container,
-  scrollBarSize
-}) => {
-  const hasScrollXIfNoYScrollBar = content.width > container.width;
-  const hasScrollYIfNoXScrollBar = content.height > container.height;
-  let hasScrollX = false;
-  let hasScrollY = false;
-  if (hasScrollXIfNoYScrollBar || hasScrollYIfNoXScrollBar) {
-    hasScrollX = hasScrollXIfNoYScrollBar;
-    hasScrollY = content.height + (hasScrollX ? scrollBarSize : 0) > container.height;
-
-    // We recalculate the scroll x to consider the size of the y scrollbar.
-    if (hasScrollY) {
-      hasScrollX = content.width + scrollBarSize > container.width;
-    }
-  }
-  return {
-    hasScrollX,
-    hasScrollY
-  };
+const EMPTY_SIZE = {
+  width: 0,
+  height: 0
+};
+const EMPTY_DIMENSIONS = {
+  isReady: false,
+  root: EMPTY_SIZE,
+  viewportOuterSize: EMPTY_SIZE,
+  viewportInnerSize: EMPTY_SIZE,
+  contentSize: EMPTY_SIZE,
+  minimumSize: EMPTY_SIZE,
+  hasScrollX: false,
+  hasScrollY: false,
+  scrollbarSize: 0,
+  headerHeight: 0,
+  rowWidth: 0,
+  rowHeight: 0,
+  columnsTotalWidth: 0,
+  leftPinnedWidth: 0,
+  rightPinnedWidth: 0,
+  headersTotalHeight: 0,
+  topContainerHeight: 0,
+  bottomContainerHeight: 0
+};
+export const dimensionsStateInitializer = state => {
+  const dimensions = EMPTY_DIMENSIONS;
+  return _extends({}, state, {
+    dimensions
+  });
 };
 export function useGridDimensions(apiRef, props) {
   const logger = useGridLogger(apiRef, 'useResizeContainer');
   const errorShown = React.useRef(false);
-  const rootDimensionsRef = React.useRef(null);
-  const fullDimensionsRef = React.useRef(null);
+  const rootDimensionsRef = React.useRef(EMPTY_SIZE);
   const rowsMeta = useGridSelector(apiRef, gridRowsMetaSelector);
+  const pinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);
   const densityFactor = useGridSelector(apiRef, gridDensityFactorSelector);
   const rowHeight = Math.floor(props.rowHeight * densityFactor);
-  const totalHeaderHeight = getTotalHeaderHeight(apiRef, props.columnHeaderHeight);
-  const updateGridDimensionsRef = React.useCallback(() => {
-    const rootElement = apiRef.current.rootElementRef?.current;
-    const columnsTotalWidth = gridColumnsTotalWidthSelector(apiRef);
-    const pinnedRowsHeight = calculatePinnedRowsHeight(apiRef);
-    if (!rootDimensionsRef.current) {
-      return;
-    }
-    let scrollBarSize;
-    if (props.scrollbarSize != null) {
-      scrollBarSize = props.scrollbarSize;
-    } else if (!columnsTotalWidth || !rootElement) {
-      scrollBarSize = 0;
-    } else {
-      const doc = ownerDocument(rootElement);
-      const scrollDiv = doc.createElement('div');
-      scrollDiv.style.width = '99px';
-      scrollDiv.style.height = '99px';
-      scrollDiv.style.position = 'absolute';
-      scrollDiv.style.overflow = 'scroll';
-      scrollDiv.className = 'scrollDiv';
-      rootElement.appendChild(scrollDiv);
-      scrollBarSize = scrollDiv.offsetWidth - scrollDiv.clientWidth;
-      rootElement.removeChild(scrollDiv);
-    }
-    let viewportOuterSize;
-    let hasScrollX;
-    let hasScrollY;
-    if (props.autoHeight) {
-      hasScrollY = false;
-      hasScrollX = Math.round(columnsTotalWidth) > Math.round(rootDimensionsRef.current.width);
-      viewportOuterSize = {
-        width: rootDimensionsRef.current.width,
-        height: rowsMeta.currentPageTotalHeight + (hasScrollX ? scrollBarSize : 0)
-      };
-    } else {
-      viewportOuterSize = {
-        width: rootDimensionsRef.current.width,
-        height: Math.max(rootDimensionsRef.current.height - totalHeaderHeight, 0)
-      };
-      const scrollInformation = hasScroll({
-        content: {
-          width: Math.round(columnsTotalWidth),
-          height: rowsMeta.currentPageTotalHeight
-        },
-        container: {
-          width: Math.round(viewportOuterSize.width),
-          height: viewportOuterSize.height - pinnedRowsHeight.top - pinnedRowsHeight.bottom
-        },
-        scrollBarSize
-      });
-      hasScrollY = scrollInformation.hasScrollY;
-      hasScrollX = scrollInformation.hasScrollX;
-    }
-    const viewportInnerSize = {
-      width: viewportOuterSize.width - (hasScrollY ? scrollBarSize : 0),
-      height: viewportOuterSize.height - (hasScrollX ? scrollBarSize : 0)
-    };
-    const newFullDimensions = {
-      viewportOuterSize,
-      viewportInnerSize,
-      hasScrollX,
-      hasScrollY,
-      scrollBarSize
-    };
-    const prevDimensions = fullDimensionsRef.current;
-    fullDimensionsRef.current = newFullDimensions;
-    if (newFullDimensions.viewportInnerSize.width !== prevDimensions?.viewportInnerSize.width || newFullDimensions.viewportInnerSize.height !== prevDimensions?.viewportInnerSize.height) {
-      apiRef.current.publishEvent('viewportInnerSizeChange', newFullDimensions.viewportInnerSize);
-    }
-  }, [apiRef, props.scrollbarSize, props.autoHeight, rowsMeta.currentPageTotalHeight, totalHeaderHeight]);
+  const headerHeight = Math.floor(props.columnHeaderHeight * densityFactor);
+  const columnsTotalWidth = roundToDecimalPlaces(gridColumnsTotalWidthSelector(apiRef), 6);
+  // XXX: The `props as any` below is not resilient to change.
+  const hasHeaderFilters = Boolean(props.headerFilters);
+  const headersTotalHeight = getTotalHeaderHeight(apiRef, props.columnHeaderHeight) + Number(hasHeaderFilters) * headerHeight;
+  const leftPinnedWidth = pinnedColumns.left.reduce((w, col) => w + col.computedWidth, 0);
+  const rightPinnedWidth = pinnedColumns.right.reduce((w, col) => w + col.computedWidth, 0);
   const [savedSize, setSavedSize] = React.useState();
   const debouncedSetSavedSize = React.useMemo(() => debounce(setSavedSize, 60), []);
   const previousSize = React.useRef();
-  useEnhancedEffect(() => {
-    if (savedSize) {
-      updateGridDimensionsRef();
-      apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
-    }
-  }, [apiRef, savedSize, updateGridDimensionsRef]);
-
-  // This is the function called by apiRef.current.resize()
+  const getRootDimensions = () => apiRef.current.state.dimensions;
+  const setDimensions = useEventCallback(dimensions => {
+    apiRef.current.setState(state => _extends({}, state, {
+      dimensions
+    }));
+  });
   const resize = React.useCallback(() => {
-    apiRef.current.computeSizeAndPublishResizeEvent();
+    const element = apiRef.current.mainElementRef.current;
+    if (!element) {
+      return;
+    }
+    const computedStyle = ownerWindow(element).getComputedStyle(element);
+    const height = parseFloat(computedStyle.height) || 0;
+    const width = parseFloat(computedStyle.width) || 0;
+    const hasHeightChanged = height !== previousSize.current?.height;
+    const hasWidthChanged = width !== previousSize.current?.width;
+    if (!previousSize.current || hasHeightChanged || hasWidthChanged) {
+      const size = {
+        width,
+        height
+      };
+      apiRef.current.publishEvent('resize', size);
+      previousSize.current = size;
+    }
   }, [apiRef]);
-  const getRootDimensions = React.useCallback(() => fullDimensionsRef.current, []);
   const getViewportPageSize = React.useCallback(() => {
-    const dimensions = apiRef.current.getRootDimensions();
-    if (!dimensions) {
+    const dimensions = gridDimensionsSelector(apiRef.current.state);
+    if (!dimensions.isReady) {
       return 0;
     }
     const currentPage = getVisibleRows(apiRef, {
@@ -141,44 +99,135 @@ export function useGridDimensions(apiRef, props) {
     // TODO: Use a combination of scrollTop, dimensions.viewportInnerSize.height and rowsMeta.possitions
     // to find out the maximum number of rows that can fit in the visible part of the grid
     if (props.getRowHeight) {
-      const renderContext = apiRef.current.getRenderContext();
+      const renderContext = gridRenderContextSelector(apiRef);
       const viewportPageSize = renderContext.lastRowIndex - renderContext.firstRowIndex;
       return Math.min(viewportPageSize - 1, currentPage.rows.length);
     }
     const maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);
     return Math.min(maximumPageSizeWithoutScrollBar, currentPage.rows.length);
   }, [apiRef, props.pagination, props.paginationMode, props.getRowHeight, rowHeight]);
-  const computeSizeAndPublishResizeEvent = React.useCallback(() => {
-    const mainEl = apiRef.current.mainElementRef?.current;
-    if (!mainEl) {
-      return;
-    }
-    const win = ownerWindow(mainEl);
-    const computedStyle = win.getComputedStyle(mainEl);
-    const height = parseFloat(computedStyle.height) || 0;
-    const width = parseFloat(computedStyle.width) || 0;
-    const hasHeightChanged = height !== previousSize.current?.height;
-    const hasWidthChanged = width !== previousSize.current?.width;
-    if (!previousSize.current || hasHeightChanged || hasWidthChanged) {
-      const size = {
-        width,
-        height
+  const updateDimensions = React.useCallback(() => {
+    const rootElement = apiRef.current.rootElementRef.current;
+    const pinnedRowsHeight = calculatePinnedRowsHeight(apiRef);
+    const scrollbarSize = measureScrollbarSize(rootElement, columnsTotalWidth, props.scrollbarSize);
+    const topContainerHeight = headersTotalHeight + pinnedRowsHeight.top;
+    const bottomContainerHeight = pinnedRowsHeight.bottom;
+    const contentSize = {
+      width: columnsTotalWidth,
+      height: rowsMeta.currentPageTotalHeight
+    };
+    let viewportOuterSize;
+    let viewportInnerSize;
+    let hasScrollX = false;
+    let hasScrollY = false;
+    if (props.autoHeight) {
+      hasScrollY = false;
+      hasScrollX = Math.round(columnsTotalWidth) > Math.round(rootDimensionsRef.current.width);
+      viewportOuterSize = {
+        width: rootDimensionsRef.current.width,
+        height: topContainerHeight + bottomContainerHeight + contentSize.height
       };
-      apiRef.current.publishEvent('resize', size);
-      previousSize.current = size;
+      viewportInnerSize = {
+        width: Math.max(0, viewportOuterSize.width - (hasScrollY ? scrollbarSize : 0)),
+        height: Math.max(0, viewportOuterSize.height - (hasScrollX ? scrollbarSize : 0))
+      };
+    } else {
+      viewportOuterSize = {
+        width: rootDimensionsRef.current.width,
+        height: rootDimensionsRef.current.height
+      };
+      viewportInnerSize = {
+        width: Math.max(0, viewportOuterSize.width - leftPinnedWidth - rightPinnedWidth),
+        height: Math.max(0, viewportOuterSize.height - topContainerHeight - bottomContainerHeight)
+      };
+      const content = contentSize;
+      const container = viewportInnerSize;
+      const hasScrollXIfNoYScrollBar = content.width > container.width;
+      const hasScrollYIfNoXScrollBar = content.height > container.height;
+      if (hasScrollXIfNoYScrollBar || hasScrollYIfNoXScrollBar) {
+        hasScrollY = hasScrollYIfNoXScrollBar;
+        hasScrollX = content.width + (hasScrollY ? scrollbarSize : 0) > container.width;
+
+        // We recalculate the scroll y to consider the size of the x scrollbar.
+        if (hasScrollX) {
+          hasScrollY = content.height + scrollbarSize > container.height;
+        }
+      }
+      if (hasScrollY) {
+        viewportInnerSize.width -= scrollbarSize;
+      }
+      if (hasScrollX) {
+        viewportInnerSize.height -= scrollbarSize;
+      }
     }
-  }, [apiRef]);
-  const dimensionsApi = {
+    const rowWidth = Math.max(viewportOuterSize.width, columnsTotalWidth + (hasScrollY ? scrollbarSize : 0));
+    const minimumSize = {
+      width: contentSize.width,
+      height: topContainerHeight + contentSize.height + bottomContainerHeight
+    };
+    const newDimensions = {
+      isReady: true,
+      root: rootDimensionsRef.current,
+      viewportOuterSize,
+      viewportInnerSize,
+      contentSize,
+      minimumSize,
+      hasScrollX,
+      hasScrollY,
+      scrollbarSize,
+      headerHeight,
+      rowWidth,
+      rowHeight,
+      columnsTotalWidth,
+      leftPinnedWidth,
+      rightPinnedWidth,
+      headersTotalHeight,
+      topContainerHeight,
+      bottomContainerHeight
+    };
+    const prevDimensions = apiRef.current.state.dimensions;
+    setDimensions(newDimensions);
+    if (newDimensions.viewportInnerSize.width !== prevDimensions.viewportInnerSize.width || newDimensions.viewportInnerSize.height !== prevDimensions.viewportInnerSize.height) {
+      apiRef.current.publishEvent('viewportInnerSizeChange', newDimensions.viewportInnerSize);
+    }
+    apiRef.current.updateRenderContext?.();
+  }, [apiRef, setDimensions, props.scrollbarSize, props.autoHeight, rowsMeta.currentPageTotalHeight, rowHeight, headerHeight, columnsTotalWidth, headersTotalHeight, leftPinnedWidth, rightPinnedWidth]);
+  const apiPublic = {
     resize,
     getRootDimensions
   };
-  const dimensionsPrivateApi = {
-    getViewportPageSize,
-    updateGridDimensionsRef,
-    computeSizeAndPublishResizeEvent
+  const apiPrivate = {
+    updateDimensions,
+    getViewportPageSize
   };
-  useGridApiMethod(apiRef, dimensionsApi, 'public');
-  useGridApiMethod(apiRef, dimensionsPrivateApi, 'private');
+  useGridApiMethod(apiRef, apiPublic, 'public');
+  useGridApiMethod(apiRef, apiPrivate, 'private');
+  useEnhancedEffect(() => {
+    if (savedSize) {
+      updateDimensions();
+      apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
+    }
+  }, [apiRef, savedSize, updateDimensions]);
+  const root = apiRef.current.rootElementRef.current;
+  const dimensions = apiRef.current.state.dimensions;
+  useEnhancedEffect(() => {
+    if (!root) {
+      return;
+    }
+    const set = (k, v) => root.style.setProperty(k, v);
+    set('--DataGrid-width', `${dimensions.viewportOuterSize.width}px`);
+    set('--DataGrid-hasScrollX', `${Number(dimensions.hasScrollX)}`);
+    set('--DataGrid-hasScrollY', `${Number(dimensions.hasScrollY)}`);
+    set('--DataGrid-scrollbarSize', `${dimensions.scrollbarSize}px`);
+    set('--DataGrid-rowWidth', `${dimensions.rowWidth}px`);
+    set('--DataGrid-columnsTotalWidth', `${dimensions.columnsTotalWidth}px`);
+    set('--DataGrid-leftPinnedWidth', `${dimensions.leftPinnedWidth}px`);
+    set('--DataGrid-rightPinnedWidth', `${dimensions.rightPinnedWidth}px`);
+    set('--DataGrid-headerHeight', `${dimensions.headerHeight}px`);
+    set('--DataGrid-headersTotalHeight', `${dimensions.headersTotalHeight}px`);
+    set('--DataGrid-topContainerHeight', `${dimensions.topContainerHeight}px`);
+    set('--DataGrid-bottomContainerHeight', `${dimensions.bottomContainerHeight}px`);
+  }, [root, dimensions]);
   const isFirstSizing = React.useRef(true);
   const handleResize = React.useCallback(size => {
     rootDimensionsRef.current = size;
@@ -193,12 +242,6 @@ export function useGridDimensions(apiRef, props) {
       logger.error(['The parent DOM element of the data grid has an empty width.', 'Please make sure that this element has an intrinsic width.', 'The grid displays with a width of 0px.', '', 'More details: https://mui.com/r/x-data-grid-no-dimensions.'].join('\n'));
       errorShown.current = true;
     }
-    if (isTestEnvironment) {
-      // We don't need to debounce the resize for tests.
-      setSavedSize(size);
-      isFirstSizing.current = false;
-      return;
-    }
     if (isFirstSizing.current) {
       // We want to initialize the grid dimensions as soon as possible to avoid flickering
       setSavedSize(size);
@@ -207,10 +250,35 @@ export function useGridDimensions(apiRef, props) {
     }
     debouncedSetSavedSize(size);
   }, [props.autoHeight, debouncedSetSavedSize, logger]);
-  useEnhancedEffect(() => updateGridDimensionsRef(), [updateGridDimensionsRef]);
-  useGridApiOptionHandler(apiRef, 'sortedRowsSet', updateGridDimensionsRef);
-  useGridApiOptionHandler(apiRef, 'paginationModelChange', updateGridDimensionsRef);
-  useGridApiOptionHandler(apiRef, 'columnsChange', updateGridDimensionsRef);
+  useEnhancedEffect(updateDimensions, [updateDimensions]);
+  useGridApiOptionHandler(apiRef, 'sortedRowsSet', updateDimensions);
+  useGridApiOptionHandler(apiRef, 'paginationModelChange', updateDimensions);
+  useGridApiOptionHandler(apiRef, 'columnsChange', updateDimensions);
   useGridApiEventHandler(apiRef, 'resize', handleResize);
   useGridApiOptionHandler(apiRef, 'debouncedResize', props.onResize);
+}
+function measureScrollbarSize(rootElement, columnsTotalWidth, scrollbarSize) {
+  if (scrollbarSize !== undefined) {
+    return scrollbarSize;
+  }
+  if (rootElement === null || columnsTotalWidth === 0) {
+    return 0;
+  }
+  const doc = ownerDocument(rootElement);
+  const scrollDiv = doc.createElement('div');
+  scrollDiv.style.width = '99px';
+  scrollDiv.style.height = '99px';
+  scrollDiv.style.position = 'absolute';
+  scrollDiv.style.overflow = 'scroll';
+  scrollDiv.className = 'scrollDiv';
+  rootElement.appendChild(scrollDiv);
+  const size = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+  rootElement.removeChild(scrollDiv);
+  return size;
+}
+
+// Get rid of floating point imprecision errors
+// https://github.com/mui/mui-x/issues/9550#issuecomment-1619020477
+function roundToDecimalPlaces(value, decimals) {
+  return Math.round(value * 10 ** decimals) / 10 ** decimals;
 }

package/modern/hooks/features/export/serializers/csvSerializer.js

@@ -104,10 +104,10 @@ export function buildCSV(options) {
   const filteredColumns = columns.filter(column => column.field !== GRID_CHECKBOX_SELECTION_COL_DEF.field);
   const headerRows = [];
   if (includeColumnGroupsHeaders) {
-    const columnGroupLookup = apiRef.current.unstable_getAllGroupDetails();
+    const columnGroupLookup = apiRef.current.getAllGroupDetails();
     let maxColumnGroupsDepth = 0;
     const columnGroupPathsLookup = filteredColumns.reduce((acc, column) => {
-      const columnGroupPath = apiRef.current.unstable_getColumnGroupPath(column.field);
+      const columnGroupPath = apiRef.current.getColumnGroupPath(column.field);
       acc[column.field] = columnGroupPath;
       maxColumnGroupsDepth = Math.max(maxColumnGroupsDepth, columnGroupPath.length);
       return acc;

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

@@ -6,7 +6,7 @@ import { useLazyRef } from '../../utils/useLazyRef';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
-import { gridFilterableColumnLookupSelector } from '../columns/gridColumnsSelector';
+import { gridColumnLookupSelector } from '../columns/gridColumnsSelector';
 import { GridPreferencePanelsValue } from '../preferencesPanel/gridPreferencePanelsValue';
 import { getDefaultGridFilterModel } from './gridFilterState';
 import { gridFilterModelSelector } from './gridFilterSelector';
@@ -309,8 +309,8 @@ export const useGridFilter = (apiRef, props) => {
   const handleColumnsChange = React.useCallback(() => {
     logger.debug('onColUpdated - GridColumns changed, applying filters');
     const filterModel = gridFilterModelSelector(apiRef);
-    const filterableColumnsLookup = gridFilterableColumnLookupSelector(apiRef);
-    const newFilterItems = filterModel.items.filter(item => item.field && filterableColumnsLookup[item.field]);
+    const columnsLookup = gridColumnLookupSelector(apiRef);
+    const newFilterItems = filterModel.items.filter(item => item.field && columnsLookup[item.field]);
     if (newFilterItems.length < filterModel.items.length) {
       apiRef.current.setFilterModel(_extends({}, filterModel, {
         items: newFilterItems

package/modern/hooks/features/focus/gridFocusStateSelector.js

@@ -3,13 +3,9 @@ export const gridFocusStateSelector = state => state.focus;
 export const gridFocusCellSelector = createSelector(gridFocusStateSelector, focusState => focusState.cell);
 export const gridFocusColumnHeaderSelector = createSelector(gridFocusStateSelector, focusState => focusState.columnHeader);
 export const gridFocusColumnHeaderFilterSelector = createSelector(gridFocusStateSelector, focusState => focusState.columnHeaderFilter);
-
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export const unstable_gridFocusColumnGroupHeaderSelector = createSelector(gridFocusStateSelector, focusState => focusState.columnGroupHeader);
+export const gridFocusColumnGroupHeaderSelector = createSelector(gridFocusStateSelector, focusState => focusState.columnGroupHeader);
 export const gridTabIndexStateSelector = state => state.tabIndex;
 export const gridTabIndexCellSelector = createSelector(gridTabIndexStateSelector, state => state.cell);
 export const gridTabIndexColumnHeaderSelector = createSelector(gridTabIndexStateSelector, state => state.columnHeader);
 export const gridTabIndexColumnHeaderFilterSelector = createSelector(gridTabIndexStateSelector, state => state.columnHeaderFilter);
-
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export const unstable_gridTabIndexColumnGroupHeaderSelector = createSelector(gridTabIndexStateSelector, state => state.columnGroupHeader);
+export const gridTabIndexColumnGroupHeaderSelector = createSelector(gridTabIndexStateSelector, state => state.columnGroupHeader);

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

@@ -6,7 +6,7 @@ import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
 import { isNavigationKey } from '../../../utils/keyboardUtils';
-import { gridFocusCellSelector, unstable_gridFocusColumnGroupHeaderSelector } from './gridFocusStateSelector';
+import { gridFocusCellSelector, gridFocusColumnGroupHeaderSelector } from './gridFocusStateSelector';
 import { gridVisibleColumnDefinitionsSelector } from '../columns/gridColumnsSelector';
 import { getVisibleRows } from '../../utils/useGridVisibleRows';
 import { clamp } from '../../../utils/utils';
@@ -164,7 +164,7 @@ export const useGridFocus = (apiRef, props) => {
     });
     apiRef.current.forceUpdate();
   }, [apiRef]);
-  const getColumnGroupHeaderFocus = React.useCallback(() => unstable_gridFocusColumnGroupHeaderSelector(apiRef), [apiRef]);
+  const getColumnGroupHeaderFocus = React.useCallback(() => gridFocusColumnGroupHeaderSelector(apiRef), [apiRef]);
   const moveFocusToRelativeCell = React.useCallback((id, field, direction) => {
     let columnIndexToFocus = apiRef.current.getColumnIndex(field);
     const visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);
@@ -244,7 +244,7 @@ export const useGridFocus = (apiRef, props) => {
     if (event.target !== event.currentTarget) {
       return;
     }
-    const focusedColumnGroup = unstable_gridFocusColumnGroupHeaderSelector(apiRef);
+    const focusedColumnGroup = gridFocusColumnGroupHeaderSelector(apiRef);
     if (focusedColumnGroup !== null && focusedColumnGroup.depth === depth && fields.includes(focusedColumnGroup.field)) {
       // This group cell has already been focused
       return;

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

@@ -11,7 +11,7 @@ import { GridCellModes } from '../../../models/gridEditRowModel';
 import { isNavigationKey } from '../../../utils/keyboardUtils';
 import { GRID_DETAIL_PANEL_TOGGLE_FIELD } from '../../../constants/gridDetailPanelToggleField';
 import { gridPinnedRowsSelector } from '../rows/gridRowsSelector';
-import { unstable_gridFocusColumnGroupHeaderSelector } from '../focus';
+import { gridFocusColumnGroupHeaderSelector } from '../focus';
 import { gridColumnGroupsHeaderMaxDepthSelector } from '../columnGrouping/gridColumnGroupsSelector';
 import { gridHeaderFilteringEditFieldSelector, gridHeaderFilteringMenuSelector } from '../headerFiltering/gridHeaderFilteringSelectors';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
@@ -137,10 +137,6 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
       // There is one exception for the checkBoxHeader
       return;
     }
-    const dimensions = apiRef.current.getRootDimensions();
-    if (!dimensions) {
-      return;
-    }
     const viewportPageSize = apiRef.current.getViewportPageSize();
     const colIndexBefore = params.field ? apiRef.current.getColumnIndex(params.field) : 0;
     const firstRowIndexInPage = currentPageRows.length > 0 ? 0 : null;
@@ -233,10 +229,6 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
     }
   }, [apiRef, currentPageRows.length, headerFilteringEnabled, goToHeaderFilter, goToCell, getRowIdFromIndex, theme.direction, goToHeader, goToGroupHeader]);
   const handleHeaderFilterKeyDown = React.useCallback((params, event) => {
-    const dimensions = apiRef.current.getRootDimensions();
-    if (!dimensions) {
-      return;
-    }
     const isEditing = gridHeaderFilteringEditFieldSelector(apiRef) === params.field;
     const isHeaderMenuOpen = gridHeaderFilteringMenuSelector(apiRef) === params.field;
     if (isEditing || isHeaderMenuOpen || !isNavigationKey(event.key)) {
@@ -323,11 +315,7 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
     }
   }, [apiRef, currentPageRows.length, goToHeaderFilter, theme.direction, goToHeader, goToCell, getRowIdFromIndex]);
   const handleColumnGroupHeaderKeyDown = React.useCallback((params, event) => {
-    const dimensions = apiRef.current.getRootDimensions();
-    if (!dimensions) {
-      return;
-    }
-    const focusedColumnGroup = unstable_gridFocusColumnGroupHeaderSelector(apiRef);
+    const focusedColumnGroup = gridFocusColumnGroupHeaderSelector(apiRef);
     if (focusedColumnGroup === null) {
       return;
     }
@@ -430,8 +418,7 @@ export const useGridKeyboardNavigation = (apiRef, props) => {
     if (!canUpdateFocus) {
       return;
     }
-    const dimensions = apiRef.current.getRootDimensions();
-    if (currentPageRows.length === 0 || !dimensions) {
+    if (currentPageRows.length === 0) {
       return;
     }
     const direction = theme.direction;

package/modern/hooks/features/pagination/useGridPagination.js

@@ -5,7 +5,6 @@ import { gridDensityFactorSelector } from '../density';
 import { useGridLogger, useGridSelector, useGridApiMethod, useGridApiEventHandler } from '../../utils';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
 import { gridPaginationModelSelector } from './gridPaginationSelector';
-import { calculatePinnedRowsHeight } from '../rows/gridRowsUtils';
 import { getPageCount, noRowCountInServerMode, defaultPageSize, throwIfPageSizeExceedsTheLimit, getDefaultGridPaginationModel, getValidPage } from './gridPaginationUtils';
 export const paginationStateInitializer = (state, props) => {
   const paginationModel = _extends({}, getDefaultGridPaginationModel(props.autoPageSize), props.paginationModel ?? props.initialState?.pagination?.paginationModel);
@@ -137,12 +136,11 @@ export const useGridPagination = (apiRef, props) => {
     apiRef.current.forceUpdate();
   };
   const handleUpdateAutoPageSize = React.useCallback(() => {
-    const dimensions = apiRef.current.getRootDimensions();
-    if (!props.autoPageSize || !dimensions) {
+    if (!props.autoPageSize) {
       return;
     }
-    const pinnedRowsHeight = calculatePinnedRowsHeight(apiRef);
-    const maximumPageSizeWithoutScrollBar = Math.floor((dimensions.viewportInnerSize.height - pinnedRowsHeight.top - pinnedRowsHeight.bottom) / rowHeight);
+    const dimensions = apiRef.current.getRootDimensions();
+    const maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);
     apiRef.current.setPageSize(maximumPageSizeWithoutScrollBar);
   }, [apiRef, props.autoPageSize, rowHeight]);
   useGridApiEventHandler(apiRef, 'viewportInnerSizeChange', handleUpdateAutoPageSize);

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

@@ -33,11 +33,11 @@ export const gridPinnedRowsSelector = createSelectorMemoized(gridAdditionalRowGr
     bottom: rawPinnedRows?.bottom?.map(rowEntry => ({
       id: rowEntry.id,
       model: rowEntry.model ?? {}
-    })),
+    })) ?? [],
     top: rawPinnedRows?.top?.map(rowEntry => ({
       id: rowEntry.id,
       model: rowEntry.model ?? {}
-    }))
+    })) ?? []
   };
 });
 

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

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { gridPinnedRowsSelector } from './gridRowsSelector';
-import { gridDensityFactorSelector } from '../density/densitySelector';
+import { gridDimensionsSelector } from '../dimensions';
 export const GRID_ROOT_GROUP_ID = `auto-generated-group-node-root`;
 export const GRID_ID_AUTOGENERATED = Symbol('mui.id_autogenerated');
 export const buildRootGroup = () => ({
@@ -275,7 +275,7 @@ export function calculatePinnedRowsHeight(apiRef) {
     bottom: bottomPinnedRowsHeight
   };
 }
-export function getMinimalContentHeight(apiRef, rowHeight) {
-  const densityFactor = gridDensityFactorSelector(apiRef);
-  return `var(--DataGrid-overlayHeight, ${2 * Math.floor(rowHeight * densityFactor)}px)`;
+export function getMinimalContentHeight(apiRef) {
+  const dimensions = gridDimensionsSelector(apiRef.current.state);
+  return `var(--DataGrid-overlayHeight, ${2 * dimensions.rowHeight}px)`;
 }

package/modern/hooks/features/rows/useGridRowsMeta.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { unstable_debounce as debounce, unstable_capitalize as capitalize } from '@mui/utils';
+import { unstable_debounce as debounce } from '@mui/utils';
 import { useGridVisibleRows } from '../../utils/useGridVisibleRows';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridSelector } from '../../utils/useGridSelector';
@@ -11,6 +11,9 @@ import { gridSortModelSelector } from '../sorting/gridSortingSelector';
 import { useGridRegisterPipeApplier } from '../../core/pipeProcessing';
 import { gridPinnedRowsSelector } from './gridRowsSelector';
 import { DATA_GRID_PROPS_DEFAULT_VALUES } from '../../../DataGrid/useDataGridProps';
+
+// TODO: I think the row heights can now be encoded as a single `size` instead of `sizes.baseXxxx`
+
 export const rowsMetaStateInitializer = state => _extends({}, state, {
   rowsMeta: {
     currentPageTotalHeight: 0,
@@ -174,15 +177,15 @@ export const useGridRowsMeta = (apiRef, props) => {
     hydrateRowsMeta();
   }, [hydrateRowsMeta]);
   const debouncedHydrateRowsMeta = React.useMemo(() => debounce(hydrateRowsMeta, props.rowPositionsDebounceMs), [hydrateRowsMeta, props.rowPositionsDebounceMs]);
-  const storeMeasuredRowHeight = React.useCallback((id, height, position) => {
+  const storeMeasuredRowHeight = React.useCallback((id, height) => {
     if (!rowsHeightLookup.current[id] || !rowsHeightLookup.current[id].autoHeight) {
       return;
     }
 
     // Only trigger hydration if the value is different, otherwise we trigger a loop
-    const needsHydration = rowsHeightLookup.current[id].sizes[`base${capitalize(position)}`] !== height;
+    const needsHydration = rowsHeightLookup.current[id].sizes.baseCenter !== height;
     rowsHeightLookup.current[id].needsFirstMeasurement = false;
-    rowsHeightLookup.current[id].sizes[`base${capitalize(position)}`] = height;
+    rowsHeightLookup.current[id].sizes.baseCenter = height;
     if (needsHydration) {
       debouncedHydrateRowsMeta();
     }