@mui/x-data-grid 6.0.3 → 6.1.0

package/legacy/hooks/features/columnMenu/{useGridColumnMenuComponents.js → useGridColumnMenuSlots.js}

@@ -6,54 +6,49 @@ var _excluded = ["displayOrder"];
 import * as React from 'react';
 import Divider from '@mui/material/Divider';
 import { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';
-var camelize = function camelize(pascalCase) {
-  var camelCase = pascalCase.split('');
-  camelCase[0] = camelCase[0].toLowerCase();
-  return camelCase.join('');
-};
-var useGridColumnMenuComponents = function useGridColumnMenuComponents(props) {
+var useGridColumnMenuSlots = function useGridColumnMenuSlots(props) {
   var apiRef = useGridPrivateApiContext();
-  var defaultComponents = props.defaultComponents,
-    defaultComponentsProps = props.defaultComponentsProps,
-    _props$components = props.components,
-    components = _props$components === void 0 ? {} : _props$components,
-    _props$componentsProp = props.componentsProps,
-    componentsProps = _props$componentsProp === void 0 ? {} : _props$componentsProp,
+  var defaultSlots = props.defaultSlots,
+    defaultSlotProps = props.defaultSlotProps,
+    _props$slots = props.slots,
+    slots = _props$slots === void 0 ? {} : _props$slots,
+    _props$slotProps = props.slotProps,
+    slotProps = _props$slotProps === void 0 ? {} : _props$slotProps,
     hideMenu = props.hideMenu,
     colDef = props.colDef,
     _props$addDividers = props.addDividers,
     addDividers = _props$addDividers === void 0 ? true : _props$addDividers;
   var processedComponents = React.useMemo(function () {
-    return _extends({}, defaultComponents, components);
-  }, [defaultComponents, components]);
-  var processedComponentsProps = React.useMemo(function () {
-    if (!componentsProps || Object.keys(componentsProps).length === 0) {
-      return defaultComponentsProps;
+    return _extends({}, defaultSlots, slots);
+  }, [defaultSlots, slots]);
+  var processedSlotProps = React.useMemo(function () {
+    if (!slotProps || Object.keys(slotProps).length === 0) {
+      return defaultSlotProps;
     }
-    var mergedProps = _extends({}, componentsProps);
-    Object.entries(defaultComponentsProps).forEach(function (_ref) {
+    var mergedProps = _extends({}, slotProps);
+    Object.entries(defaultSlotProps).forEach(function (_ref) {
       var _ref2 = _slicedToArray(_ref, 2),
         key = _ref2[0],
-        currentComponentProps = _ref2[1];
-      mergedProps[key] = _extends({}, currentComponentProps, componentsProps[key] || {});
+        currentSlotProps = _ref2[1];
+      mergedProps[key] = _extends({}, currentSlotProps, slotProps[key] || {});
     });
     return mergedProps;
-  }, [defaultComponentsProps, componentsProps]);
+  }, [defaultSlotProps, slotProps]);
   var defaultItems = apiRef.current.unstable_applyPipeProcessors('columnMenu', [], props.colDef);
   var userItems = React.useMemo(function () {
-    var defaultComponentKeys = Object.keys(defaultComponents);
-    return Object.keys(components).filter(function (key) {
+    var defaultComponentKeys = Object.keys(defaultSlots);
+    return Object.keys(slots).filter(function (key) {
       return !defaultComponentKeys.includes(key);
     });
-  }, [components, defaultComponents]);
+  }, [slots, defaultSlots]);
   return React.useMemo(function () {
     var uniqueItems = Array.from(new Set([].concat(_toConsumableArray(defaultItems), _toConsumableArray(userItems))));
     var cleansedItems = uniqueItems.filter(function (key) {
       return processedComponents[key] != null;
     });
     var sorted = cleansedItems.sort(function (a, b) {
-      var leftItemProps = processedComponentsProps[camelize(a)];
-      var rightItemProps = processedComponentsProps[camelize(b)];
+      var leftItemProps = processedSlotProps[a];
+      var rightItemProps = processedSlotProps[b];
       var leftDisplayOrder = Number.isFinite(leftItemProps == null ? void 0 : leftItemProps.displayOrder) ? leftItemProps.displayOrder : 100;
       var rightDisplayOrder = Number.isFinite(rightItemProps == null ? void 0 : rightItemProps.displayOrder) ? rightItemProps.displayOrder : 100;
       return leftDisplayOrder - rightDisplayOrder;
@@ -63,7 +58,7 @@ var useGridColumnMenuComponents = function useGridColumnMenuComponents(props) {
         colDef: colDef,
         onClick: hideMenu
       };
-      var processedComponentProps = processedComponentsProps[camelize(key)];
+      var processedComponentProps = processedSlotProps[key];
       if (processedComponentProps) {
         var displayOrder = processedComponentProps.displayOrder,
           customProps = _objectWithoutProperties(processedComponentProps, _excluded);
@@ -71,6 +66,6 @@ var useGridColumnMenuComponents = function useGridColumnMenuComponents(props) {
       }
       return addDividers && index !== sorted.length - 1 ? [].concat(_toConsumableArray(acc), [[processedComponents[key], itemProps], [Divider, {}]]) : [].concat(_toConsumableArray(acc), [[processedComponents[key], itemProps]]);
     }, []);
-  }, [addDividers, colDef, defaultItems, hideMenu, processedComponents, processedComponentsProps, userItems]);
+  }, [addDividers, colDef, defaultItems, hideMenu, processedComponents, processedSlotProps, userItems]);
 };
-export { useGridColumnMenuComponents };
+export { useGridColumnMenuSlots };

package/legacy/hooks/features/columns/gridColumnsUtils.js

@@ -183,7 +183,7 @@ export var applyInitialState = function applyInitialState(columnsState, initialS
     return !orderedFieldsLookup[field];
   })));
   var newColumnLookup = _extends({}, columnsState.lookup);
