@mui/x-data-grid 6.7.0 → 6.8.0

package/modern/components/cell/GridCell.js

@@ -1,30 +1,48 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["align", "children", "colIndex", "colDef", "cellMode", "field", "formattedValue", "hasFocus", "height", "isEditable", "isSelected", "rowId", "tabIndex", "value", "width", "className", "showRightBorder", "extendRowFullWidth", "row", "colSpan", "disableDragEvents", "onClick", "onDoubleClick", "onMouseDown", "onMouseUp", "onMouseOver", "onKeyDown", "onKeyUp", "onDragEnter", "onDragOver"];
+const _excluded = ["changeReason", "unstable_updateValueOnRender"],
+  _excluded2 = ["align", "children", "colIndex", "column", "cellMode", "field", "formattedValue", "hasFocus", "height", "isEditable", "isSelected", "rowId", "tabIndex", "value", "width", "className", "showRightBorder", "extendRowFullWidth", "row", "colSpan", "disableDragEvents", "onClick", "onDoubleClick", "onMouseDown", "onMouseUp", "onMouseOver", "onKeyDown", "onKeyUp", "onDragEnter", "onDragOver"],
+  _excluded3 = ["column", "rowId", "editCellState", "align", "children", "colIndex", "height", "width", "className", "showRightBorder", "extendRowFullWidth", "row", "colSpan", "disableDragEvents", "onClick", "onDoubleClick", "onMouseDown", "onMouseUp", "onMouseOver", "onKeyDown", "onKeyUp", "onDragEnter", "onDragOver"],
+  _excluded4 = ["changeReason", "unstable_updateValueOnRender"];
 /* eslint-disable jsx-a11y/no-noninteractive-element-interactions */
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import clsx from 'clsx';
 import { unstable_useForkRef as useForkRef, unstable_composeClasses as composeClasses, unstable_ownerDocument as ownerDocument, unstable_capitalize as capitalize } from '@mui/utils';
-import { getDataGridUtilityClass } from '../../constants/gridClasses';
+import { fastMemo } from '../../utils/fastMemo';
+import { doesSupportPreventScroll } from '../../utils/doesSupportPreventScroll';
+import { getDataGridUtilityClass, gridClasses } from '../../constants/gridClasses';
 import { GridCellModes } from '../../models';
+import { useGridSelector, objectShallowCompare } from '../../hooks/utils/useGridSelector';
 import { useGridApiContext } from '../../hooks/utils/useGridApiContext';
 import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
 import { gridFocusCellSelector } from '../../hooks/features/focus/gridFocusStateSelector';
+import { MissingRowIdError } from '../../hooks/features/rows/useGridParamsApi';
 import { jsx as _jsx } from "react/jsx-runtime";
