@mui/x-data-grid 5.14.0 → 5.15.2

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

@@ -23,6 +23,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
       cellModesModel = _React$useState2[0],
       setCellModesModel = _React$useState2[1];
 
+  var cellModesModelRef = React.useRef(cellModesModel);
   var prevCellModesModel = React.useRef({});
   var processRowUpdate = props.processRowUpdate,
       onProcessRowUpdateError = props.onProcessRowUpdateError,
@@ -70,6 +71,10 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
       return;
     }
 
+    if (apiRef.current.getCellMode(params.id, params.field) === GridCellModes.View) {
+      return;
+    }
+
     var newParams = _extends({}, params, {
       reason: GridCellEditStopReasons.cellFocusOut
     });
@@ -105,15 +110,14 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     } else if (params.isEditable) {
       var _reason;
 
-      if (isPrintableKey(event.key)) {
-        if (event.ctrlKey && event.key !== 'v' || event.metaKey && event.key !== 'v' || event.altKey) {
-          return;
-        }
-
+      if (isPrintableKey(event)) {
+        _reason = GridCellEditStartReasons.printableKeyDown;
+      } else if ((event.ctrlKey || event.metaKey) && event.key === 'v') {
         _reason = GridCellEditStartReasons.printableKeyDown;
       } else if (event.key === 'Enter') {
         _reason = GridCellEditStartReasons.enterKeyDown;
-      } else if (event.key === 'Delete') {
+      } else if (event.key === 'Delete' || event.key === 'Backspace') {
+        // Delete on Windows, Backspace on macOS
         _reason = GridCellEditStartReasons.deleteKeyDown;
       }
 
@@ -145,6 +149,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     var id = params.id,
         field = params.field,
         reason = params.reason;
+    apiRef.current.unstable_runPendingEditCellValueMutation(id, field);
     var cellToFocusAfter;
 
     if (reason === GridCellEditStopReasons.enterKeyDown) {
@@ -158,7 +163,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     var ignoreModifications = reason === 'escapeKeyDown';
     var editingState = gridEditRowsStateSelector(apiRef.current.state);
 
-    if (editingState[id][field].isProcessingProps) {
+    if (editingState[id][field].isProcessingProps && !props.disableIgnoreModificationsIfProcessingProps) {
       // The user wants to stop editing the cell but we can't wait for the props to be processed.
       // In this case, discard the modifications.
       ignoreModifications = true;
@@ -170,7 +175,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
       ignoreModifications: ignoreModifications,
       cellToFocusAfter: cellToFocusAfter
     });
-  }, [apiRef]);
+  }, [apiRef, props.disableIgnoreModificationsIfProcessingProps]);
   useGridApiEventHandler(apiRef, 'cellDoubleClick', runIfEditModeIsCell(handleCellDoubleClick));
   useGridApiEventHandler(apiRef, 'cellFocusOut', runIfEditModeIsCell(handleCellFocusOut));
   useGridApiEventHandler(apiRef, 'cellKeyDown', runIfEditModeIsCell(handleCellKeyDown));
@@ -198,17 +203,20 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     }
 
     setCellModesModel(newModel);