-  var _loop = function _loop(_i) {
+  var _loop = function _loop() {
     var field = columnsWithUpdatedDimensions[_i];
     var newColDef = _extends({}, newColumnLookup[field], {
       hasBeenResized: true
@@ -197,7 +197,7 @@ export var applyInitialState = function applyInitialState(columnsState, initialS
     newColumnLookup[field] = newColDef;
   };
   for (var _i = 0; _i < columnsWithUpdatedDimensions.length; _i += 1) {
-    _loop(_i);
+    _loop();
   }
   var newColumnsState = _extends({}, columnsState, {
     orderedFields: newOrderedFields,

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

@@ -245,7 +245,7 @@ export function useGridColumns(apiRef, props) {
     if (props.disableColumnSelector) {
       return columnMenuItems;
     }
-    return [].concat(_toConsumableArray(columnMenuItems), ['ColumnMenuColumnsItem']);
+    return [].concat(_toConsumableArray(columnMenuItems), ['columnMenuColumnsItem']);
   }, [props.disableColumnSelector]);
   useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItems);
   useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);

package/legacy/hooks/features/editing/useGridCellEditing.js

@@ -238,13 +238,17 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
       deleteValue = params.deleteValue,
       initialValue = params.initialValue;
     var newValue = apiRef.current.getCellValue(id, field);
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    var unstable_updateValueOnRender = false;
     if (deleteValue || initialValue) {
       newValue = deleteValue ? '' : initialValue;
+      unstable_updateValueOnRender = true;
     }
     var newProps = {
       value: newValue,
       error: false,
-      isProcessingProps: false
+      isProcessingProps: false,
+      unstable_updateValueOnRender: unstable_updateValueOnRender
     };
     updateOrDeleteFieldState(id, field, newProps);
     apiRef.current.setCellFocus(id, field);
@@ -262,72 +266,70 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(params) {
       var id, field, ignoreModifications, _params$cellToFocusAf, cellToFocusAfter, finishCellEditMode, editingState, _editingState$id$fiel, error, isProcessingProps, rowUpdate, handleError, row;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              id = params.id, field = params.field, ignoreModifications = params.ignoreModifications, _params$cellToFocusAf = params.cellToFocusAfter, cellToFocusAfter = _params$cellToFocusAf === void 0 ? 'none' : _params$cellToFocusAf;
-              throwIfNotInMode(id, field, GridCellModes.Edit);
-              apiRef.current.runPendingEditCellValueMutation(id, field);
-              finishCellEditMode = function finishCellEditMode() {
-                updateOrDeleteFieldState(id, field, null);
-                updateFieldInCellModesModel(id, field, null);
-                if (cellToFocusAfter !== 'none') {
-                  apiRef.current.moveFocusToRelativeCell(id, field, cellToFocusAfter);
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            id = params.id, field = params.field, ignoreModifications = params.ignoreModifications, _params$cellToFocusAf = params.cellToFocusAfter, cellToFocusAfter = _params$cellToFocusAf === void 0 ? 'none' : _params$cellToFocusAf;
+            throwIfNotInMode(id, field, GridCellModes.Edit);
+            apiRef.current.runPendingEditCellValueMutation(id, field);
+            finishCellEditMode = function finishCellEditMode() {
+              updateOrDeleteFieldState(id, field, null);
+              updateFieldInCellModesModel(id, field, null);
+              if (cellToFocusAfter !== 'none') {
+                apiRef.current.moveFocusToRelativeCell(id, field, cellToFocusAfter);
+              }
+            };
+            if (!ignoreModifications) {
+              _context.next = 7;
+              break;
+            }
+            finishCellEditMode();
+            return _context.abrupt("return");
+          case 7:
+            editingState = gridEditRowsStateSelector(apiRef.current.state);
+            _editingState$id$fiel = editingState[id][field], error = _editingState$id$fiel.error, isProcessingProps = _editingState$id$fiel.isProcessingProps;
+            if (!(error || isProcessingProps)) {
+              _context.next = 13;
+              break;
+            }
+            // Attempt to change cell mode to "view" was not successful
+            // Update previous mode to allow another attempt
+            prevCellModesModel.current[id][field].mode = GridCellModes.Edit;
+            // Revert the mode in the cellModesModel prop back to "edit"
+            updateFieldInCellModesModel(id, field, {
+              mode: GridCellModes.Edit
+            });
+            return _context.abrupt("return");
+          case 13:
+            rowUpdate = apiRef.current.getRowWithUpdatedValuesFromCellEditing(id, field);
+            if (processRowUpdate) {
+              handleError = function handleError(errorThrown) {
+                prevCellModesModel.current[id][field].mode = GridCellModes.Edit;
+                // Revert the mode in the cellModesModel prop back to "edit"
+                updateFieldInCellModesModel(id, field, {
+                  mode: GridCellModes.Edit
+                });
+                if (onProcessRowUpdateError) {
+                  onProcessRowUpdateError(errorThrown);
+                } else {
+                  missingOnProcessRowUpdateErrorWarning();
                 }
               };
-              if (!ignoreModifications) {
-                _context.next = 7;
-                break;
+              try {
+                row = apiRef.current.getRow(id);
+                Promise.resolve(processRowUpdate(rowUpdate, row)).then(function (finalRowUpdate) {
+                  apiRef.current.updateRows([finalRowUpdate]);
+                  finishCellEditMode();
+                }).catch(handleError);
+              } catch (errorThrown) {
+                handleError(errorThrown);
               }
+            } else {
+              apiRef.current.updateRows([rowUpdate]);
               finishCellEditMode();
-              return _context.abrupt("return");
-            case 7:
-              editingState = gridEditRowsStateSelector(apiRef.current.state);
-              _editingState$id$fiel = editingState[id][field], error = _editingState$id$fiel.error, isProcessingProps = _editingState$id$fiel.isProcessingProps;
-              if (!(error || isProcessingProps)) {
-                _context.next = 13;
-                break;
-              }
-              // Attempt to change cell mode to "view" was not successful
-              // Update previous mode to allow another attempt
-              prevCellModesModel.current[id][field].mode = GridCellModes.Edit;
-              // Revert the mode in the cellModesModel prop back to "edit"
-              updateFieldInCellModesModel(id, field, {
-                mode: GridCellModes.Edit
-              });
-              return _context.abrupt("return");
-            case 13:
-              rowUpdate = apiRef.current.getRowWithUpdatedValuesFromCellEditing(id, field);
-              if (processRowUpdate) {
-                handleError = function handleError(errorThrown) {
-                  prevCellModesModel.current[id][field].mode = GridCellModes.Edit;
-                  // Revert the mode in the cellModesModel prop back to "edit"
-                  updateFieldInCellModesModel(id, field, {
-                    mode: GridCellModes.Edit
-                  });
-                  if (onProcessRowUpdateError) {
-                    onProcessRowUpdateError(errorThrown);
-                  } else {
-                    missingOnProcessRowUpdateErrorWarning();
-                  }
-                };
-                try {
-                  row = apiRef.current.getRow(id);
-                  Promise.resolve(processRowUpdate(rowUpdate, row)).then(function (finalRowUpdate) {
-                    apiRef.current.updateRows([finalRowUpdate]);
-                    finishCellEditMode();
-                  }).catch(handleError);
-                } catch (errorThrown) {
-                  handleError(errorThrown);
-                }
-              } else {
-                apiRef.current.updateRows([rowUpdate]);
-                finishCellEditMode();
-              }
-            case 15:
-            case "end":
-              return _context.stop();
-          }
+            }
+          case 15:
+          case "end":
+            return _context.stop();
         }
       }, _callee);
     }));