-// Based on https://stackoverflow.com/a/59518678
-let cachedSupportsPreventScroll;
-function doesSupportPreventScroll() {
-  if (cachedSupportsPreventScroll === undefined) {
-    document.createElement('div').focus({
-      get preventScroll() {
-        cachedSupportsPreventScroll = true;
-        return false;
-      }
-    });
-  }
-  return cachedSupportsPreventScroll;
-}
+const EMPTY_CELL_PARAMS = {
+  id: -1,
+  field: '__unset__',
+  row: {},
+  rowNode: {
+    id: -1,
+    depth: 0,
+    type: 'leaf',
+    parent: -1,
+    groupingKey: null
+  },
+  colDef: {
+    type: 'string',
+    field: '__unset__',
+    computedWidth: 0
+  },
+  cellMode: GridCellModes.View,
+  hasFocus: false,
+  tabIndex: -1,
+  value: null,
+  formattedValue: '__unset__',
+  isEditable: false,
+  api: {}
+};
 const useUtilityClasses = ownerState => {
   const {
     align,
@@ -40,11 +58,109 @@ const useUtilityClasses = ownerState => {
   return composeClasses(slots, getDataGridUtilityClass, classes);
 };
 let warnedOnce = false;
+
+// GridCellWrapper is a compatibility layer for the V6 cell slot. If we can use the more efficient
+// `GridCellV7`, we should. That component is a merge of `GridCellWrapper` and `GridCell`.
+// TODO(v7): Remove the wrapper & cellV6 and use the cellV7 exclusively.
+// TODO(v7): Removing the wrapper will break the docs performance visualization demo.
+const GridCellWrapper = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    column,
+    rowId,
+    editCellState
+  } = props;
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const field = column.field;
+  const cellParamsWithAPI = useGridSelector(apiRef, () => {
+    // This is required because `.getCellParams` tries to get the `state.rows.tree` entry
+    // associated with `rowId`/`fieldId`, but this selector runs after the state has been
+    // updated, while `rowId`/`fieldId` reference an entry in the old state.
+    try {
+      const cellParams = apiRef.current.getCellParams(rowId, field);
+      const result = cellParams;
+      result.api = apiRef.current;
+      return result;
+    } catch (e) {
+      if (e instanceof MissingRowIdError) {
+        return EMPTY_CELL_PARAMS;
+      }
+      throw e;
+    }
+  }, objectShallowCompare);
+  const isSelected = useGridSelector(apiRef, () => apiRef.current.unstable_applyPipeProcessors('isCellSelected', false, {
+    id: rowId,
+    field
+  }));
+  if (cellParamsWithAPI === EMPTY_CELL_PARAMS) {
+    return null;
+  }
+  const {
+    cellMode,
+    hasFocus,
+    isEditable,
+    value,
+    formattedValue
+  } = cellParamsWithAPI;
+  const managesOwnFocus = column.type === 'actions';
+  const tabIndex = (cellMode === 'view' || !isEditable) && !managesOwnFocus ? cellParamsWithAPI.tabIndex : -1;
+  const {
+    classes: rootClasses,
+    getCellClassName
+  } = rootProps;
+  const classNames = apiRef.current.unstable_applyPipeProcessors('cellClassName', [], {
+    id: rowId,
+    field
+  });
+  if (column.cellClassName) {
+    classNames.push(typeof column.cellClassName === 'function' ? column.cellClassName(cellParamsWithAPI) : column.cellClassName);
+  }
+  if (getCellClassName) {
+    classNames.push(getCellClassName(cellParamsWithAPI));
+  }
+  let children;
+  if (editCellState == null && column.renderCell) {
+    children = column.renderCell(cellParamsWithAPI);
+    classNames.push(gridClasses['cell--withRenderer']);
+    classNames.push(rootClasses?.['cell--withRenderer']);
+  }
+  if (editCellState != null && column.renderEditCell) {
+    const updatedRow = apiRef.current.getRowWithUpdatedValues(rowId, column.field);
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const editCellStateRest = _objectWithoutPropertiesLoose(editCellState, _excluded);
+    const params = _extends({}, cellParamsWithAPI, {
+      row: updatedRow
+    }, editCellStateRest);
+    children = column.renderEditCell(params);
+    classNames.push(gridClasses['cell--editing']);
+    classNames.push(rootClasses?.['cell--editing']);
+  }
+  const {
+    slots
+  } = rootProps;
+  const CellComponent = slots.cell;
+  const cellProps = _extends({}, props, {
+    ref,
+    field,
+    formattedValue,
+    hasFocus,
+    isEditable,
+    isSelected,
+    value,
+    cellMode,
+    children,
+    tabIndex,
+    className: clsx(classNames)
+  });
+  return /*#__PURE__*/React.createElement(CellComponent, cellProps);
+});
 const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
   const {
       align,
-      children,
+      children: childrenProp,
       colIndex,
+      column,
       cellMode,
       field,
       formattedValue,
@@ -70,7 +186,7 @@ const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
       onDragEnter,
       onDragOver
     } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
+    other = _objectWithoutPropertiesLoose(props, _excluded2);
   const valueToRender = formattedValue == null ? value : formattedValue;
   const cellRef = React.useRef(null);
   const handleRef = useForkRef(ref, cellRef);
@@ -152,24 +268,21 @@ const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
       }
     };
   }