+    cellModesModelRef.current = newModel;
     apiRef.current.publishEvent('cellModesModelChange', newModel);
   }, [apiRef, onCellModesModelChange, props.cellModesModel, signature]);
   var updateFieldInCellModesModel = React.useCallback(function (id, field, newProps) {
-    var newModel = _extends({}, cellModesModel);
+    // We use the ref because it always contain the up-to-date value, different from the state
+    // that needs a rerender to reflect the new value
+    var newModel = _extends({}, cellModesModelRef.current);
 
     if (newProps !== null) {
       newModel[id] = _extends({}, newModel[id], _defineProperty({}, field, _extends({}, newProps)));
     } else {
-      var _cellModesModel$id = cellModesModel[id],
-          fieldToRemove = _cellModesModel$id[field],
-          otherFields = _objectWithoutProperties(_cellModesModel$id, [field].map(_toPropertyKey)); // Ensure that we have a new object, not a reference
+      var _newModel$id = newModel[id],
+          fieldToRemove = _newModel$id[field],
+          otherFields = _objectWithoutProperties(_newModel$id, [field].map(_toPropertyKey)); // Ensure that we have a new object, not a reference
 
 
       newModel[id] = otherFields;
@@ -219,7 +227,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     }
 
     updateCellModesModel(newModel);
-  }, [cellModesModel, updateCellModesModel]);
+  }, [updateCellModesModel]);
   var updateOrDeleteFieldState = React.useCallback(function (id, field, newProps) {
     apiRef.current.setState(function (state) {
       var newEditingState = _extends({}, state.editRows);
@@ -286,12 +294,12 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
               apiRef.current.unstable_runPendingEditCellValueMutation(id, field);
 
               finishCellEditMode = function finishCellEditMode() {
+                updateOrDeleteFieldState(id, field, null);
+                updateFieldInCellModesModel(id, field, null);
+
                 if (cellToFocusAfter !== 'none') {
                   apiRef.current.unstable_moveFocusToRelativeCell(id, field, cellToFocusAfter);
                 }
-
-                updateOrDeleteFieldState(id, field, null);
-                updateFieldInCellModesModel(id, field, null);
               };
 
               if (!ignoreModifications) {
@@ -358,6 +366,8 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
   }(), [apiRef, onProcessRowUpdateError, processRowUpdate, throwIfNotInMode, updateFieldInCellModesModel, updateOrDeleteFieldState]);
   var setCellEditingEditCellValue = React.useCallback( /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(params) {
+      var _editingState$id, _editingState$id$fiel2;
+
       var id, field, value, column, row, parsedValue, editingState, newProps, hasChanged;
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
@@ -419,7 +429,7 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
               newProps.value = column.preProcessEditCellProps ? editingState[id][field].value : parsedValue;
               updateOrDeleteFieldState(id, field, newProps);
               editingState = gridEditRowsStateSelector(apiRef.current.state);
-              return _context2.abrupt("return", !editingState[id][field].error);
+              return _context2.abrupt("return", !((_editingState$id = editingState[id]) != null && (_editingState$id$fiel2 = _editingState$id[field]) != null && _editingState$id$fiel2.error));
 
             case 24:
             case "end":

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

@@ -210,7 +210,7 @@ export var useCellEditing = function useCellEditing(apiRef, props) {
               isEditMode = cellMode === GridCellModes.Edit;
               isModifierKeyPressed = event.ctrlKey || event.metaKey || event.altKey;
 
-              if (!isEditMode && isCellEnterEditModeKeys(event.key) && !isModifierKeyPressed && !(event.key === ' ' && event.shiftKey)) {
+              if (!isEditMode && isCellEnterEditModeKeys(event) && !isModifierKeyPressed && !(event.key === ' ' && event.shiftKey)) {
                 apiRef.current.publishEvent('cellEditStart', params, event);
               }
 
@@ -327,7 +327,7 @@ export var useCellEditing = function useCellEditing(apiRef, props) {
 
     apiRef.current.setCellMode(params.id, params.field, GridCellModes.Edit);
 
-    if (isKeyboardEvent(event) && isPrintableKey(event.key)) {
+    if (isKeyboardEvent(event) && isPrintableKey(event)) {
       apiRef.current.unstable_setEditCellProps({
         id: params.id,
         field: params.field,

package/legacy/hooks/features/editRows/useGridEditing.new.js

@@ -34,6 +34,10 @@ export var useGridEditing = function useGridEditing(apiRef, props) {
       return isCellEditableProp(params);
     }
 
+    if (params.rowNode.isPinned) {
+      return false;
+    }
+
     return true;
   }, [isCellEditableProp]);
 

package/legacy/hooks/features/editRows/useGridEditing.old.js

@@ -34,7 +34,7 @@ export function useGridEditing(apiRef, props) {
     changeEvent: 'editRowsModelChange'
   });
   var isCellEditable = React.useCallback(function (params) {
-    return !params.rowNode.isAutoGenerated && !!params.colDef.editable && !!params.colDef.renderEditCell && (!props.isCellEditable || props.isCellEditable(params));
+    return !params.rowNode.isAutoGenerated && !params.rowNode.isPinned && !!params.colDef.editable && !!params.colDef.renderEditCell && (!props.isCellEditable || props.isCellEditable(params));
   }, // eslint-disable-next-line react-hooks/exhaustive-deps
   [props.isCellEditable]);
 

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

@@ -22,6 +22,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
       rowModesModel = _React$useState2[0],
       setRowModesModel = _React$useState2[1];
 
+  var rowModesModelRef = React.useRef(rowModesModel);
   var prevRowModesModel = React.useRef({});
   var focusTimeout = React.useRef(null);
   var nextFocusedCell = React.useRef(null);
@@ -96,6 +97,11 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
         // The row might have been deleted during the click
         if (!apiRef.current.getRow(params.id)) {
           return;
+        } // The row may already changed its mode
+
+
+        if (apiRef.current.getRowMode(params.id) === GridRowModes.View) {
+          return;
         }
 
         var rowParams = apiRef.current.getRowParams(params.id);
@@ -161,15 +167,14 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
     } else if (params.isEditable) {
       var _reason;
 
-      if (isPrintableKey(event.key)) {
-        if (event.ctrlKey && event.key !== 'v' || event.metaKey && event.key !== 'v' || event.altKey) {
-          return;
-        }
-
+      if (isPrintableKey(event)) {
+        _reason = GridRowEditStartReasons.printableKeyDown;
+      } else if ((event.ctrlKey || event.metaKey) && event.key === 'v') {
         _reason = GridRowEditStartReasons.printableKeyDown;
       } else if (event.key === 'Enter') {
         _reason = GridRowEditStartReasons.enterKeyDown;
-      } else if (event.key === 'Delete') {
+      } else if (event.key === 'Delete' || event.key === 'Backspace') {
+        // Delete on Windows, Backspace on macOS
         _reason = GridRowEditStartReasons.deleteKeyDown;
       }
 
@@ -218,7 +223,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
     var ignoreModifications = reason === 'escapeKeyDown';
     var editingState = gridEditRowsStateSelector(apiRef.current.state);
 
-    if (!ignoreModifications) {
+    if (!ignoreModifications && !props.disableIgnoreModificationsIfProcessingProps) {
       // The user wants to stop editing the cell but we can't wait for the props to be processed.
       // In this case, discard the modifications if any field is processing its props.
       ignoreModifications = Object.values(editingState[id]).some(function (fieldProps) {
@@ -232,7 +237,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
       field: field,
       cellToFocusAfter: cellToFocusAfter
     });
-  }, [apiRef]);
+  }, [apiRef, props.disableIgnoreModificationsIfProcessingProps]);
   useGridApiEventHandler(apiRef, 'cellDoubleClick', runIfEditModeIsRow(handleCellDoubleClick));
   useGridApiEventHandler(apiRef, 'cellFocusIn', runIfEditModeIsRow(handleCellFocusIn));
   useGridApiEventHandler(apiRef, 'cellFocusOut', runIfEditModeIsRow(handleCellFocusOut));
@@ -265,10 +270,11 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
     }
 
     setRowModesModel(newModel);
+    rowModesModelRef.current = newModel;
     apiRef.current.publishEvent('rowModesModelChange', newModel);
   }, [apiRef, onRowModesModelChange, props.rowModesModel, signature]);
   var updateRowInRowModesModel = React.useCallback(function (id, newProps) {
-    var newModel = _extends({}, rowModesModel);
+    var newModel = _extends({}, rowModesModelRef.current);
 
     if (newProps !== null) {
       newModel[id] = _extends({}, newProps);
@@ -277,7 +283,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
     }
 
     updateRowModesModel(newModel);
-  }, [rowModesModel, updateRowModesModel]);
+  }, [updateRowModesModel]);
   var updateOrDeleteRowState = React.useCallback(function (id, newProps) {
     apiRef.current.setState(function (state) {
       var newEditingState = _extends({}, state.editRows);

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

@@ -1,6 +1,7 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import { gridColumnDefinitionsSelector, gridVisibleColumnDefinitionsSelector } from '../columns';
 import { gridFilteredSortedRowIdsSelector } from '../filter';
-import { gridRowTreeSelector } from '../rows/gridRowsSelector';
+import { gridPinnedRowsSelector, gridRowTreeSelector } from '../rows/gridRowsSelector';
 export var getColumnsToExport = function getColumnsToExport(_ref) {
   var apiRef = _ref.apiRef,
       options = _ref.options;
@@ -22,6 +23,8 @@ export var getColumnsToExport = function getColumnsToExport(_ref) {
   });
 };
 export var defaultGetRowsToExport = function defaultGetRowsToExport(_ref2) {
+  var _pinnedRows$top, _pinnedRows$bottom;
+
   var apiRef = _ref2.apiRef;
   var filteredSortedRowIds = gridFilteredSortedRowIdsSelector(apiRef);
   var rowTree = gridRowTreeSelector(apiRef);
@@ -31,6 +34,15 @@ export var defaultGetRowsToExport = function defaultGetRowsToExport(_ref2) {
 
     return ((_rowTree$id$position = rowTree[id].position) != null ? _rowTree$id$position : 'body') === 'body';
   });
+  var pinnedRows = gridPinnedRowsSelector(apiRef);
+  var topPinnedRowsIds = (pinnedRows == null ? void 0 : (_pinnedRows$top = pinnedRows.top) == null ? void 0 : _pinnedRows$top.map(function (row) {
+    return row.id;
+  })) || [];
+  var bottomPinnedRowsIds = (pinnedRows == null ? void 0 : (_pinnedRows$bottom = pinnedRows.bottom) == null ? void 0 : _pinnedRows$bottom.map(function (row) {
+    return row.id;
+  })) || [];
+  bodyRows.unshift.apply(bodyRows, _toConsumableArray(topPinnedRowsIds));
+  bodyRows.push.apply(bodyRows, _toConsumableArray(bottomPinnedRowsIds));
 
   if (selectedRows.size > 0) {
     return bodyRows.filter(function (id) {

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

@@ -1,8 +1,8 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { GridLinkOperator } from '../../../models';
+import { getDefaultGridFilterModel } from './gridFilterState';
 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.
@@ -87,10 +87,7 @@ export var mergeStateWithFilterModel = function mergeStateWithFilterModel(filter
  */
 
 export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterItemsApplier(filterModel, apiRef) {
-  var items = filterModel.items,
-      _filterModel$linkOper = filterModel.linkOperator,
-      linkOperator = _filterModel$linkOper === void 0 ? GridLinkOperator.And : _filterModel$linkOper;
-  var tree = gridRowTreeSelector(apiRef);
+  var items = filterModel.items;
 
   var getFilterCallbackFromItem = function getFilterCallbackFromItem(filterItem) {
     if (!filterItem.columnField || !filterItem.operatorValue) {
@@ -160,24 +157,14 @@ export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterIte
   }
 
   return function (rowId, shouldApplyFilter) {
-    if (tree[rowId].position === 'footer') {
-      return true;
-    }
-
+    var resultPerItemId = {};
     var filteredAppliers = shouldApplyFilter ? appliers.filter(function (applier) {
       return shouldApplyFilter(applier.item.columnField);
-    }) : appliers; // Return `false` as soon as we have a failing filter
-
-    if (linkOperator === GridLinkOperator.And) {
-      return filteredAppliers.every(function (applier) {
-        return applier.fn(rowId);
-      });
-    } // Return `true` as soon as we have a passing filter
-
-
-    return filteredAppliers.some(function (applier) {
-      return applier.fn(rowId);
+    }) : appliers;
+    filteredAppliers.forEach(function (applier) {
+      resultPerItemId[applier.item.id] = applier.fn(rowId);
     });
+    return resultPerItemId;
   };
 };
 /**
@@ -189,9 +176,7 @@ export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterIte
 
 export var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilterApplier(filterModel, apiRef) {
   var _filterModel$quickFil = filterModel.quickFilterValues,
-      quickFilterValues = _filterModel$quickFil === void 0 ? [] : _filterModel$quickFil,
-      _filterModel$quickFil2 = filterModel.quickFilterLogicOperator,
-      quickFilterLogicOperator = _filterModel$quickFil2 === void 0 ? GridLinkOperator.And : _filterModel$quickFil2;
+      quickFilterValues = _filterModel$quickFil === void 0 ? [] : _filterModel$quickFil;
 
   if (quickFilterValues.length === 0) {
     return null;
@@ -217,6 +202,11 @@ export var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilt
       return appliersPerColumnField[field][index] != null;
     });
   });
+
+  if (sanitizedQuickFilterValues.length === 0) {
+    return null;
+  }
+
   return function (rowId, shouldApplyFilter) {
     var usedCellParams = {};
     var columnsFieldsToFilter = [];
@@ -225,53 +215,92 @@ export var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilt
         usedCellParams[columnField] = apiRef.current.getCellParams(rowId, columnField);
         columnsFieldsToFilter.push(columnField);
       }
-    }); // Return `false` as soon as we have a quick filter value that does not match any column
-
-    if (quickFilterLogicOperator === GridLinkOperator.And) {
-      return sanitizedQuickFilterValues.every(function (value, index) {
-        return columnsFieldsToFilter.some(function (field) {
-          var _appliersPerColumnFie, _appliersPerColumnFie2;
-
-          if (appliersPerColumnField[field][index] == null) {
-            return false;
-          }
-
-          return (_appliersPerColumnFie = (_appliersPerColumnFie2 = appliersPerColumnField[field])[index]) == null ? void 0 : _appliersPerColumnFie.call(_appliersPerColumnFie2, usedCellParams[field]);
-        });
-      });
-    } // Return `true` as soon as we have have a quick filter value that match any column
-
-
-    return sanitizedQuickFilterValues.some(function (value, index) {
-      return columnsFieldsToFilter.some(function (field) {
-        var _appliersPerColumnFie3, _appliersPerColumnFie4;
+    });
+    var quickFilterValueResult = {};
+    sanitizedQuickFilterValues.forEach(function (value, index) {
+      var isPassing = columnsFieldsToFilter.some(function (field) {
+        var _appliersPerColumnFie, _appliersPerColumnFie2;
 
         if (appliersPerColumnField[field][index] == null) {
           return false;
         }
 
-        return (_appliersPerColumnFie3 = (_appliersPerColumnFie4 = appliersPerColumnField[field])[index]) == null ? void 0 : _appliersPerColumnFie3.call(_appliersPerColumnFie4, usedCellParams[field]);
+        return (_appliersPerColumnFie = (_appliersPerColumnFie2 = appliersPerColumnField[field])[index]) == null ? void 0 : _appliersPerColumnFie.call(_appliersPerColumnFie2, usedCellParams[field]);
       });
+      quickFilterValueResult[value] = isPassing;
     });
+    return quickFilterValueResult;
   };
 };
 export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(filterModel, apiRef) {
   var isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(filterModel, apiRef);
   var isRowMatchingQuickFilter = buildAggregatedQuickFilterApplier(filterModel, apiRef);
+  return function (rowId, shouldApplyFilter) {
+    return {
+      passingFilterItems: isRowMatchingFilterItems && isRowMatchingFilterItems(rowId, shouldApplyFilter),
+      passingQuickFilterValues: isRowMatchingQuickFilter && isRowMatchingQuickFilter(rowId, shouldApplyFilter)
+    };
+  };
+};
+export var passFilterLogic = function passFilterLogic(allFilterItemResults, allQuickFilterResults, filterModel) {
+  var _filterModel$quickFil2, _filterModel$linkOper;
 
-  if (isRowMatchingFilterItems == null && isRowMatchingQuickFilter == null) {
-    return null;
-  }
+  var cleanedAllFilterItemResults = allFilterItemResults.filter(function (result) {
+    return result != null;
+  });
+  var cleanedAllQuickFilterResults = allQuickFilterResults.filter(function (result) {
+    return result != null;
+  }); // Defaultize operators
+
+  var quickFilterLogicOperator = (_filterModel$quickFil2 = filterModel.quickFilterLogicOperator) != null ? _filterModel$quickFil2 : getDefaultGridFilterModel().quickFilterLogicOperator;
+  var linkOperator = (_filterModel$linkOper = filterModel.linkOperator) != null ? _filterModel$linkOper : getDefaultGridFilterModel().linkOperator; // get result for filter items model
+
+  if (cleanedAllFilterItemResults.length > 0) {
+    // Return true if the item pass with one of the rows
+    var filterItemPredicate = function filterItemPredicate(item) {
+      return cleanedAllFilterItemResults.some(function (filterItemResult) {
+        return filterItemResult[item.id];
+      });
+    };
+
+    if (linkOperator === GridLinkOperator.And) {
+      var passesAllFilters = filterModel.items.every(filterItemPredicate);
+
+      if (!passesAllFilters) {
+        return false;
+      }
+    } else {
+      var passesSomeFilters = filterModel.items.some(filterItemPredicate);
+
+      if (!passesSomeFilters) {
+        return false;
+      }
+    }
+  } // get result for quick filter model
 
-  if (isRowMatchingFilterItems == null) {
-    return isRowMatchingQuickFilter;
-  }
 
-  if (isRowMatchingQuickFilter == null) {
-    return isRowMatchingFilterItems;
+  if (cleanedAllQuickFilterResults.length > 0 && filterModel.quickFilterValues != null) {
+    // Return true if the item pass with one of the rows
+    var quickFilterValuePredicate = function quickFilterValuePredicate(value) {
+      return cleanedAllQuickFilterResults.some(function (quickFilterValueResult) {
+        return quickFilterValueResult[value];
+      });
+    };
+
+    if (quickFilterLogicOperator === GridLinkOperator.And) {
+      var passesAllQuickFilterValues = filterModel.quickFilterValues.every(quickFilterValuePredicate);
+
+      if (!passesAllQuickFilterValues) {
+        return false;
+      }
+    } else {
+      var passesSomeQuickFilterValues = filterModel.quickFilterValues.some(quickFilterValuePredicate);
+
+      if (!passesSomeQuickFilterValues) {
+        return false;
+      }
+    }
   }
 
-  return function (rowId, shouldApplyFilter) {
-    return isRowMatchingFilterItems(rowId, shouldApplyFilter) && isRowMatchingQuickFilter(rowId, shouldApplyFilter);
-  };
+  return true;
 };

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

@@ -13,7 +13,7 @@ import { useFirstRender } from '../../utils/useFirstRender';
 import { gridRowIdsSelector } from '../rows';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
 import { GRID_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from '../../core/strategyProcessing';
-import { buildAggregatedFilterApplier, sanitizeFilterModel, mergeStateWithFilterModel, cleanFilterItem } from './gridFilterUtils';
+import { buildAggregatedFilterApplier, sanitizeFilterModel, mergeStateWithFilterModel, cleanFilterItem, passFilterLogic } from './gridFilterUtils';
 import { isDeepEqual } from '../../../utils/utils';
 import { jsx as _jsx } from "react/jsx-runtime";
 export var filterStateInitializer = function filterStateInitializer(state, props, apiRef) {
@@ -50,7 +50,8 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
       var filterModel = gridFilterModelSelector(state, apiRef.current.instanceId);
       var isRowMatchingFilters = props.filterMode === GridFeatureModeConstant.client ? buildAggregatedFilterApplier(filterModel, apiRef) : null;
       var filteringResult = apiRef.current.unstable_applyStrategyProcessor('filtering', {
-        isRowMatchingFilters: isRowMatchingFilters
+        isRowMatchingFilters: isRowMatchingFilters,
+        filterModel: filterModel != null ? filterModel : getDefaultGridFilterModel()
       });
       return _extends({}, state, {
         filter: _extends({}, state.filter, filteringResult)
@@ -278,7 +279,19 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
 
       for (var i = 0; i < rowIds.length; i += 1) {
         var rowId = rowIds[i];
-        filteredRowsLookup[rowId] = params.isRowMatchingFilters(rowId);
+        var isRowPassing = void 0;
+
+        if (typeof rowId === 'string' && rowId.startsWith('auto-generated-group-footer')) {
+          isRowPassing = true;
+        } else {
+          var _params$isRowMatching = params.isRowMatchingFilters(rowId),
+              passingFilterItems = _params$isRowMatching.passingFilterItems,
+              passingQuickFilterValues = _params$isRowMatching.passingQuickFilterValues;
+
+          isRowPassing = passFilterLogic([passingFilterItems], [passingQuickFilterValues], params.filterModel);
+        }
+
+        filteredRowsLookup[rowId] = isRowPassing;
       }
 
       return {

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

@@ -62,6 +62,12 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
       return;
     }
 
+    if (focusedCell) {
+      // There's a focused cell but another cell was clicked
+      // Publishes an event to notify that the focus was lost
+      apiRef.current.publishEvent('cellFocusOut', apiRef.current.getCellParams(focusedCell.id, focusedCell.field));
+    }
+
     apiRef.current.publishEvent('cellFocusIn', apiRef.current.getCellParams(id, field));
   }, [apiRef, logger]);
   var setColumnHeaderFocus = React.useCallback(function (field) {
@@ -195,11 +201,7 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
 
     if (!apiRef.current.getRow(focusedCell.id)) {
       return;
-    } // There's a focused cell but another cell was clicked
-    // Publishes an event to notify that the focus was lost
-
-
-    apiRef.current.publishEvent('cellFocusOut', apiRef.current.getCellParams(focusedCell.id, focusedCell.field), event);
+    }
 
     if (cellParams) {
       apiRef.current.setCellFocus(cellParams.id, cellParams.field);
@@ -212,7 +214,10 @@ export var useGridFocus = function useGridFocus(apiRef, props) {
           }
         });
       });
-      apiRef.current.forceUpdate();
+      apiRef.current.forceUpdate(); // There's a focused cell but another element (not a cell) was clicked
+      // Publishes an event to notify that the focus was lost
+
+      apiRef.current.publishEvent('cellFocusOut', apiRef.current.getCellParams(focusedCell.id, focusedCell.field), event);
     }
   }, [apiRef]);
   var handleCellModeChange = React.useCallback(function (params) {