@@ -340,63 +342,61 @@ export var useGridCellEditing = function useGridCellEditing(apiRef, props) {
       var _editingState$id, _editingState$id$fiel2;
       var id, field, value, debounceMs, skipValueParser, column, row, parsedValue, editingState, newProps, hasChanged;
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-        while (1) {
-          switch (_context2.prev = _context2.next) {
-            case 0:
-              id = params.id, field = params.field, value = params.value, debounceMs = params.debounceMs, skipValueParser = params.unstable_skipValueParser;
-              throwIfNotEditable(id, field);
-              throwIfNotInMode(id, field, GridCellModes.Edit);
-              column = apiRef.current.getColumn(field);
-              row = apiRef.current.getRow(id);
-              parsedValue = value;
-              if (column.valueParser && !skipValueParser) {
-                parsedValue = column.valueParser(value, apiRef.current.getCellParams(id, field));
-              }
-              editingState = gridEditRowsStateSelector(apiRef.current.state);
-              newProps = _extends({}, editingState[id][field], {
-                value: parsedValue,
-                changeReason: debounceMs ? 'debouncedSetEditCellValue' : 'setEditCellValue'
-              });
-              if (!column.preProcessEditCellProps) {
-                _context2.next = 16;
-                break;
-              }
-              hasChanged = value !== editingState[id][field].value;
-              newProps = _extends({}, newProps, {
-                isProcessingProps: true
-              });
-              updateOrDeleteFieldState(id, field, newProps);
-              _context2.next = 15;
-              return Promise.resolve(column.preProcessEditCellProps({
-                id: id,
-                row: row,
-                props: newProps,
-                hasChanged: hasChanged
-              }));
-            case 15:
-              newProps = _context2.sent;
-            case 16:
-              if (!(apiRef.current.getCellMode(id, field) === GridCellModes.View)) {
-                _context2.next = 18;
-                break;
-              }
-              return _context2.abrupt("return", false);
-            case 18:
-              editingState = gridEditRowsStateSelector(apiRef.current.state);
-              newProps = _extends({}, newProps, {
-                isProcessingProps: false
-              });
-              // We don't update the value with the one coming from the props pre-processing
-              // because when the promise resolves it may be already outdated. The only
-              // exception to this rule is when there's no pre-processing.
-              newProps.value = column.preProcessEditCellProps ? editingState[id][field].value : parsedValue;
-              updateOrDeleteFieldState(id, field, newProps);
-              editingState = gridEditRowsStateSelector(apiRef.current.state);
-              return _context2.abrupt("return", !((_editingState$id = editingState[id]) != null && (_editingState$id$fiel2 = _editingState$id[field]) != null && _editingState$id$fiel2.error));
-            case 24:
-            case "end":
-              return _context2.stop();
-          }
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            id = params.id, field = params.field, value = params.value, debounceMs = params.debounceMs, skipValueParser = params.unstable_skipValueParser;
+            throwIfNotEditable(id, field);
+            throwIfNotInMode(id, field, GridCellModes.Edit);
+            column = apiRef.current.getColumn(field);
+            row = apiRef.current.getRow(id);
+            parsedValue = value;
+            if (column.valueParser && !skipValueParser) {
+              parsedValue = column.valueParser(value, apiRef.current.getCellParams(id, field));
+            }
+            editingState = gridEditRowsStateSelector(apiRef.current.state);
+            newProps = _extends({}, editingState[id][field], {
+              value: parsedValue,
+              changeReason: debounceMs ? 'debouncedSetEditCellValue' : 'setEditCellValue'
+            });
+            if (!column.preProcessEditCellProps) {
+              _context2.next = 16;
+              break;
+            }
+            hasChanged = value !== editingState[id][field].value;
+            newProps = _extends({}, newProps, {
+              isProcessingProps: true
+            });
+            updateOrDeleteFieldState(id, field, newProps);
+            _context2.next = 15;
+            return Promise.resolve(column.preProcessEditCellProps({
+              id: id,
+              row: row,
+              props: newProps,
+              hasChanged: hasChanged
+            }));
+          case 15:
+            newProps = _context2.sent;
+          case 16:
+            if (!(apiRef.current.getCellMode(id, field) === GridCellModes.View)) {
+              _context2.next = 18;
+              break;
+            }
+            return _context2.abrupt("return", false);
+          case 18:
+            editingState = gridEditRowsStateSelector(apiRef.current.state);
+            newProps = _extends({}, newProps, {
+              isProcessingProps: false
+            });
+            // We don't update the value with the one coming from the props pre-processing
+            // because when the promise resolves it may be already outdated. The only
+            // exception to this rule is when there's no pre-processing.
+            newProps.value = column.preProcessEditCellProps ? editingState[id][field].value : parsedValue;
+            updateOrDeleteFieldState(id, field, newProps);
+            editingState = gridEditRowsStateSelector(apiRef.current.state);
+            return _context2.abrupt("return", !((_editingState$id = editingState[id]) != null && (_editingState$id$fiel2 = _editingState$id[field]) != null && _editingState$id$fiel2.error));
+          case 24:
+          case "end":
+            return _context2.stop();
         }
       }, _callee2);
     }));