-  const column = apiRef.current.getColumn(field);
   const managesOwnFocus = column.type === 'actions';
-  const renderChildren = () => {
-    if (children === undefined) {
-      const valueString = valueToRender?.toString();
-      return /*#__PURE__*/_jsx("div", {
-        className: classes.content,
-        title: valueString,
-        children: valueString
-      });
-    }
-    if ( /*#__PURE__*/React.isValidElement(children) && managesOwnFocus) {
-      return /*#__PURE__*/React.cloneElement(children, {
-        focusElementRef
-      });
-    }
-    return children;
-  };
+  let children = childrenProp;
+  if (children === undefined) {
+    const valueString = valueToRender?.toString();
+    children = /*#__PURE__*/_jsx("div", {
+      className: classes.content,
+      title: valueString,
+      children: valueString
+    });
+  }
+  if ( /*#__PURE__*/React.isValidElement(children) && managesOwnFocus) {
+    children = /*#__PURE__*/React.cloneElement(children, {
+      focusElementRef
+    });
+  }
   const draggableEventHandlers = disableDragEvents ? null : {
     onDragEnter: publish('cellDragEnter', onDragEnter),
     onDragOver: publish('cellDragOver', onDragOver)
@@ -183,7 +296,7 @@ const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
     "aria-colindex": colIndex + 1,
     "aria-colspan": colSpan,
     style: style,
-    tabIndex: (cellMode === 'view' || !isEditable) && !managesOwnFocus ? tabIndex : -1,
+    tabIndex: tabIndex,
     onClick: publish('cellClick', onClick),
     onDoubleClick: publish('cellDoubleClick', onDoubleClick),
     onMouseOver: publish('cellMouseOver', onMouseOver),
@@ -193,10 +306,33 @@ const GridCell = /*#__PURE__*/React.forwardRef((props, ref) => {
     onKeyUp: publish('cellKeyUp', onKeyUp)
   }, draggableEventHandlers, other, {
     onFocus: handleFocus,
-    children: renderChildren()
+    children: children
   }));
 });
