@mui/x-data-grid 6.2.0 → 6.2.1

package/modern/components/index.js

@@ -8,7 +8,6 @@ export * from './menu';
 export * from './panel';
 export * from './toolbar';
 export * from './GridApiContext';
-export * from './GridAutoSizer';
 export * from './GridFooter';
 export * from './GridHeader';
 export * from './GridLoadingOverlay';

package/modern/components/panel/GridColumnsPanel.js

@@ -94,8 +94,9 @@ function GridColumnsPanel(props) {
   const toggleAllColumns = React.useCallback(isVisible => {
     const currentModel = gridColumnVisibilityModelSelector(apiRef);
     const newModel = _extends({}, currentModel);
+    const togglableColumns = getTogglableColumns ? getTogglableColumns(columns) : null;
     columns.forEach(col => {
-      if (col.hideable) {
+      if (col.hideable && (togglableColumns == null || togglableColumns.includes(col.field))) {
         if (isVisible) {
           // delete the key from the model instead of setting it to `true`
           delete newModel[col.field];
@@ -105,7 +106,7 @@ function GridColumnsPanel(props) {
       }
     });
     return apiRef.current.setColumnVisibilityModel(newModel);
-  }, [apiRef, columns]);
+  }, [apiRef, columns, getTogglableColumns]);
   const handleSearchValueChange = React.useCallback(event => {
     setSearchValue(event.target.value);
   }, []);

package/modern/components/panel/GridPanel.js

@@ -115,6 +115,7 @@ process.env.NODE_ENV !== "production" ? GridPanel.propTypes = {
   /**
    * If `true`, the component is shown.
    */
-  open: PropTypes.bool.isRequired
+  open: PropTypes.bool.isRequired,
+  ownerState: PropTypes.object
 } : void 0;
 export { GridPanel };

package/modern/components/panel/filterPanel/GridFilterPanel.js

@@ -26,6 +26,7 @@ const GridFilterPanel = /*#__PURE__*/React.forwardRef(function GridFilterPanel(p
   const filterModel = useGridSelector(apiRef, gridFilterModelSelector);
   const filterableColumns = useGridSelector(apiRef, gridFilterableColumnDefinitionsSelector);
   const lastFilterRef = React.useRef(null);
+  const placeholderFilter = React.useRef(null);
   const {
       logicOperators = [GridLogicOperator.And, GridLogicOperator.Or],
       columnsSort,
@@ -89,8 +90,10 @@ const GridFilterPanel = /*#__PURE__*/React.forwardRef(function GridFilterPanel(p
     if (filterModel.items.length) {
       return filterModel.items;
     }
-    const defaultFilter = getDefaultFilter();
-    return defaultFilter ? [defaultFilter] : [];
+    if (!placeholderFilter.current) {
+      placeholderFilter.current = getDefaultFilter();
+    }
+    return placeholderFilter.current ? [placeholderFilter.current] : [];
   }, [filterModel.items, getDefaultFilter]);
   const hasMultipleFilters = items.length > 1;
   const addNewFilter = () => {

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

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { unstable_debounce as debounce, unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
+import { unstable_debounce as debounce, unstable_ownerDocument as ownerDocument, unstable_useEnhancedEffect as useEnhancedEffect, unstable_ownerWindow as ownerWindow } from '@mui/utils';
 import { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
@@ -10,6 +10,7 @@ import { getVisibleRows } from '../../utils/useGridVisibleRows';
 import { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';
 import { calculatePinnedRowsHeight } from '../rows/gridRowsUtils';
 import { getTotalHeaderHeight } from '../columns/gridColumnsUtils';
+import { gridClasses } from '../../../constants/gridClasses';
 const isTestEnvironment = process.env.NODE_ENV === 'test';
 const hasScroll = ({
   content,
@@ -113,10 +114,20 @@ export function useGridDimensions(apiRef, props) {
       apiRef.current.publishEvent('viewportInnerSizeChange', newFullDimensions.viewportInnerSize);
     }
   }, [apiRef, props.scrollbarSize, props.autoHeight, rowsMeta.currentPageTotalHeight, totalHeaderHeight]);
+  const [savedSize, setSavedSize] = React.useState();
+  const debouncedSetSavedSize = React.useMemo(() => debounce(setSavedSize, 60), []);
+  const previousSize = React.useRef();
+  useEnhancedEffect(() => {
+    if (savedSize) {
+      updateGridDimensionsRef();
+      apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
+    }
+  }, [apiRef, savedSize, updateGridDimensionsRef]);
+
+  // This is the function called by apiRef.current.resize()
   const resize = React.useCallback(() => {
-    updateGridDimensionsRef();
-    apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
-  }, [apiRef, updateGridDimensionsRef]);
+    apiRef.current.computeSizeAndPublishResizeEvent();
+  }, [apiRef]);
   const getRootDimensions = React.useCallback(() => fullDimensionsRef.current, []);
   const getViewportPageSize = React.useCallback(() => {
     const dimensions = apiRef.current.getRootDimensions();
@@ -138,17 +149,44 @@ export function useGridDimensions(apiRef, props) {
     const maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);
     return Math.min(maximumPageSizeWithoutScrollBar, currentPage.rows.length);
   }, [apiRef, props.pagination, props.paginationMode, props.getRowHeight, rowHeight]);
+  const computeSizeAndPublishResizeEvent = React.useCallback(() => {
+    const rootEl = apiRef.current.rootElementRef?.current;
+    const mainEl = rootEl?.querySelector(`.${gridClasses.main}`);
+    if (!mainEl) {
+      return;
+    }
+    const height = mainEl.offsetHeight || 0;
+    const width = mainEl.offsetWidth || 0;
+    const win = ownerWindow(mainEl);
+    const computedStyle = win.getComputedStyle(mainEl);
+    const paddingLeft = parseInt(computedStyle.paddingLeft, 10) || 0;
+    const paddingRight = parseInt(computedStyle.paddingRight, 10) || 0;
+    const paddingTop = parseInt(computedStyle.paddingTop, 10) || 0;
+    const paddingBottom = parseInt(computedStyle.paddingBottom, 10) || 0;
+    const newHeight = height - paddingTop - paddingBottom;
+    const newWidth = width - paddingLeft - paddingRight;
+    const hasHeightChanged = newHeight !== previousSize.current?.height;
+    const hasWidthChanged = newWidth !== previousSize.current?.width;
+    if (!previousSize.current || hasHeightChanged || hasWidthChanged) {
+      const size = {
+        width: newWidth,
+        height: newHeight
+      };
+      apiRef.current.publishEvent('resize', size);
+      previousSize.current = size;
+    }
+  }, [apiRef]);
   const dimensionsApi = {
     resize,
     getRootDimensions
   };
   const dimensionsPrivateApi = {
     getViewportPageSize,
-    updateGridDimensionsRef
+    updateGridDimensionsRef,
+    computeSizeAndPublishResizeEvent
   };
   useGridApiMethod(apiRef, dimensionsApi, 'public');
   useGridApiMethod(apiRef, dimensionsPrivateApi, 'private');
-  const debounceResize = React.useMemo(() => debounce(resize, 60), [resize]);
   const isFirstSizing = React.useRef(true);
   const handleResize = React.useCallback(size => {
     rootDimensionsRef.current = size;
@@ -165,18 +203,18 @@ export function useGridDimensions(apiRef, props) {
     }
     if (isTestEnvironment) {
       // We don't need to debounce the resize for tests.
-      resize();
+      setSavedSize(size);
       isFirstSizing.current = false;
       return;
     }
     if (isFirstSizing.current) {
       // We want to initialize the grid dimensions as soon as possible to avoid flickering
-      resize();
+      setSavedSize(size);
       isFirstSizing.current = false;
       return;
     }
-    debounceResize();
-  }, [props.autoHeight, debounceResize, logger, resize]);
+    debouncedSetSavedSize(size);
+  }, [props.autoHeight, debouncedSetSavedSize, logger]);
   useEnhancedEffect(() => updateGridDimensionsRef(), [updateGridDimensionsRef]);
   useGridApiOptionHandler(apiRef, 'sortedRowsSet', updateGridDimensionsRef);
   useGridApiOptionHandler(apiRef, 'paginationModelChange', updateGridDimensionsRef);

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

@@ -121,7 +121,9 @@ export const useGridPrintExport = (apiRef, props) => {
       printDoc.body.classList.add(...normalizeOptions.bodyClassName.split(' '));
     }
     if (normalizeOptions.copyStyles) {
-      const headStyleElements = doc.current.querySelectorAll("style, link[rel='stylesheet']");
+      const rootCandidate = gridRootElement.getRootNode();
+      const root = rootCandidate.constructor.name === 'ShadowRoot' ? rootCandidate : doc.current;
+      const headStyleElements = root.querySelectorAll("style, link[rel='stylesheet']");
       for (let i = 0; i < headStyleElements.length; i += 1) {
         const node = headStyleElements[i];
         if (node.tagName === 'STYLE') {

package/modern/hooks/features/virtualization/useGridVirtualScroller.js

@@ -174,11 +174,13 @@ export const useGridVirtualScroller = props => {
       height: rootRef.current.clientHeight
     });
   }, [rowsMeta.currentPageTotalHeight]);
-  const handleResize = React.useCallback(params => {
-    setContainerDimensions({
-      width: params.width,
-      height: params.height
-    });
+  const handleResize = React.useCallback(() => {
+    if (rootRef.current) {
+      setContainerDimensions({
+        width: rootRef.current.clientWidth,
+        height: rootRef.current.clientHeight
+      });
+    }
   }, []);
   useGridApiEventHandler(apiRef, 'debouncedResize', handleResize);
   const updateRenderZonePosition = React.useCallback(nextRenderContext => {
@@ -304,6 +306,7 @@ export const useGridVirtualScroller = props => {
     renderContext
   }) => {
     const {
+      onRowRender,
       renderContext: nextRenderContext,
       minFirstColumn = renderZoneMinColumnIndex,
       maxLastColumn = renderZoneMaxColumnIndex,
@@ -387,6 +390,9 @@ export const useGridVirtualScroller = props => {
       } else {
         isSelected = apiRef.current.isRowSelectable(id);
       }
+      if (onRowRender) {
+        onRowRender(id);
+      }
       const focusedCell = cellFocus !== null && cellFocus.id === id ? cellFocus.field : null;
       let tabbableCell = null;
       if (cellTabIndex !== null && cellTabIndex.id === id) {

package/modern/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid v6.2.0
+ * @mui/x-data-grid v6.2.1
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/modern/joy/index.js

@@ -0,0 +1,2 @@
+import joySlots from './joySlots';
+export { joySlots as unstable_joySlots };

package/modern/joy/joySlots.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["touchRippleRef", "inputProps", "onChange", "color", "size", "checked", "sx", "value", "inputRef"];
+import * as React from 'react';
+import JoyCheckbox from '@mui/joy/Checkbox';
+import JoyInput from '@mui/joy/Input';
+import JoyFormControl from '@mui/joy/FormControl';
+import JoyFormLabel from '@mui/joy/FormLabel';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+const Checkbox = /*#__PURE__*/React.forwardRef((_ref, ref) => {
+  let {
+      inputProps,
+      onChange,
+      checked,
+      inputRef
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded);
+  return /*#__PURE__*/_jsx(JoyCheckbox, _extends({}, props, {
+    slotProps: {
+      input: _extends({}, inputProps, {
+        ref: inputRef
+      })
+    },
+    ref: ref,
+    checked: checked,
+    onChange: onChange
+  }));
+});
+const TextField = /*#__PURE__*/React.forwardRef(({
+  onChange,
+  label,
+  placeholder,
+  value,
+  inputRef,
+  type
+}, ref) => {
+  return /*#__PURE__*/_jsxs(JoyFormControl, {
+    ref: ref,
+    children: [/*#__PURE__*/_jsx(JoyFormLabel, {
+      sx: {
+        fontSize: 12
+      },
+      children: label
+    }), /*#__PURE__*/_jsx(JoyInput, {
+      type: type,
+      value: value,
+      onChange: onChange,
+      placeholder: placeholder,
+      size: "sm",
+      slotProps: {
+        input: {
+          ref: inputRef
+        }
+      }
+    })]
+  });
+});
+const joySlots = {
+  baseCheckbox: Checkbox,
+  baseTextField: TextField
+  // BaseFormControl: MUIFormControl,
+  // BaseSelect: MUISelect,
+  // BaseSwitch: MUISwitch,
+  // BaseButton: MUIButton,
+  // BaseIconButton: MUIIconButton,
+  // BaseTooltip: MUITooltip,
+  // BasePopper: MUIPopper,
+};
+
+export default joySlots;

package/node/components/GridHeader.js

@@ -4,19 +4,16 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.GridHeader = void 0;
+exports.GridHeader = GridHeader;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
 var _useGridRootProps = require("../hooks/utils/useGridRootProps");
 var _jsxRuntime = require("react/jsx-runtime");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-const GridHeader = /*#__PURE__*/React.forwardRef(function GridHeader(props, ref) {
+function GridHeader() {
   const rootProps = (0, _useGridRootProps.useGridRootProps)();
-  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", (0, _extends2.default)({
-    ref: ref
-  }, props, {
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
     children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(rootProps.slots.preferencesPanel, (0, _extends2.default)({}, rootProps.slotProps?.preferencesPanel)), rootProps.slots.toolbar && /*#__PURE__*/(0, _jsxRuntime.jsx)(rootProps.slots.toolbar, (0, _extends2.default)({}, rootProps.slotProps?.toolbar))]
-  }));
-});
-exports.GridHeader = GridHeader;
+  });
+}

package/node/components/base/GridBody.js

@@ -8,10 +8,10 @@ exports.GridBody = GridBody;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
 var _propTypes = _interopRequireDefault(require("prop-types"));
+var _utils = require("@mui/utils");
 var _useGridPrivateApiContext = require("../../hooks/utils/useGridPrivateApiContext");
 var _useGridSelector = require("../../hooks/utils/useGridSelector");
 var _GridMainContainer = require("../containers/GridMainContainer");
-var _GridAutoSizer = require("../GridAutoSizer");
 var _useGridRootProps = require("../../hooks/utils/useGridRootProps");
 var _gridColumnsSelector = require("../../hooks/features/columns/gridColumnsSelector");
 var _gridFilterSelector = require("../../hooks/features/filter/gridFilterSelector");
@@ -25,12 +25,12 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function GridBody(props) {
   const {
-    children,
     VirtualScrollerComponent,
     ColumnHeadersProps
   } = props;
   const apiRef = (0, _useGridPrivateApiContext.useGridPrivateApiContext)();
   const rootProps = (0, _useGridRootProps.useGridRootProps)();
+  const rootRef = React.useRef(null);
   const visibleColumns = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector);
   const filterColumnLookup = (0, _useGridSelector.useGridSelector)(apiRef, _gridFilterSelector.gridFilterActiveItemsLookupSelector);
   const sortColumnLookup = (0, _useGridSelector.useGridSelector)(apiRef, _gridSortingSelector.gridSortColumnLookupSelector);
@@ -47,6 +47,24 @@ function GridBody(props) {
   const columnGroupsHeaderStructure = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnGroupsSelector.gridColumnGroupsHeaderStructureSelector);
   const hasOtherElementInTabSequence = !(columnGroupHeaderTabIndexState === null && columnHeaderTabIndexState === null && cellTabIndexState === null);
   const [isVirtualizationDisabled, setIsVirtualizationDisabled] = React.useState(rootProps.disableVirtualization);
+  (0, _utils.unstable_useEnhancedEffect)(() => {
+    apiRef.current.computeSizeAndPublishResizeEvent();
+    const elementToObserve = rootRef.current;
+    if (typeof ResizeObserver === 'undefined') {
+      return () => {};
+    }
+    const observer = new ResizeObserver(() => {
+      apiRef.current.computeSizeAndPublishResizeEvent();
+    });
+    if (elementToObserve) {
+      observer.observe(elementToObserve);
+    }
+    return () => {
+      if (elementToObserve) {
+        observer.unobserve(elementToObserve);
+      }
+    };
+  }, [apiRef]);
   const disableVirtualization = React.useCallback(() => {
     setIsVirtualizationDisabled(true);
   }, []);
@@ -73,10 +91,9 @@ function GridBody(props) {
     columnHeadersElementRef: columnHeadersRef,
     virtualScrollerRef
   });
-  const handleResize = React.useCallback(size => {
-    apiRef.current.publishEvent('resize', size);
-  }, [apiRef]);
+  const hasDimensions = !!apiRef.current.getRootDimensions();
   return /*#__PURE__*/(0, _jsxRuntime.jsxs)(_GridMainContainer.GridMainContainer, {
+    ref: rootRef,
     children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(rootProps.slots.columnHeaders, (0, _extends2.default)({
       ref: columnsContainerRef,
       innerRef: columnHeadersRef,
@@ -94,15 +111,16 @@ function GridBody(props) {
       columnVisibility: columnVisibility,
       columnGroupsHeaderStructure: columnGroupsHeaderStructure,
       hasOtherElementInTabSequence: hasOtherElementInTabSequence
-    }, ColumnHeadersProps)), /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridAutoSizer.GridAutoSizer, {
-      nonce: rootProps.nonce,
-      disableHeight: rootProps.autoHeight,
-      onResize: handleResize,
-      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualScrollerComponent, {
-        ref: virtualScrollerRef,
-        disableVirtualization: isVirtualizationDisabled
-      })
-    }), children]
+    }, ColumnHeadersProps)), hasDimensions && /*#__PURE__*/(0, _jsxRuntime.jsx)(VirtualScrollerComponent
+    // The content is only rendered after dimensions are computed because
+    // the lazy-loading hook is listening to `renderedRowsIntervalChange`,
+    // but only does something if the dimensions are also available.
+    // If this event is published while dimensions haven't been computed,
+    // the `onFetchRows` prop won't be called during mount.
+    , {
+      ref: virtualScrollerRef,
+      disableVirtualization: isVirtualizationDisabled
+    })]
   });
 }
 process.env.NODE_ENV !== "production" ? GridBody.propTypes = {
@@ -110,7 +128,6 @@ process.env.NODE_ENV !== "production" ? GridBody.propTypes = {
   // | These PropTypes are generated from the TypeScript type definitions |
   // | To update them edit the TypeScript types and run "yarn proptypes"  |
   // ----------------------------------------------------------------------
-  children: _propTypes.default.node,
   ColumnHeadersProps: _propTypes.default.object,
   VirtualScrollerComponent: _propTypes.default.elementType.isRequired
 } : void 0;

package/node/components/columnSelection/GridCellCheckboxRenderer.js

@@ -44,7 +44,7 @@ const GridCellCheckboxForwardRef = /*#__PURE__*/React.forwardRef(function GridCe
   };
   const classes = useUtilityClasses(ownerState);
   const checkboxElement = React.useRef(null);
-  const rippleRef = React.useRef();
+  const rippleRef = React.useRef(null);
   const handleRef = (0, _utils.unstable_useForkRef)(checkboxElement, ref);
   const element = apiRef.current.getCellElement(id, field);
   const handleChange = event => {

package/node/components/containers/GridMainContainer.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.GridMainContainer = GridMainContainer;
+exports.GridMainContainer = void 0;
 var React = _interopRequireWildcard(require("react"));
 var _utils = require("@mui/utils");
 var _system = require("@mui/system");
@@ -32,12 +32,14 @@ const GridMainContainerRoot = (0, _system.styled)('div', {
   flexDirection: 'column',
   overflow: 'hidden'
 }));
-function GridMainContainer(props) {
+const GridMainContainer = /*#__PURE__*/React.forwardRef((props, ref) => {
   const rootProps = (0, _useGridRootProps.useGridRootProps)();
   const classes = useUtilityClasses(rootProps);
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(GridMainContainerRoot, {
+    ref: ref,
     className: classes.root,
     ownerState: rootProps,
     children: props.children
   });
-}
+});
+exports.GridMainContainer = GridMainContainer;

package/node/components/containers/GridRoot.js

@@ -63,11 +63,6 @@ const GridRoot = /*#__PURE__*/React.forwardRef(function GridRoot(props, ref) {
   (0, _utils.unstable_useEnhancedEffect)(() => {
     setMountedState(true);
   }, []);
-  (0, _utils.unstable_useEnhancedEffect)(() => {
-    if (mountedState) {
-      apiRef.current.updateGridDimensionsRef();
-    }
-  }, [apiRef, mountedState]);
   if (!mountedState) {
     return null;
   }

package/node/components/index.js

@@ -113,17 +113,6 @@ Object.keys(_GridApiContext).forEach(function (key) {
     }
   });
 });