package/legacy/hooks/features/editing/useGridEditing.js

@@ -105,24 +105,22 @@ export var useGridEditing = function useGridEditing(apiRef, props) {
       maybeDebounce(id, field, debounceMs, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
         var setEditCellValueToCall, result;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                setEditCellValueToCall = props.editMode === GridEditModes.Row ? apiRef.current.setRowEditingEditCellValue : apiRef.current.setCellEditingEditCellValue; // Check if the cell is in edit mode
-                // By the time this callback runs the user may have cancelled the editing
-                if (!(apiRef.current.getCellMode(id, field) === GridCellModes.Edit)) {
-                  _context.next = 6;
-                  break;
-                }
-                _context.next = 4;
-                return setEditCellValueToCall(params);
-              case 4:
-                result = _context.sent;
-                resolve(result);
-              case 6:
-              case "end":
-                return _context.stop();
-            }
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              setEditCellValueToCall = props.editMode === GridEditModes.Row ? apiRef.current.setRowEditingEditCellValue : apiRef.current.setCellEditingEditCellValue; // Check if the cell is in edit mode
+              // By the time this callback runs the user may have cancelled the editing
+              if (!(apiRef.current.getCellMode(id, field) === GridCellModes.Edit)) {
+                _context.next = 6;
+                break;
+              }
+              _context.next = 4;
+              return setEditCellValueToCall(params);
+            case 4:
+              result = _context.sent;
+              resolve(result);
+            case 6:
+            case "end":
+              return _context.stop();
           }
         }, _callee);
       })));