-const MemoizedCell = /*#__PURE__*/React.memo(GridCell);
+const MemoizedCellWrapper = fastMemo(GridCellWrapper);
+process.env.NODE_ENV !== "production" ? GridCellWrapper.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  align: PropTypes.oneOf(['center', 'left', 'right']),
+  className: PropTypes.string,
+  colIndex: PropTypes.number,
+  colSpan: PropTypes.number,
+  column: PropTypes.object,
+  disableDragEvents: PropTypes.bool,
+  height: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+  onClick: PropTypes.func,
+  onDoubleClick: PropTypes.func,
+  onDragEnter: PropTypes.func,
+  onDragOver: PropTypes.func,
+  onKeyDown: PropTypes.func,
+  onMouseDown: PropTypes.func,
+  onMouseUp: PropTypes.func,
+  rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  showRightBorder: PropTypes.bool,
+  width: PropTypes.number
+} : void 0;
 process.env.NODE_ENV !== "production" ? GridCell.propTypes = {
   // ----------------------------- Warning --------------------------------
   // | These PropTypes are generated from the TypeScript type definitions |
@@ -208,13 +344,254 @@ process.env.NODE_ENV !== "production" ? GridCell.propTypes = {
   className: PropTypes.string,
   colIndex: PropTypes.number,
   colSpan: PropTypes.number,
+  column: PropTypes.object,
+  disableDragEvents: PropTypes.bool,
+  editCellState: PropTypes.shape({
+    changeReason: PropTypes.oneOf(['debouncedSetEditCellValue', 'setEditCellValue']),
+    isProcessingProps: PropTypes.bool,
+    isValidating: PropTypes.bool,
+    value: PropTypes.any
+  }),
+  height: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
+  onClick: PropTypes.func,
+  onDoubleClick: PropTypes.func,
+  onDragEnter: PropTypes.func,
+  onDragOver: PropTypes.func,
+  onKeyDown: PropTypes.func,
+  onMouseDown: PropTypes.func,
+  onMouseUp: PropTypes.func,
+  rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  showRightBorder: PropTypes.bool,
+  width: PropTypes.number
+} : void 0;
+export { MemoizedCellWrapper as GridCellWrapper, GridCell };
+const GridCellV7 = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+      column,
+      rowId,
+      editCellState,
+      align,
+      colIndex,
+      height,
+      width,
+      className,
+      showRightBorder,
+      colSpan,
+      disableDragEvents,
+      onClick,
+      onDoubleClick,
+      onMouseDown,
+      onMouseUp,
+      onMouseOver,
+      onKeyDown,
+      onKeyUp,
+      onDragEnter,
+      onDragOver
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded3);
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const field = column.field;
+  const cellParamsWithAPI = useGridSelector(apiRef, () => {
+    // This is required because `.getCellParams` tries to get the `state.rows.tree` entry
+    // associated with `rowId`/`fieldId`, but this selector runs after the state has been
+    // updated, while `rowId`/`fieldId` reference an entry in the old state.
+    try {
+      const cellParams = apiRef.current.getCellParams(rowId, field);
+      const result = cellParams;
+      result.api = apiRef.current;
+      return result;
+    } catch (e) {
+      if (e instanceof MissingRowIdError) {
+        return EMPTY_CELL_PARAMS;
+      }
+      throw e;
+    }
+  }, objectShallowCompare);
+  const isSelected = useGridSelector(apiRef, () => apiRef.current.unstable_applyPipeProcessors('isCellSelected', false, {
+    id: rowId,
+    field
+  }));
+  const {
+    cellMode,
+    hasFocus,
+    isEditable,
+    value,
+    formattedValue
+  } = cellParamsWithAPI;
+  const managesOwnFocus = column.type === 'actions';
+  const tabIndex = (cellMode === 'view' || !isEditable) && !managesOwnFocus ? cellParamsWithAPI.tabIndex : -1;
+  const {
+    classes: rootClasses,
+    getCellClassName
+  } = rootProps;
+  const classNames = apiRef.current.unstable_applyPipeProcessors('cellClassName', [], {
+    id: rowId,
+    field
+  });
+  if (column.cellClassName) {
+    classNames.push(typeof column.cellClassName === 'function' ? column.cellClassName(cellParamsWithAPI) : column.cellClassName);
+  }
+  if (getCellClassName) {
+    classNames.push(getCellClassName(cellParamsWithAPI));
+  }
+  const valueToRender = formattedValue == null ? value : formattedValue;
+  const cellRef = React.useRef(null);
+  const handleRef = useForkRef(ref, cellRef);
+  const focusElementRef = React.useRef(null);
+  const ownerState = {
+    align,
+    showRightBorder,
+    isEditable,
+    classes: rootProps.classes,
+    isSelected
+  };
+  const classes = useUtilityClasses(ownerState);
+  const publishMouseUp = React.useCallback(eventName => event => {
+    const params = apiRef.current.getCellParams(rowId, field || '');
+    apiRef.current.publishEvent(eventName, params, event);
+    if (onMouseUp) {
+      onMouseUp(event);
+    }
+  }, [apiRef, field, onMouseUp, rowId]);
+  const publishMouseDown = React.useCallback(eventName => event => {
+    const params = apiRef.current.getCellParams(rowId, field || '');
+    apiRef.current.publishEvent(eventName, params, event);
+    if (onMouseDown) {
+      onMouseDown(event);
+    }
+  }, [apiRef, field, onMouseDown, rowId]);
+  const publish = React.useCallback((eventName, propHandler) => event => {
+    // The row might have been deleted during the click
+    if (!apiRef.current.getRow(rowId)) {
+      return;
+    }
+    const params = apiRef.current.getCellParams(rowId, field || '');
+    apiRef.current.publishEvent(eventName, params, event);
+    if (propHandler) {
+      propHandler(event);
+    }
+  }, [apiRef, field, rowId]);
+  const style = {
+    minWidth: width,
+    maxWidth: width,
+    minHeight: height,
+    maxHeight: height === 'auto' ? 'none' : height // max-height doesn't support "auto"
+  };
+
+  React.useEffect(() => {
+    if (!hasFocus || cellMode === GridCellModes.Edit) {
+      return;
+    }
+    const doc = ownerDocument(apiRef.current.rootElementRef.current);
+    if (cellRef.current && !cellRef.current.contains(doc.activeElement)) {
+      const focusableElement = cellRef.current.querySelector('[tabindex="0"]');
+      const elementToFocus = focusElementRef.current || focusableElement || cellRef.current;
+      if (doesSupportPreventScroll()) {
+        elementToFocus.focus({
+          preventScroll: true
+        });
+      } else {
+        const scrollPosition = apiRef.current.getScrollPosition();
+        elementToFocus.focus();
+        apiRef.current.scroll(scrollPosition);
+      }
+    }
+  }, [hasFocus, cellMode, apiRef]);
+  if (cellParamsWithAPI === EMPTY_CELL_PARAMS) {
+    return null;
+  }
+  let handleFocus = other.onFocus;
+  if (process.env.NODE_ENV === 'test' && rootProps.experimentalFeatures?.warnIfFocusStateIsNotSynced) {
+    handleFocus = event => {
+      const focusedCell = gridFocusCellSelector(apiRef);
+      if (focusedCell?.id === rowId && focusedCell.field === field) {
+        if (typeof other.onFocus === 'function') {
+          other.onFocus(event);
+        }
+        return;
+      }
+      if (!warnedOnce) {
+        console.warn([`MUI: The cell with id=${rowId} and field=${field} received focus.`, `According to the state, the focus should be at id=${focusedCell?.id}, field=${focusedCell?.field}.`, "Not syncing the state may cause unwanted behaviors since the `cellFocusIn` event won't be fired.", 'Call `fireEvent.mouseUp` before the `fireEvent.click` to sync the focus with the state.'].join('\n'));
+        warnedOnce = true;
+      }
+    };
+  }
+  let children;
+  if (editCellState == null && column.renderCell) {
+    children = column.renderCell(cellParamsWithAPI);
+    classNames.push(gridClasses['cell--withRenderer']);
+    classNames.push(rootClasses?.['cell--withRenderer']);
+  }
+  if (editCellState != null && column.renderEditCell) {
+    const updatedRow = apiRef.current.getRowWithUpdatedValues(rowId, column.field);
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const editCellStateRest = _objectWithoutPropertiesLoose(editCellState, _excluded4);
+    const params = _extends({}, cellParamsWithAPI, {
+      row: updatedRow
+    }, editCellStateRest);
+    children = column.renderEditCell(params);
+    classNames.push(gridClasses['cell--editing']);
+    classNames.push(rootClasses?.['cell--editing']);
+  }
+  if (children === undefined) {
+    const valueString = valueToRender?.toString();
+    children = /*#__PURE__*/_jsx("div", {
+      className: classes.content,
+      title: valueString,
+      children: valueString
+    });
+  }
+  if ( /*#__PURE__*/React.isValidElement(children) && managesOwnFocus) {
+    children = /*#__PURE__*/React.cloneElement(children, {
+      focusElementRef
+    });
+  }
+  const draggableEventHandlers = disableDragEvents ? null : {
+    onDragEnter: publish('cellDragEnter', onDragEnter),
+    onDragOver: publish('cellDragOver', onDragOver)
+  };
+  return /*#__PURE__*/_jsx("div", _extends({
+    ref: handleRef,
+    className: clsx(className, classNames, classes.root),
+    role: "cell",
+    "data-field": field,
+    "data-colindex": colIndex,
+    "aria-colindex": colIndex + 1,
+    "aria-colspan": colSpan,
+    style: style,
+    tabIndex: tabIndex,
+    onClick: publish('cellClick', onClick),
+    onDoubleClick: publish('cellDoubleClick', onDoubleClick),
+    onMouseOver: publish('cellMouseOver', onMouseOver),
+    onMouseDown: publishMouseDown('cellMouseDown'),
+    onMouseUp: publishMouseUp('cellMouseUp'),
+    onKeyDown: publish('cellKeyDown', onKeyDown),
+    onKeyUp: publish('cellKeyUp', onKeyUp)
+  }, draggableEventHandlers, other, {
+    onFocus: handleFocus,
+    children: children
+  }));
+});
+process.env.NODE_ENV !== "production" ? GridCellV7.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "yarn proptypes"  |
+  // ----------------------------------------------------------------------
+  align: PropTypes.oneOf(['center', 'left', 'right']),
+  className: PropTypes.string,
+  colIndex: PropTypes.number,
+  colSpan: PropTypes.number,
+  column: PropTypes.object,
   disableDragEvents: PropTypes.bool,
