@mui/x-data-grid 5.12.3 → 5.14.0

package/modern/components/toolbar/GridToolbarExport.js

@@ -1,6 +1,8 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["csvOptions", "printOptions", "excelOptions"];
+const _excluded = ["hideMenu", "options"],
+      _excluded2 = ["hideMenu", "options"],
+      _excluded3 = ["csvOptions", "printOptions", "excelOptions"];
 import * as React from 'react';
 import PropTypes from 'prop-types';
 import MenuItem from '@mui/material/MenuItem';
@@ -9,31 +11,39 @@ import { GridToolbarExportContainer } from './GridToolbarExportContainer';
 import { jsx as _jsx } from "react/jsx-runtime";
 export const GridCsvExportMenuItem = props => {
   const apiRef = useGridApiContext();
+
   const {
     hideMenu,
     options
-  } = props;
-  return /*#__PURE__*/_jsx(MenuItem, {
+  } = props,
+        other = _objectWithoutPropertiesLoose(props, _excluded);
+
+  return /*#__PURE__*/_jsx(MenuItem, _extends({
     onClick: () => {
       apiRef.current.exportDataAsCsv(options);
       hideMenu?.();
-    },
+    }
+  }, other, {
     children: apiRef.current.getLocaleText('toolbarExportCSV')
-  });
+  }));
 };
 export const GridPrintExportMenuItem = props => {
   const apiRef = useGridApiContext();
+
   const {
     hideMenu,
     options
-  } = props;
-  return /*#__PURE__*/_jsx(MenuItem, {
+  } = props,
+        other = _objectWithoutPropertiesLoose(props, _excluded2);
+
+  return /*#__PURE__*/_jsx(MenuItem, _extends({
     onClick: () => {
       apiRef.current.exportDataAsPrint(options);
       hideMenu?.();
-    },
+    }
+  }, other, {
     children: apiRef.current.getLocaleText('toolbarExportPrint')
-  });
+  }));
 };
 const GridToolbarExport = /*#__PURE__*/React.forwardRef(function GridToolbarExport(props, ref) {
   const {
@@ -41,7 +51,7 @@ const GridToolbarExport = /*#__PURE__*/React.forwardRef(function GridToolbarExpo
     printOptions = {},
     excelOptions
   } = props,
-        other = _objectWithoutPropertiesLoose(props, _excluded);
+        other = _objectWithoutPropertiesLoose(props, _excluded3);
 
   const apiRef = useGridApiContext();
   const preProcessedButtons = apiRef.current.unstable_applyPipeProcessors('exportMenu', [], {

package/modern/constants/gridClasses.js

@@ -2,4 +2,4 @@ import { generateUtilityClasses, generateUtilityClass } from '@mui/material';
 export function getDataGridUtilityClass(slot) {
   return generateUtilityClass('MuiDataGrid', slot);
 }
-export const gridClasses = generateUtilityClasses('MuiDataGrid', ['actionsCell', 'autoHeight', 'booleanCell', 'cell--editable', 'cell--editing', 'cell--textCenter', 'cell--textLeft', 'cell--textRight', 'cell--withRenderer', 'cell', 'cellContent', 'cellCheckbox', 'checkboxInput', 'columnHeader--alignCenter', 'columnHeader--alignLeft', 'columnHeader--alignRight', 'columnHeader--dragging', 'columnHeader--moving', 'columnHeader--numeric', 'columnHeader--sortable', 'columnHeader--sorted', 'columnHeader--filtered', 'columnHeader', 'columnHeaderCheckbox', 'columnHeaderDraggableContainer', 'columnHeaderDropZone', 'columnHeaderTitle', 'columnHeaderTitleContainer', 'columnHeaderTitleContainerContent', 'columnHeaders', 'columnHeadersInner', 'columnHeadersInner--scrollable', 'columnSeparator--resizable', 'columnSeparator--resizing', 'columnSeparator--sideLeft', 'columnSeparator--sideRight', 'columnSeparator', 'columnsPanel', 'columnsPanelRow', 'detailPanel', 'detailPanels', 'detailPanelToggleCell', 'detailPanelToggleCell--expanded', 'panel', 'panelHeader', 'panelWrapper', 'panelContent', 'panelFooter', 'paper', 'editBooleanCell', 'editInputCell', 'filterForm', 'filterFormDeleteIcon', 'filterFormLinkOperatorInput', 'filterFormColumnInput', 'filterFormOperatorInput', 'filterFormValueInput', 'filterIcon', 'footerContainer', 'iconButtonContainer', 'iconSeparator', 'main', 'menu', 'menuIcon', 'menuIconButton', 'menuOpen', 'menuList', 'overlay', 'root', 'root--densityStandard', 'root--densityComfortable', 'root--densityCompact', 'row', 'row--editable', 'row--editing', 'row--lastVisible', 'row--dragging', 'row--dynamicHeight', 'rowReorderCellPlaceholder', 'rowCount', 'rowReorderCellContainer', 'rowReorderCell', 'rowReorderCell--draggable', 'scrollArea--left', 'scrollArea--right', 'scrollArea', 'selectedRowCount', 'sortIcon', 'toolbarContainer', 'toolbarFilterList', 'virtualScroller', 'virtualScrollerContent', 'virtualScrollerContent--overflowed', 'virtualScrollerRenderZone', 'pinnedColumns', 'pinnedColumns--left', 'pinnedColumns--right', 'pinnedColumnHeaders', 'pinnedColumnHeaders--left', 'pinnedColumnHeaders--right', 'withBorder', 'treeDataGroupingCell', 'treeDataGroupingCellToggle', 'groupingCriteriaCell', 'groupingCriteriaCellToggle']);
+export const gridClasses = generateUtilityClasses('MuiDataGrid', ['actionsCell', 'aggregationColumnHeader', 'aggregationColumnHeader--alignLeft', 'aggregationColumnHeader--alignCenter', 'aggregationColumnHeader--alignRight', 'autoHeight', 'booleanCell', 'cell--editable', 'cell--editing', 'cell--textCenter', 'cell--textLeft', 'cell--textRight', 'cell--withRenderer', 'cell', 'cellContent', 'cellCheckbox', 'checkboxInput', 'columnHeader--alignCenter', 'columnHeader--alignLeft', 'columnHeader--alignRight', 'columnHeader--dragging', 'columnHeader--moving', 'columnHeader--numeric', 'columnHeader--sortable', 'columnHeader--sorted', 'columnHeader--filtered', 'columnHeader', 'columnHeaderCheckbox', 'columnHeaderDraggableContainer', 'columnHeaderDropZone', 'columnHeaderTitle', 'columnHeaderTitleContainer', 'columnHeaderTitleContainerContent', 'columnHeaders', 'columnHeadersInner', 'columnHeadersInner--scrollable', 'columnSeparator--resizable', 'columnSeparator--resizing', 'columnSeparator--sideLeft', 'columnSeparator--sideRight', 'columnSeparator', 'columnsPanel', 'columnsPanelRow', 'detailPanel', 'detailPanels', 'detailPanelToggleCell', 'detailPanelToggleCell--expanded', 'footerCell', 'panel', 'panelHeader', 'panelWrapper', 'panelContent', 'panelFooter', 'paper', 'editBooleanCell', 'editInputCell', 'filterForm', 'filterFormDeleteIcon', 'filterFormLinkOperatorInput', 'filterFormColumnInput', 'filterFormOperatorInput', 'filterFormValueInput', 'filterIcon', 'footerContainer', 'iconButtonContainer', 'iconSeparator', 'main', 'menu', 'menuIcon', 'menuIconButton', 'menuOpen', 'menuList', 'overlay', 'root', 'root--densityStandard', 'root--densityComfortable', 'root--densityCompact', 'row', 'row--editable', 'row--editing', 'row--lastVisible', 'row--dragging', 'row--dynamicHeight', 'rowReorderCellPlaceholder', 'rowCount', 'rowReorderCellContainer', 'rowReorderCell', 'rowReorderCell--draggable', 'scrollArea--left', 'scrollArea--right', 'scrollArea', 'selectedRowCount', 'sortIcon', 'toolbarContainer', 'toolbarFilterList', 'virtualScroller', 'virtualScrollerContent', 'virtualScrollerContent--overflowed', 'virtualScrollerRenderZone', 'pinnedColumns', 'pinnedColumns--left', 'pinnedColumns--right', 'pinnedColumnHeaders', 'pinnedColumnHeaders--left', 'pinnedColumnHeaders--right', 'withBorder', 'treeDataGroupingCell', 'treeDataGroupingCellToggle', 'groupingCriteriaCell', 'groupingCriteriaCellToggle']);

package/modern/constants/localeTextConstants.js

@@ -111,5 +111,12 @@ export const GRID_DEFAULT_LOCALE_TEXT = {
   // Used core components translation keys
   MuiTablePagination: {},
   // Row reordering text
-  rowReorderingHeaderName: 'Row reordering'
+  rowReorderingHeaderName: 'Row reordering',
+  // Aggregation
+  aggregationMenuItemHeader: 'Aggregation',
+  aggregationFunctionLabelSum: 'sum',
+  aggregationFunctionLabelAvg: 'avg',
+  aggregationFunctionLabelMin: 'min',
+  aggregationFunctionLabelMax: 'max',
+  aggregationFunctionLabelSize: 'size'
 };

package/modern/hooks/features/columns/useGridColumnSpanning.js

@@ -26,11 +26,11 @@ export const useGridColumnSpanning = apiRef => {
       columnIndex,
       rowId,
       minFirstColumnIndex,
-      maxLastColumnIndex
+      maxLastColumnIndex,
+      columns
     } = params;
-    const visibleColumns = apiRef.current.getVisibleColumns();
-    const columnsLength = visibleColumns.length;
-    const column = visibleColumns[columnIndex];
+    const columnsLength = columns.length;
+    const column = columns[columnIndex];
     const colSpan = typeof column.colSpan === 'function' ? column.colSpan(apiRef.current.getCellParams(rowId, column.field)) : column.colSpan;
 
     if (!colSpan || colSpan === 1) {
@@ -52,7 +52,7 @@ export const useGridColumnSpanning = apiRef => {
       const nextColumnIndex = columnIndex + j; // Cells should be spanned only within their column section (left-pinned, right-pinned and unpinned).
 
       if (nextColumnIndex >= minFirstColumnIndex && nextColumnIndex < maxLastColumnIndex) {
-        const nextColumn = visibleColumns[nextColumnIndex];
+        const nextColumn = columns[nextColumnIndex];
         width += nextColumn.computedWidth;
         setCellColSpanInfo(rowId, columnIndex + j, {
           spannedByColSpan: true,
@@ -78,14 +78,16 @@ export const useGridColumnSpanning = apiRef => {
   const calculateColSpan = React.useCallback(({
     rowId,
     minFirstColumn,
-    maxLastColumn
+    maxLastColumn,
+    columns
   }) => {
     for (let i = minFirstColumn; i < maxLastColumn; i += 1) {
       const cellProps = calculateCellColSpan({
         columnIndex: i,
         rowId,
         minFirstColumnIndex: minFirstColumn,
-        maxLastColumnIndex: maxLastColumn
+        maxLastColumnIndex: maxLastColumn,
+        columns
       });
 
       if (cellProps.colSpan > 1) {

package/modern/hooks/features/columns/useGridColumns.js

@@ -186,14 +186,19 @@ export function useGridColumns(apiRef, props) {
    * PRE-PROCESSING
    */
 
-  const stateExportPreProcessing = React.useCallback(prevState => {
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
     const columnsStateToExport = {};
 
     if (apiRef.current.unstable_caches.columns.isUsingColumnVisibilityModel) {
       const columnVisibilityModelToExport = gridColumnVisibilityModelSelector(apiRef);
-      const hasHiddenColumns = Object.values(columnVisibilityModelToExport).some(value => value === false);
-
-      if (hasHiddenColumns) {
+      const shouldExportColumnVisibilityModel = // Always export if the `exportOnlyDirtyModels` property is activated
+      !context.exportOnlyDirtyModels || // Always export if the model is controlled
+      props.columnVisibilityModel != null || // Always export if the model has been initialized
+      // TODO v6 Do a nullish check instead to export even if the initial model equals "{}"
+      Object.keys(props.initialState?.columns?.columnVisibilityModel ?? {}).length > 0 || // Always export if the model is not empty
+      Object.keys(columnVisibilityModelToExport).length > 0;
+
+      if (shouldExportColumnVisibilityModel) {
         columnsStateToExport.columnVisibilityModel = columnVisibilityModelToExport;
       }
     }
@@ -224,7 +229,7 @@ export function useGridColumns(apiRef, props) {
     return _extends({}, prevState, {
       columns: columnsStateToExport
     });
-  }, [apiRef]);
+  }, [apiRef, props.columnVisibilityModel, props.initialState?.columns]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     const columnVisibilityModelToImport = apiRef.current.unstable_caches.columns.isUsingColumnVisibilityModel ? context.stateToRestore.columns?.columnVisibilityModel : undefined;
     const initialState = context.stateToRestore.columns;

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

@@ -69,21 +69,34 @@ export function useGridDimensions(apiRef, props) {
       rootElement.removeChild(scrollDiv);
     }
 
-    const viewportOuterSize = {
-      width: rootDimensionsRef.current.width,
-      height: props.autoHeight ? rowsMeta.currentPageTotalHeight : rootDimensionsRef.current.height - headerHeight
-    };
-    const {
-      hasScrollX,
-      hasScrollY
-    } = hasScroll({
-      content: {
-        width: Math.round(columnsTotalWidth),
-        height: rowsMeta.currentPageTotalHeight
-      },
-      container: viewportOuterSize,
-      scrollBarSize
-    });
+    let viewportOuterSize;
+    let hasScrollX;
+    let hasScrollY;
+
+    if (props.autoHeight) {
+      hasScrollY = false;
+      hasScrollX = Math.round(columnsTotalWidth) > rootDimensionsRef.current.width;
+      viewportOuterSize = {
+        width: rootDimensionsRef.current.width,
+        height: rowsMeta.currentPageTotalHeight + (hasScrollX ? scrollBarSize : 0)
+      };
+    } else {
+      viewportOuterSize = {
+        width: rootDimensionsRef.current.width,
+        height: rootDimensionsRef.current.height - headerHeight
+      };
+      const scrollInformation = hasScroll({
+        content: {
+          width: Math.round(columnsTotalWidth),
+          height: rowsMeta.currentPageTotalHeight
+        },
+        container: viewportOuterSize,
+        scrollBarSize
+      });
+      hasScrollY = scrollInformation.hasScrollY;
+      hasScrollX = scrollInformation.hasScrollX;
+    }
+
     const viewportInnerSize = {
       width: viewportOuterSize.width - (hasScrollY ? scrollBarSize : 0),
       height: viewportOuterSize.height - (hasScrollX ? scrollBarSize : 0)

package/modern/hooks/features/editRows/useGridCellEditing.new.js

@@ -70,6 +70,12 @@ export const useGridCellEditing = (apiRef, props) => {
   }, [apiRef]);
   const handleCellKeyDown = React.useCallback((params, event) => {
     if (params.cellMode === GridCellModes.Edit) {
+      // Wait until IME is settled for Asian languages like Japanese and Chinese
+      // TODO: `event.which` is depricated but this is a temporary workaround
+      if (event.which === 229) {
+        return;
+      }
+
       let reason;
 
       if (event.key === 'Escape') {
@@ -92,7 +98,7 @@ export const useGridCellEditing = (apiRef, props) => {
       let reason;
 
       if (isPrintableKey(event.key)) {
-        if (event.shiftKey || event.ctrlKey || event.metaKey || event.altKey) {
+        if (event.ctrlKey && event.key !== 'v' || event.metaKey && event.key !== 'v' || event.altKey) {
           return;
         }
 

package/modern/hooks/features/editRows/useGridCellEditing.old.js

@@ -175,6 +175,12 @@ export const useCellEditing = (apiRef, props) => {
   };
   useGridApiMethod(apiRef, cellEditingApi, 'EditRowApi');
   const handleCellKeyDown = React.useCallback(async (params, event) => {
+    // Wait until IME is settled for Asian languages like Japanese and Chinese
+    // TODO: `event.which` is depricated but this is a temporary workaround
+    if (event.which === 229) {
+      return;
+    }
+
     const {
       id,
       field,

package/modern/hooks/features/editRows/useGridRowEditing.new.js

@@ -108,6 +108,12 @@ export const useGridRowEditing = (apiRef, props) => {
   }, []);
   const handleCellKeyDown = React.useCallback((params, event) => {
     if (params.cellMode === GridRowModes.Edit) {
+      // Wait until IME is settled for Asian languages like Japanese and Chinese
+      // TODO: `event.which` is depricated but this is a temporary workaround
+      if (event.which === 229) {
+        return;
+      }
+
       let reason;
 
       if (event.key === 'Escape') {
@@ -146,7 +152,7 @@ export const useGridRowEditing = (apiRef, props) => {
       let reason;
 
       if (isPrintableKey(event.key)) {
-        if (event.shiftKey || event.ctrlKey || event.metaKey || event.altKey) {
+        if (event.ctrlKey && event.key !== 'v' || event.metaKey && event.key !== 'v' || event.altKey) {
           return;
         }
 

package/modern/hooks/features/editRows/useGridRowEditing.old.js

@@ -172,6 +172,12 @@ export const useGridRowEditing = (apiRef, props) => {
   };
   useGridApiMethod(apiRef, rowEditingApi, 'EditRowApi');
   const handleCellKeyDown = React.useCallback(async (params, event) => {
+    // Wait until IME is settled for Asian languages like Japanese and Chinese
+    // TODO: `event.which` is depricated but this is a temporary workaround
+    if (event.which === 229) {
+      return;
+    }
+
     const {
       cellMode,
       isEditable

package/modern/hooks/features/export/utils.js

@@ -1,5 +1,6 @@
 import { gridColumnDefinitionsSelector, gridVisibleColumnDefinitionsSelector } from '../columns';
 import { gridFilteredSortedRowIdsSelector } from '../filter';
+import { gridRowTreeSelector } from '../rows/gridRowsSelector';
 export const getColumnsToExport = ({
   apiRef,
   options
@@ -17,11 +18,13 @@ export const defaultGetRowsToExport = ({
   apiRef
 }) => {
   const filteredSortedRowIds = gridFilteredSortedRowIdsSelector(apiRef);
+  const rowTree = gridRowTreeSelector(apiRef);
   const selectedRows = apiRef.current.getSelectedRows();
+  const bodyRows = filteredSortedRowIds.filter(id => (rowTree[id].position ?? 'body') === 'body');
 
   if (selectedRows.size > 0) {
-    return filteredSortedRowIds.filter(id => selectedRows.has(id));
+    return bodyRows.filter(id => selectedRows.has(id));
   }
 
-  return filteredSortedRowIds;
+  return bodyRows;
 };

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

@@ -2,6 +2,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import { GridLinkOperator } from '../../../models';
 import { buildWarning } from '../../../utils/warning';
 import { gridColumnFieldsSelector, gridColumnLookupSelector } from '../columns';
+import { gridRowTreeSelector } from '../rows/gridRowsSelector';
 
 /**
  * Adds default values to the optional fields of a filter items.
@@ -80,6 +81,7 @@ export const buildAggregatedFilterItemsApplier = (filterModel, apiRef) => {
     items,
     linkOperator = GridLinkOperator.And
   } = filterModel;
+  const tree = gridRowTreeSelector(apiRef);
 
   const getFilterCallbackFromItem = filterItem => {
     if (!filterItem.columnField || !filterItem.operatorValue) {
@@ -141,6 +143,10 @@ export const buildAggregatedFilterItemsApplier = (filterModel, apiRef) => {
   }
 
   return (rowId, shouldApplyFilter) => {
+    if (tree[rowId].position === 'footer') {
+      return true;
+    }
+
     const filteredAppliers = shouldApplyFilter ? appliers.filter(applier => shouldApplyFilter(applier.item.columnField)) : appliers; // Return `false` as soon as we have a failing filter
 
     if (linkOperator === GridLinkOperator.And) {

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

@@ -109,7 +109,23 @@ export const useGridFilter = (apiRef, props) => {
 
     if (targetColumnField) {
       const filterModel = gridFilterModelSelector(apiRef);
-      const filterItemsWithValue = filterModel.items.filter(item => item.value !== undefined);
+      const filterItemsWithValue = filterModel.items.filter(item => {
+        if (item.value !== undefined) {
+          return true;
+        }
+
+        const column = apiRef.current.getColumn(item.columnField);
+        const filterOperator = column.filterOperators?.find(operator => operator.value === item.operatorValue);
+        const requiresFilterValue = typeof filterOperator?.requiresFilterValue === 'undefined' ? true : filterOperator?.requiresFilterValue; // Operators like `isEmpty` don't have and don't require `item.value`.
+        // So we don't want to remove them from the filter model if `item.value === undefined`.
+        // See https://github.com/mui/mui-x/issues/5402
+
+        if (requiresFilterValue) {
+          return false;
+        }
+
+        return true;
+      });
       let newFilterItems;
       const filterItemOnTarget = filterItemsWithValue.find(item => item.columnField === targetColumnField);
 
@@ -188,10 +204,15 @@ export const useGridFilter = (apiRef, props) => {
    * PRE-PROCESSING
    */
 
-  const stateExportPreProcessing = React.useCallback(prevState => {
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
     const filterModelToExport = gridFilterModelSelector(apiRef);
+    const shouldExportFilterModel = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the model is controlled
+    props.filterModel != null || // Always export if the model has been initialized
+    props.initialState?.filter?.filterModel != null || // Export if the model is not equal to the default value
+    !isDeepEqual(filterModelToExport, getDefaultGridFilterModel());
 
-    if (filterModelToExport.items.length === 0 && filterModelToExport.linkOperator === getDefaultGridFilterModel().linkOperator) {
+    if (!shouldExportFilterModel) {
       return prevState;
     }
 
@@ -200,7 +221,7 @@ export const useGridFilter = (apiRef, props) => {
         filterModel: filterModelToExport
       }
     });
-  }, [apiRef]);
+  }, [apiRef, props.filterModel, props.initialState?.filter?.filterModel]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     const filterModel = context.stateToRestore.filter?.filterModel;
 

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

@@ -61,11 +61,12 @@ export const useGridPage = (apiRef, props) => {
    * PRE-PROCESSING
    */
 
-  const stateExportPreProcessing = React.useCallback(prevState => {
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
     const pageToExport = gridPageSelector(apiRef);
-    const shouldExportPage = // Always export if the page is controlled
+    const shouldExportPage = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the page is controlled
     props.page != null || // Always export if the page has been initialized
-    props.initialState?.pagination?.page != null || // Export if the page value is not equal to the default value
+    props.initialState?.pagination?.page != null || // Export if the page is not equal to the default value
     pageToExport !== 0;
 
     if (!shouldExportPage) {

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

@@ -47,11 +47,12 @@ export const useGridPageSize = (apiRef, props) => {
    * PRE-PROCESSING
    */
 
-  const stateExportPreProcessing = React.useCallback(prevState => {
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
     const pageSizeToExport = gridPageSizeSelector(apiRef);
-    const shouldExportPageSize = // Always export if the page size is controlled
+    const shouldExportPageSize = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the page size is controlled
     props.pageSize != null || // Always export if the page size has been initialized
-    props.initialState?.pagination?.pageSize != null || // Export if the page size value is not equal to the default value
+    props.initialState?.pagination?.pageSize != null || // Export if the page size is not equal to the default value
     pageSizeToExport !== defaultPageSize(props.autoPageSize);
 
     if (!shouldExportPageSize) {

package/modern/hooks/features/preferencesPanel/useGridPreferencesPanel.js

@@ -13,7 +13,7 @@ export const preferencePanelStateInitializer = (state, props) => _extends({}, st
  * TODO: Add a single `setPreferencePanel` method to avoid multiple `setState`
  */
 
-export const useGridPreferencesPanel = apiRef => {
+export const useGridPreferencesPanel = (apiRef, props) => {
   const logger = useGridLogger(apiRef, 'useGridPreferencesPanel');
   const hideTimeout = React.useRef();
   const immediateTimeout = React.useRef();
@@ -70,17 +70,21 @@ export const useGridPreferencesPanel = apiRef => {
    * PRE-PROCESSING
    */
 
-  const stateExportPreProcessing = React.useCallback(prevState => {
+  const stateExportPreProcessing = React.useCallback((prevState, context) => {
     const preferencePanelToExport = gridPreferencePanelStateSelector(apiRef.current.state);
+    const shouldExportPreferencePanel = // Always export if the `exportOnlyDirtyModels` property is activated
+    !context.exportOnlyDirtyModels || // Always export if the panel was initialized
+    props.initialState?.preferencePanel != null || // Always export if the panel is opened
+    preferencePanelToExport.open;
 
-    if (!preferencePanelToExport.open && !preferencePanelToExport.openedPanelValue) {
+    if (!shouldExportPreferencePanel) {
       return prevState;
     }
 
     return _extends({}, prevState, {
       preferencePanel: preferencePanelToExport
     });
-  }, [apiRef]);
+  }, [apiRef, props.initialState?.preferencePanel]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     const preferencePanel = context.stateToRestore.preferencePanel;
 

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

@@ -93,7 +93,7 @@ export const useGridRows = (apiRef, props) => {
   const updateRows = React.useCallback(updates => {
     if (props.signature === GridSignature.DataGrid && updates.length > 1) {
       // TODO: Add test with direct call to `apiRef.current.updateRows` in DataGrid after enabling the `apiRef` on the free plan.
-      throw new Error(["MUI: You can't update several rows at once in `apiRef.current.updateRows` on the DataGrid.", 'You need to upgrade to the DataGridPro component to unlock this feature.'].join('\n'));
+      throw new Error(["MUI: You can't update several rows at once in `apiRef.current.updateRows` on the DataGrid.", 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
     } // we remove duplicate updates. A server can batch updates, and send several updates for the same row in one fn call.
 
 

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

@@ -11,7 +11,7 @@ const flatRowTreeCreationMethod = ({
   for (let i = 0; i < ids.length; i += 1) {
     const rowId = ids[i];
 
-    if (previousTree && previousTree[rowId]) {
+    if (previousTree && previousTree[rowId] && previousTree[rowId].depth === 0 && previousTree[rowId].parent == null) {
       tree[rowId] = previousTree[rowId];
     } else {
       tree[rowId] = {

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

@@ -57,9 +57,9 @@ export const useGridSelection = (apiRef, props) => {
     checkboxSelection,
     disableMultipleSelection,
     disableSelectionOnClick,
-    isRowSelectable,
     pagination,
-    paginationMode
+    paginationMode,
+    isRowSelectable: propIsRowSelectable
   } = props;
   const canHaveMultipleSelection = !disableMultipleSelection || checkboxSelection;
   const visibleRows = useGridVisibleRows(apiRef, props);
@@ -106,9 +106,20 @@ export const useGridSelection = (apiRef, props) => {
     }
   }, [apiRef, logger]);
   const isRowSelected = React.useCallback(id => gridSelectionStateSelector(apiRef.current.state).includes(id), [apiRef]);
+  const isRowSelectable = React.useCallback(id => {
+    if (propIsRowSelectable && !propIsRowSelectable(apiRef.current.getRowParams(id))) {
+      return false;
+    }
+
+    if (apiRef.current.getRowNode(id)?.position === 'footer') {
+      return false;
+    }
+
+    return true;
+  }, [apiRef, propIsRowSelectable]);
   const getSelectedRows = React.useCallback(() => selectedGridRowsSelector(apiRef), [apiRef]);
   const selectRow = React.useCallback((id, isSelected = true, resetSelection = false) => {
-    if (isRowSelectable && !isRowSelectable(apiRef.current.getRowParams(id))) {
+    if (!apiRef.current.isRowSelectable(id)) {
       return;
     }
 
@@ -132,10 +143,10 @@ export const useGridSelection = (apiRef, props) => {
         apiRef.current.setSelectionModel(newSelection);
       }
     }
-  }, [apiRef, isRowSelectable, logger, canHaveMultipleSelection]);
+  }, [apiRef, logger, canHaveMultipleSelection]);
   const selectRows = React.useCallback((ids, isSelected = true, resetSelection = false) => {
     logger.debug(`Setting selection for several rows`);
-    const selectableIds = isRowSelectable ? ids.filter(id => isRowSelectable(apiRef.current.getRowParams(id))) : ids;
+    const selectableIds = ids.filter(id => apiRef.current.isRowSelectable(id));
     let newSelection;
 
     if (resetSelection) {
@@ -159,7 +170,7 @@ export const useGridSelection = (apiRef, props) => {
     if (isSelectionValid) {
       apiRef.current.setSelectionModel(newSelection);
     }
-  }, [apiRef, isRowSelectable, logger, canHaveMultipleSelection]);
+  }, [apiRef, logger, canHaveMultipleSelection]);
   const selectRowRange = React.useCallback(({
     startId,
     endId
@@ -183,7 +194,8 @@ export const useGridSelection = (apiRef, props) => {
     selectRowRange,
     setSelectionModel,
     getSelectedRows,
-    isRowSelected
+    isRowSelected,
+    isRowSelectable
   };
   useGridApiMethod(apiRef, selectionApi, 'GridSelectionApi');
   /**
@@ -363,13 +375,13 @@ export const useGridSelection = (apiRef, props) => {
   React.useEffect(() => {
     if (isStateControlled) {
       return;
-    } // isRowSelectable changed
+    } // props.isRowSelectable changed
 
 
     const currentSelection = gridSelectionStateSelector(apiRef.current.state);
 
     if (isRowSelectable) {
-      const newSelection = currentSelection.filter(id => isRowSelectable(apiRef.current.getRowParams(id)));
+      const newSelection = currentSelection.filter(id => isRowSelectable(id));
 
       if (newSelection.length < currentSelection.length) {
         apiRef.current.setSelectionModel(newSelection);
@@ -396,7 +408,7 @@ export const useGridSelection = (apiRef, props) => {
         let isSelectable = true;
 
         if (isRowSelectable) {
-          isSelectable = isRowSelectable(apiRef.current.getRowParams(id));
+          isSelectable = isRowSelectable(id);
         }
 
         return isSelectable && currentPageRowsLookup[id]; // Check if the row is in the current page

package/modern/hooks/features/sorting/gridSortingUtils.js

@@ -46,25 +46,24 @@ const parseSortItem = (sortItem, apiRef) => {
     comparator
   };
 };
+
 /**
  * Compare two rows according to a list of valid sort items.
  * The `row1Params` and `row2Params` must have the same length as `parsedSortItems`,
  * and each of their index must contain the `GridSortCellParams` of the sort item with the same index.
  * @param {GridParsedSortItem[]} parsedSortItems All the sort items with which we want to compare the rows.
- * @param {GridSortCellParams} row1Params The params of the 1st row for each sort item.
- * @param {GridSortCellParams} row2Params The params of the 2nd row for each sort item.
+ * @param {GridRowAggregatedSortingParams} row1 The node and params of the 1st row for each sort item.
+ * @param {GridRowAggregatedSortingParams} row2 The node and params of the 2nd row for each sort item.
  */
-
-
-const compareRows = (parsedSortItems, row1Params, row2Params) => {
+const compareRows = (parsedSortItems, row1, row2) => {
   return parsedSortItems.reduce((res, item, index) => {
     if (res !== 0) {
       // return the results of the first comparator which distinguish the two rows
       return res;
     }
 
-    const sortCellParams1 = row1Params[index];
-    const sortCellParams2 = row2Params[index];
+    const sortCellParams1 = row1.params[index];
+    const sortCellParams2 = row2.params[index];
     res = item.comparator(sortCellParams1.value, sortCellParams2.value, sortCellParams1, sortCellParams2);
     return res;
   }, 0);
@@ -84,10 +83,10 @@ export const buildAggregatedSortingApplier = (sortModel, apiRef) => {
     return null;
   }
 
-  return rowList => rowList.map(value => ({
-    value,
-    params: comparatorList.map(el => el.getSortCellParams(value.id))
-  })).sort((a, b) => compareRows(comparatorList, a.params, b.params)).map(row => row.value.id);
+  return rowList => rowList.map(node => ({
+    node,
+    params: comparatorList.map(el => el.getSortCellParams(node.id))
+  })).sort((a, b) => compareRows(comparatorList, a, b)).map(row => row.node.id);
 };
 export const getNextGridSortDirection = (sortingOrder, current) => {
   const currentIdx = sortingOrder.indexOf(current);