@@ -133,9 +131,7 @@ export var useGridEditing = function useGridEditing(apiRef, props) {
   }, [apiRef, props.editMode]);
   var getEditCellMeta = React.useCallback(function (id, field) {
     var editingState = gridEditRowsStateSelector(apiRef.current.state);
-    return {
-      changeReason: editingState[id][field].changeReason
-    };
+    return editingState[id][field];
   }, [apiRef]);
   var editingSharedApi = {
     isCellEditable: isCellEditable,

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

@@ -310,13 +310,17 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
         return acc;
       }
       var newValue = apiRef.current.getCellValue(id, field);
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      var unstable_updateValueOnRender = false;
       if (fieldToFocus === field && (deleteValue || initialValue)) {
         newValue = deleteValue ? '' : initialValue;
+        unstable_updateValueOnRender = true;
       }
       acc[field] = {
         value: newValue,
         error: false,
-        isProcessingProps: false
+        isProcessingProps: false,
+        unstable_updateValueOnRender: unstable_updateValueOnRender
       };
       return acc;
     }, {});

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

@@ -190,54 +190,52 @@ export var useGridPrintExport = function useGridPrintExport(apiRef, props) {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
       var visibleRowCount, printWindow;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              logger.debug("Export data as Print");
-              if (apiRef.current.rootElementRef.current) {
-                _context.next = 3;
-                break;
-              }
-              throw new Error('MUI: No grid root element available.');
-            case 3:
-              previousGridState.current = apiRef.current.exportState();
-              // It appends that the visibility model is not exported, especially if columnVisibility is not controlled
-              previousColumnVisibility.current = gridColumnVisibilityModelSelector(apiRef);
-              if (props.pagination) {
-                visibleRowCount = gridExpandedRowCountSelector(apiRef);
-                apiRef.current.setPageSize(visibleRowCount);
-              }
-              _context.next = 8;
-              return updateGridColumnsForPrint(options == null ? void 0 : options.fields, options == null ? void 0 : options.allColumns);
-            case 8:
-              apiRef.current.unstable_disableVirtualization();
-              _context.next = 11;
-              return raf();
-            case 11:
-              // wait for the state changes to take action
-              printWindow = buildPrintWindow(options == null ? void 0 : options.fileName);
-              if (process.env.NODE_ENV === 'test') {
-                doc.current.body.appendChild(printWindow);
-                // In test env, run the all pipeline without waiting for loading
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            logger.debug("Export data as Print");
+            if (apiRef.current.rootElementRef.current) {
+              _context.next = 3;
+              break;
+            }
+            throw new Error('MUI: No grid root element available.');
+          case 3:
+            previousGridState.current = apiRef.current.exportState();
+            // It appends that the visibility model is not exported, especially if columnVisibility is not controlled
+            previousColumnVisibility.current = gridColumnVisibilityModelSelector(apiRef);
+            if (props.pagination) {
+              visibleRowCount = gridExpandedRowCountSelector(apiRef);
+              apiRef.current.setPageSize(visibleRowCount);
+            }
+            _context.next = 8;
+            return updateGridColumnsForPrint(options == null ? void 0 : options.fields, options == null ? void 0 : options.allColumns);
+          case 8:
+            apiRef.current.unstable_disableVirtualization();
+            _context.next = 11;
+            return raf();
+          case 11:
+            // wait for the state changes to take action
+            printWindow = buildPrintWindow(options == null ? void 0 : options.fileName);
+            if (process.env.NODE_ENV === 'test') {
+              doc.current.body.appendChild(printWindow);
+              // In test env, run the all pipeline without waiting for loading
+              handlePrintWindowLoad(printWindow, options);
+              handlePrintWindowAfterPrint(printWindow);
+            } else {
+              printWindow.onload = function () {
                 handlePrintWindowLoad(printWindow, options);
-                handlePrintWindowAfterPrint(printWindow);
-              } else {
-                printWindow.onload = function () {
-                  handlePrintWindowLoad(printWindow, options);
-                  var mediaQueryList = printWindow.contentWindow.matchMedia('print');
-                  mediaQueryList.addEventListener('change', function (mql) {
-                    var isAfterPrint = mql.matches === false;
-                    if (isAfterPrint) {
-                      handlePrintWindowAfterPrint(printWindow);
-                    }
-                  });
-                };
-                doc.current.body.appendChild(printWindow);
-              }
-            case 13:
-            case "end":
-              return _context.stop();
-          }
+                var mediaQueryList = printWindow.contentWindow.matchMedia('print');
+                mediaQueryList.addEventListener('change', function (mql) {
+                  var isAfterPrint = mql.matches === false;
+                  if (isAfterPrint) {
+                    handlePrintWindowAfterPrint(printWindow);
+                  }
+                });
+              };
+              doc.current.body.appendChild(printWindow);
+            }
+          case 13:
+          case "end":
+            return _context.stop();
         }
       }, _callee);
     }));

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