-  field: PropTypes.string,
-  formattedValue: PropTypes.any,
-  hasFocus: PropTypes.bool,
+  editCellState: PropTypes.shape({
+    changeReason: PropTypes.oneOf(['debouncedSetEditCellValue', 'setEditCellValue']),
+    isProcessingProps: PropTypes.bool,
+    isValidating: PropTypes.bool,
+    value: PropTypes.any
+  }),
   height: PropTypes.oneOfType([PropTypes.oneOf(['auto']), PropTypes.number]),
-  isEditable: PropTypes.bool,
-  isSelected: PropTypes.bool,
   onClick: PropTypes.func,
   onDoubleClick: PropTypes.func,
   onDragEnter: PropTypes.func,
@@ -224,8 +601,7 @@ process.env.NODE_ENV !== "production" ? GridCell.propTypes = {
   onMouseUp: PropTypes.func,
   rowId: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   showRightBorder: PropTypes.bool,
-  tabIndex: PropTypes.oneOf([-1, 0]),
-  value: PropTypes.any,
   width: PropTypes.number
 } : void 0;
-export { MemoizedCell as GridCell };
+const MemoizedGridCellV7 = fastMemo(GridCellV7);
+export { MemoizedGridCellV7 as GridCellV7 };

package/modern/components/cell/index.js

