@mui/x-data-grid 7.0.0-alpha.7 → 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/editing/useGridCellEditing.js

@@ -14,7 +14,7 @@ import { buildWarning } from '../../../utils/warning';
 import { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';
 import { deepClone } from '../../../utils/utils';
 import { GridCellEditStartReasons, GridCellEditStopReasons } from '../../../models/params/gridEditCellParams';
-const missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, e.g. `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see http://mui.com/components/data-grid/editing/#server-side-persistence.'], 'error');
+const missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, e.g. `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');
 export const useGridCellEditing = (apiRef, props) => {
   const [cellModesModel, setCellModesModel] = React.useState({});
   const cellModesModelRef = React.useRef(cellModesModel);
@@ -33,12 +33,12 @@ export const useGridCellEditing = (apiRef, props) => {
   const throwIfNotEditable = React.useCallback((id, field) => {
     const params = apiRef.current.getCellParams(id, field);
     if (!apiRef.current.isCellEditable(params)) {
-      throw new Error(`MUI: The cell with id=${id} and field=${field} is not editable.`);
+      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not editable.`);
     }
   }, [apiRef]);
   const throwIfNotInMode = React.useCallback((id, field, mode) => {
     if (apiRef.current.getCellMode(id, field) !== mode) {
-      throw new Error(`MUI: The cell with id=${id} and field=${field} is not in ${mode} mode.`);
+      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not in ${mode} mode.`);
     }
   }, [apiRef]);
   const handleCellDoubleClick = React.useCallback((params, event) => {
@@ -302,7 +302,7 @@ export const useGridCellEditing = (apiRef, props) => {
         });
         if (onProcessRowUpdateError) {
           onProcessRowUpdateError(errorThrown);
-        } else {
+        } else if (process.env.NODE_ENV !== 'production') {
           missingOnProcessRowUpdateErrorWarning();
         }
       };

package/modern/hooks/features/editing/useGridRowEditing.js

@@ -16,7 +16,7 @@ import { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';
 import { deepClone } from '../../../utils/utils';
 import { GridRowEditStopReasons, GridRowEditStartReasons } from '../../../models/params/gridRowParams';
 import { GRID_ACTIONS_COLUMN_TYPE } from '../../../colDef';
-const missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, e.g. `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see http://mui.com/components/data-grid/editing/#server-side-persistence.'], 'error');
+const missingOnProcessRowUpdateErrorWarning = buildWarning(['MUI X: A call to `processRowUpdate` threw an error which was not handled because `onProcessRowUpdateError` is missing.', 'To handle the error pass a callback to the `onProcessRowUpdateError` prop, e.g. `<DataGrid onProcessRowUpdateError={(error) => ...} />`.', 'For more detail, see https://mui.com/x/react-data-grid/editing/#server-side-persistence.'], 'error');
 export const useGridRowEditing = (apiRef, props) => {
   const [rowModesModel, setRowModesModel] = React.useState({});
   const rowModesModelRef = React.useRef(rowModesModel);
@@ -37,12 +37,12 @@ export const useGridRowEditing = (apiRef, props) => {
   const throwIfNotEditable = React.useCallback((id, field) => {
     const params = apiRef.current.getCellParams(id, field);
     if (!apiRef.current.isCellEditable(params)) {
-      throw new Error(`MUI: The cell with id=${id} and field=${field} is not editable.`);
+      throw new Error(`MUI X: The cell with id=${id} and field=${field} is not editable.`);
     }
   }, [apiRef]);
   const throwIfNotInMode = React.useCallback((id, mode) => {
     if (apiRef.current.getRowMode(id) !== mode) {
-      throw new Error(`MUI: The row with id=${id} is not in ${mode} mode.`);
+      throw new Error(`MUI X: The row with id=${id} is not in ${mode} mode.`);
     }
   }, [apiRef]);
   const handleCellDoubleClick = React.useCallback((params, event) => {
@@ -379,7 +379,7 @@ export const useGridRowEditing = (apiRef, props) => {
         });
         if (onProcessRowUpdateError) {
           onProcessRowUpdateError(errorThrown);
-        } else {
+        } else if (process.env.NODE_ENV !== 'production') {
           missingOnProcessRowUpdateErrorWarning();
         }
       };

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

@@ -32,7 +32,7 @@ export const serializeCellValue = (cellParams, options) => {
   }
   return sanitizeCellValue(value, delimiterCharacter);
 };
-const objectFormattedValueWarning = buildWarning(['MUI: When the value of a field is an object or a `renderCell` is provided, the CSV export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
+const objectFormattedValueWarning = buildWarning(['MUI X: When the value of a field is an object or a `renderCell` is provided, the CSV export might not display the value correctly.', 'You can provide a `valueFormatter` with a string representation to be used.']);
 class CSVRow {
   constructor(options) {
     this.options = void 0;
@@ -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/export/useGridPrintExport.js

@@ -206,7 +206,7 @@ export const useGridPrintExport = (apiRef, props) => {
   const exportDataAsPrint = React.useCallback(async options => {
     logger.debug(`Export data as Print`);
     if (!apiRef.current.rootElementRef.current) {
-      throw new Error('MUI: No grid root element available.');
+      throw new Error('MUI X: No grid root element available.');
     }
     previousGridState.current = apiRef.current.exportState();
     // It appends that the visibility model is not exported, especially if columnVisibility is not controlled

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

@@ -36,9 +36,9 @@ export const cleanFilterItem = (item, apiRef) => {
   }
   return cleanItem;
 };
-const filterModelDisableMultiColumnsFilteringWarning = buildWarning(['MUI: The `filterModel` can only contain a single item when the `disableMultipleColumnsFiltering` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
-const filterModelMissingItemIdWarning = buildWarning('MUI: The `id` field is required on `filterModel.items` when you use multiple filters.', 'error');
-const filterModelMissingItemOperatorWarning = buildWarning('MUI: The `operator` field is required on `filterModel.items`, one or more of your filtering item has no `operator` provided.', 'error');
+const filterModelDisableMultiColumnsFilteringWarning = buildWarning(['MUI X: The `filterModel` can only contain a single item when the `disableMultipleColumnsFiltering` prop is set to `true`.', 'If you are using the community version of the `DataGrid`, this prop is always `true`.'], 'error');
+const filterModelMissingItemIdWarning = buildWarning('MUI X: The `id` field is required on `filterModel.items` when you use multiple filters.', 'error');
+const filterModelMissingItemOperatorWarning = buildWarning('MUI X: The `operator` field is required on `filterModel.items`, one or more of your filtering item has no `operator` provided.', 'error');
 export const sanitizeFilterModel = (model, disableMultipleColumnsFiltering, apiRef) => {
   const hasSeveralItems = model.items.length > 1;
   let items;
@@ -103,11 +103,11 @@ const getFilterCallbackFromItem = (filterItem, apiRef) => {
   });
   const filterOperators = column.filterOperators;
   if (!filterOperators?.length) {
-    throw new Error(`MUI: No filter operators found for column '${column.field}'.`);
+    throw new Error(`MUI X: No filter operators found for column '${column.field}'.`);
   }
   const filterOperator = filterOperators.find(operator => operator.value === newFilterItem.operator);
   if (!filterOperator) {
-    throw new Error(`MUI: No filter operator found for column '${column.field}' and operator value '${newFilterItem.operator}'.`);
+    throw new Error(`MUI X: No filter operator found for column '${column.field}' and operator value '${newFilterItem.operator}'.`);
   }
   const publicApiRef = getPublicApiRef(apiRef);
   const applyFilterOnRow = filterOperator.getApplyFilterFn(newFilterItem, column);

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;