-var _GridAutoSizer = require("./GridAutoSizer");
-Object.keys(_GridAutoSizer).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _GridAutoSizer[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _GridAutoSizer[key];
-    }
-  });
-});
 var _GridFooter = require("./GridFooter");
 Object.keys(_GridFooter).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/node/components/panel/GridColumnsPanel.js

@@ -102,8 +102,9 @@ function GridColumnsPanel(props) {
   const toggleAllColumns = React.useCallback(isVisible => {
     const currentModel = (0, _gridColumnsSelector.gridColumnVisibilityModelSelector)(apiRef);
     const newModel = (0, _extends2.default)({}, currentModel);
+    const togglableColumns = getTogglableColumns ? getTogglableColumns(columns) : null;
     columns.forEach(col => {
-      if (col.hideable) {
+      if (col.hideable && (togglableColumns == null || togglableColumns.includes(col.field))) {
         if (isVisible) {
           // delete the key from the model instead of setting it to `true`
           delete newModel[col.field];
@@ -113,7 +114,7 @@ function GridColumnsPanel(props) {
       }
     });
     return apiRef.current.setColumnVisibilityModel(newModel);
-  }, [apiRef, columns]);
+  }, [apiRef, columns, getTogglableColumns]);
   const handleSearchValueChange = React.useCallback(event => {
     setSearchValue(event.target.value);
   }, []);

package/node/components/panel/GridPanel.js

@@ -126,5 +126,6 @@ process.env.NODE_ENV !== "production" ? GridPanel.propTypes = {
   /**
    * If `true`, the component is shown.
    */
-  open: _propTypes.default.bool.isRequired
+  open: _propTypes.default.bool.isRequired,
+  ownerState: _propTypes.default.object
 } : void 0;

package/node/components/panel/filterPanel/GridFilterPanel.js

@@ -34,6 +34,7 @@ const GridFilterPanel = /*#__PURE__*/React.forwardRef(function GridFilterPanel(p
   const filterModel = (0, _useGridSelector.useGridSelector)(apiRef, _gridFilterSelector.gridFilterModelSelector);
   const filterableColumns = (0, _useGridSelector.useGridSelector)(apiRef, _gridColumnsSelector.gridFilterableColumnDefinitionsSelector);
   const lastFilterRef = React.useRef(null);
+  const placeholderFilter = React.useRef(null);
   const {
       logicOperators = [_gridFilterItem.GridLogicOperator.And, _gridFilterItem.GridLogicOperator.Or],
       columnsSort,
@@ -97,8 +98,10 @@ const GridFilterPanel = /*#__PURE__*/React.forwardRef(function GridFilterPanel(p
     if (filterModel.items.length) {
       return filterModel.items;
     }
-    const defaultFilter = getDefaultFilter();
-    return defaultFilter ? [defaultFilter] : [];
+    if (!placeholderFilter.current) {
+      placeholderFilter.current = getDefaultFilter();
+    }
+    return placeholderFilter.current ? [placeholderFilter.current] : [];
   }, [filterModel.items, getDefaultFilter]);
   const hasMultipleFilters = items.length > 1;
   const addNewFilter = () => {

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

@@ -16,6 +16,7 @@ var _useGridVisibleRows = require("../../utils/useGridVisibleRows");
 var _gridRowsMetaSelector = require("../rows/gridRowsMetaSelector");
 var _gridRowsUtils = require("../rows/gridRowsUtils");
 var _gridColumnsUtils = require("../columns/gridColumnsUtils");
+var _gridClasses = require("../../../constants/gridClasses");
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 const isTestEnvironment = process.env.NODE_ENV === 'test';
@@ -121,10 +122,20 @@ function useGridDimensions(apiRef, props) {
       apiRef.current.publishEvent('viewportInnerSizeChange', newFullDimensions.viewportInnerSize);
     }
   }, [apiRef, props.scrollbarSize, props.autoHeight, rowsMeta.currentPageTotalHeight, totalHeaderHeight]);
+  const [savedSize, setSavedSize] = React.useState();
+  const debouncedSetSavedSize = React.useMemo(() => (0, _utils.unstable_debounce)(setSavedSize, 60), []);
+  const previousSize = React.useRef();
+  (0, _utils.unstable_useEnhancedEffect)(() => {
+    if (savedSize) {
+      updateGridDimensionsRef();
+      apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
+    }
+  }, [apiRef, savedSize, updateGridDimensionsRef]);
+
+  // This is the function called by apiRef.current.resize()
   const resize = React.useCallback(() => {
-    updateGridDimensionsRef();
-    apiRef.current.publishEvent('debouncedResize', rootDimensionsRef.current);
-  }, [apiRef, updateGridDimensionsRef]);
+    apiRef.current.computeSizeAndPublishResizeEvent();
+  }, [apiRef]);
   const getRootDimensions = React.useCallback(() => fullDimensionsRef.current, []);
   const getViewportPageSize = React.useCallback(() => {
     const dimensions = apiRef.current.getRootDimensions();
@@ -146,17 +157,44 @@ function useGridDimensions(apiRef, props) {
     const maximumPageSizeWithoutScrollBar = Math.floor(dimensions.viewportInnerSize.height / rowHeight);
     return Math.min(maximumPageSizeWithoutScrollBar, currentPage.rows.length);
   }, [apiRef, props.pagination, props.paginationMode, props.getRowHeight, rowHeight]);
+  const computeSizeAndPublishResizeEvent = React.useCallback(() => {
+    const rootEl = apiRef.current.rootElementRef?.current;
+    const mainEl = rootEl?.querySelector(`.${_gridClasses.gridClasses.main}`);
+    if (!mainEl) {
+      return;
+    }
+    const height = mainEl.offsetHeight || 0;
+    const width = mainEl.offsetWidth || 0;
+    const win = (0, _utils.unstable_ownerWindow)(mainEl);
+    const computedStyle = win.getComputedStyle(mainEl);
+    const paddingLeft = parseInt(computedStyle.paddingLeft, 10) || 0;
+    const paddingRight = parseInt(computedStyle.paddingRight, 10) || 0;
+    const paddingTop = parseInt(computedStyle.paddingTop, 10) || 0;
+    const paddingBottom = parseInt(computedStyle.paddingBottom, 10) || 0;
+    const newHeight = height - paddingTop - paddingBottom;
+    const newWidth = width - paddingLeft - paddingRight;
+    const hasHeightChanged = newHeight !== previousSize.current?.height;
+    const hasWidthChanged = newWidth !== previousSize.current?.width;
+    if (!previousSize.current || hasHeightChanged || hasWidthChanged) {
+      const size = {
+        width: newWidth,
+        height: newHeight
+      };
+      apiRef.current.publishEvent('resize', size);
+      previousSize.current = size;
+    }
+  }, [apiRef]);
   const dimensionsApi = {
     resize,
     getRootDimensions
   };
   const dimensionsPrivateApi = {
     getViewportPageSize,
-    updateGridDimensionsRef
+    updateGridDimensionsRef,
+    computeSizeAndPublishResizeEvent
   };
   (0, _useGridApiMethod.useGridApiMethod)(apiRef, dimensionsApi, 'public');
   (0, _useGridApiMethod.useGridApiMethod)(apiRef, dimensionsPrivateApi, 'private');
-  const debounceResize = React.useMemo(() => (0, _utils.unstable_debounce)(resize, 60), [resize]);
   const isFirstSizing = React.useRef(true);
   const handleResize = React.useCallback(size => {
     rootDimensionsRef.current = size;
@@ -173,18 +211,18 @@ function useGridDimensions(apiRef, props) {
     }
     if (isTestEnvironment) {
       // We don't need to debounce the resize for tests.
-      resize();
+      setSavedSize(size);
       isFirstSizing.current = false;
       return;
     }
     if (isFirstSizing.current) {
       // We want to initialize the grid dimensions as soon as possible to avoid flickering
-      resize();
+      setSavedSize(size);
       isFirstSizing.current = false;
       return;
     }
-    debounceResize();
-  }, [props.autoHeight, debounceResize, logger, resize]);
+    debouncedSetSavedSize(size);
+  }, [props.autoHeight, debouncedSetSavedSize, logger]);
   (0, _utils.unstable_useEnhancedEffect)(() => updateGridDimensionsRef(), [updateGridDimensionsRef]);
   (0, _useGridApiEventHandler.useGridApiOptionHandler)(apiRef, 'sortedRowsSet', updateGridDimensionsRef);
   (0, _useGridApiEventHandler.useGridApiOptionHandler)(apiRef, 'paginationModelChange', updateGridDimensionsRef);