@@ -6,4 +6,9 @@ export var getDefaultGridFilterModel = function getDefaultGridFilterModel() {
     quickFilterValues: [],
     quickFilterLogicOperator: GridLogicOperator.And
   };
-};
+};
+
+/**
+ * @param {GridRowId} rowId The id of the row we want to filter.
+ * @param {(filterItem: GridFilterItem) => boolean} shouldApplyItem An optional callback to allow the filtering engine to only apply some items.
+ */

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

@@ -60,7 +60,7 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
     if (colDef == null || colDef.filterable === false || props.disableColumnFilter) {
       return columnMenuItems;
     }
-    return [].concat(_toConsumableArray(columnMenuItems), ['ColumnMenuFilterItem']);
+    return [].concat(_toConsumableArray(columnMenuItems), ['columnMenuFilterItem']);
   }, [props.disableColumnFilter]);
 
   /**
@@ -121,6 +121,11 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
       var filterItemsWithValue = filterModel.items.filter(function (item) {
         var _column$filterOperato;
         if (item.value !== undefined) {
+          // Some filters like `isAnyOf` support array as `item.value`.
+          // If array is empty, we want to remove it from the filter model.
+          if (Array.isArray(item.value) && item.value.length === 0) {
+            return false;
+          }
           return true;
         }
         var column = apiRef.current.getColumn(item.field);

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

@@ -247,7 +247,7 @@ export var updateCacheWithNewRows = function updateCacheWithNewRows(_ref4) {
     dataRowIdToIdLookup[id] = id;
   });
   var actionTypeWithActionsToRemove = Object.keys(alreadyAppliedActionsToRemove);
-  var _loop = function _loop(i) {
+  var _loop = function _loop() {
     var actionType = actionTypeWithActionsToRemove[i];
     var idsToRemove = alreadyAppliedActionsToRemove[actionType];
     if (Object.keys(idsToRemove).length > 0) {
@@ -257,7 +257,7 @@ export var updateCacheWithNewRows = function updateCacheWithNewRows(_ref4) {
     }
   };
   for (var i = 0; i < actionTypeWithActionsToRemove.length; i += 1) {
-    _loop(i);
+    _loop();
   }
   return {
     dataRowIdToModelLookup: dataRowIdToModelLookup,

package/legacy/hooks/features/sorting/useGridSorting.js

@@ -81,7 +81,7 @@ export var useGridSorting = function useGridSorting(apiRef, props) {
     if (sortingOrder.some(function (item) {
       return !!item;
     })) {
-      return [].concat(_toConsumableArray(columnMenuItems), ['ColumnMenuSortItem']);
+      return [].concat(_toConsumableArray(columnMenuItems), ['columnMenuSortItem']);
     }
     return columnMenuItems;
   }, [props.sortingOrder]);