@@ -1,4 +1,4 @@
-export * from './GridCell';
+export { GridCell } from './GridCell';
 export * from './GridBooleanCell';
 export * from './GridEditBooleanCell';
 export * from './GridEditDateCell';

package/modern/components/containers/GridRootStyles.js

@@ -10,6 +10,22 @@ function getBorderColor(theme) {
   }
   return darken(alpha(theme.palette.divider, 1), 0.68);
 }
+const columnHeadersStyles = {
+  [`.${gridClasses.columnSeparator}, .${gridClasses['columnSeparator--resizing']}`]: {
+    visibility: 'visible',
+    width: 'auto'
+  }
+};
+const columnHeaderStyles = {
+  [`& .${gridClasses.iconButtonContainer}`]: {
+    visibility: 'visible',
+    width: 'auto'
+  },
+  [`& .${gridClasses.menuIcon}`]: {
+    width: 'auto',
+    visibility: 'visible'
+  }
+};
 export const GridRootStyles = styled('div', {
   name: 'MuiDataGrid',
   slot: 'Root',
@@ -51,6 +67,8 @@ export const GridRootStyles = styled('div', {
     [`& .${gridClasses['cell--rangeLeft']}`]: styles['cell--rangeLeft']
   }, {
     [`& .${gridClasses['cell--rangeRight']}`]: styles['cell--rangeRight']
+  }, {
+    [`& .${gridClasses['cell--withRightBorder']}`]: styles['cell--withRightBorder']
   }, {
     [`& .${gridClasses.cellContent}`]: styles.cellContent
   }, {
@@ -75,6 +93,8 @@ export const GridRootStyles = styled('div', {
     [`& .${gridClasses['columnHeader--sortable']}`]: styles['columnHeader--sortable']
   }, {
     [`& .${gridClasses['columnHeader--sorted']}`]: styles['columnHeader--sorted']
+  }, {
+    [`& .${gridClasses['columnHeader--withRightBorder']}`]: styles['columnHeader--withRightBorder']
   }, {
     [`& .${gridClasses.columnHeader}`]: styles.columnHeader
   }, {
@@ -200,9 +220,6 @@ export const GridRootStyles = styled('div', {
         duration: theme.transitions.duration.shorter
       })
     },
-    [`& .${gridClasses.columnHeader}:not(.${gridClasses['columnHeader--sorted']}):hover .${gridClasses.sortIcon}`]: {
-      opacity: 0.5
-    },
     [`& .${gridClasses.columnHeaderTitleContainer}`]: {
       display: 'flex',
       alignItems: 'center',
@@ -266,9 +283,16 @@ export const GridRootStyles = styled('div', {
       justifyContent: 'center',
       color: borderColor
     },
-    [`& .${gridClasses.columnHeaders}:hover .${gridClasses.columnSeparator}, .${gridClasses['columnSeparator--resizing']}`]: {
-      visibility: 'visible',
-      width: 'auto'
+    '@media (hover: hover)': {
+      [`& .${gridClasses.columnHeaders}:hover`]: columnHeadersStyles,
+      [`& .${gridClasses.columnHeader}:hover`]: columnHeaderStyles,
+      [`& .${gridClasses.columnHeader}:not(.${gridClasses['columnHeader--sorted']}):hover .${gridClasses.sortIcon}`]: {
+        opacity: 0.5
+      }
+    },
+    '@media (hover: none)': {
+      [`& .${gridClasses.columnHeaders}`]: columnHeadersStyles,
+      [`& .${gridClasses.columnHeader}`]: columnHeaderStyles
     },
     [`& .${gridClasses['columnSeparator--sideLeft']}`]: {
       left: -12
@@ -304,16 +328,6 @@ export const GridRootStyles = styled('div', {
       display: 'flex',
       alignItems: 'center'
     },
-    [`& .${gridClasses.columnHeader}:hover`]: {
-      [`& .${gridClasses.iconButtonContainer}`]: {
-        visibility: 'visible',
-        width: 'auto'
-      },
-      [`& .${gridClasses.menuIcon}`]: {
-        width: 'auto',
-        visibility: 'visible'
-      }
-    },
     [`.${gridClasses.menuOpen}`]: {
       visibility: 'visible',
       width: 'auto'

package/modern/components/menu/columnMenu/GridColumnHeaderMenu.js

@@ -24,7 +24,7 @@ function GridColumnHeaderMenu({
       apiRef.current.hideColumnMenu();
     }
   }, [apiRef, target]);
-  if (!target) {
+  if (!target || !colDef) {
     return null;
   }
   return /*#__PURE__*/_jsx(GridMenu, {

package/modern/components/toolbar/GridToolbar.js

@@ -14,8 +14,8 @@ import { GridToolbarQuickFilter } from './GridToolbarQuickFilter';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 const GridToolbar = /*#__PURE__*/React.forwardRef(function GridToolbar(props, ref) {
-  // TODO v6: think about where export option should be passed.
-  // from componentProps={{ toolbarExport: { ...exportOption} }} seems to be more appropriate
+  // TODO v7: think about where export option should be passed.
+  // from slotProps={{ toolbarExport: { ...exportOption } }} seems to be more appropriate
   const {
       csvOptions,
       printOptions,

package/modern/components/virtualization/GridVirtualScroller.js

@@ -1,6 +1,4 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["className"];
 import * as React from 'react';
 import clsx from 'clsx';
 import { styled } from '@mui/system';
@@ -31,16 +29,13 @@ const VirtualScrollerRoot = styled('div', {
   }
 });
 const GridVirtualScroller = /*#__PURE__*/React.forwardRef(function GridVirtualScroller(props, ref) {
-  const {
-      className
-    } = props,
-    other = _objectWithoutPropertiesLoose(props, _excluded);
   const rootProps = useGridRootProps();
   const classes = useUtilityClasses(rootProps);
   return /*#__PURE__*/_jsx(VirtualScrollerRoot, _extends({
-    ref: ref,
-    className: clsx(classes.root, className),
+    ref: ref
+  }, props, {
+    className: clsx(classes.root, props.className),
     ownerState: rootProps
-  }, other));
+  }));
 });
 export { GridVirtualScroller };