@mui/x-data-grid-pro 5.5.1 → 5.7.0

package/DataGridPro/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DataGridPro';
+export { DATA_GRID_PRO_PROPS_DEFAULT_VALUES } from './useDataGridProProps';

package/DataGridPro/index.js

@@ -0,0 +1,2 @@
+export * from './DataGridPro';
+export { DATA_GRID_PRO_PROPS_DEFAULT_VALUES } from './useDataGridProProps';

package/DataGridPro/package.json

@@ -0,0 +1,6 @@
+{
+  "sideEffects": false,
+  "module": "./index.js",
+  "main": "../node/DataGridPro/index.js",
+  "types": "./index.d.ts"
+}

package/DataGridPro/useDataGridProComponent.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiPro } from '../models/gridApiPro';
+import { DataGridProProcessedProps } from '../models/dataGridProProps';
+export declare const useDataGridProComponent: (inputApiRef: React.MutableRefObject<GridApiPro> | undefined, props: DataGridProProcessedProps) => React.MutableRefObject<GridApiPro>;

package/DataGridPro/useDataGridProComponent.js

@@ -0,0 +1,84 @@
+import { useGridInitialization, useGridInitializeState, useGridClipboard, useGridColumnMenu, useGridColumns, columnsStateInitializer, useGridDensity, useGridCsvExport, useGridPrintExport, useGridFilter, filterStateInitializer, useGridFocus, useGridKeyboard, useGridKeyboardNavigation, useGridPagination, paginationStateInitializer, useGridPreferencesPanel, useGridEditing_new, useGridEditing_old, editingStateInitializer_old, editingStateInitializer_new, useGridRows, useGridRowsPreProcessors, rowsStateInitializer, useGridRowsMeta, useGridParamsApi, useGridSelection, useGridSorting, sortingStateInitializer, useGridScroll, useGridEvents, useGridDimensions, useGridStatePersistence, useGridSelectionPreProcessors, columnMenuStateInitializer, densityStateInitializer, focusStateInitializer, preferencePanelStateInitializer, rowsMetaStateInitializer, selectionStateInitializer } from '@mui/x-data-grid/internals';
+// Pro-only features
+import { useGridInfiniteLoader } from '../hooks/features/infiniteLoader/useGridInfiniteLoader';
+import { useGridColumnReorder, columnReorderStateInitializer } from '../hooks/features/columnReorder/useGridColumnReorder';
+import { useGridColumnResize, columnResizeStateInitializer } from '../hooks/features/columnResize/useGridColumnResize';
+import { useGridTreeData } from '../hooks/features/treeData/useGridTreeData';
+import { useGridTreeDataPreProcessors } from '../hooks/features/treeData/useGridTreeDataPreProcessors';
+import { useGridRowGrouping, rowGroupingStateInitializer } from '../hooks/features/rowGrouping/useGridRowGrouping';
+import { useGridRowGroupingPreProcessors } from '../hooks/features/rowGrouping/useGridRowGroupingPreProcessors';
+import { useGridColumnPinning, columnPinningStateInitializer } from '../hooks/features/columnPinning/useGridColumnPinning';
+import { useGridColumnPinningPreProcessors } from '../hooks/features/columnPinning/useGridColumnPinningPreProcessors';
+import { useGridDetailPanel, detailPanelStateInitializer } from '../hooks/features/detailPanel/useGridDetailPanel';
+import { useGridDetailPanelCache } from '../hooks/features/detailPanel/useGridDetailPanelCache';
+import { useGridDetailPanelPreProcessors } from '../hooks/features/detailPanel/useGridDetailPanelPreProcessors';
+export const useDataGridProComponent = (inputApiRef, props) => {
+  var _props$experimentalFe, _props$experimentalFe2;
+
+  const apiRef = useGridInitialization(inputApiRef, props);
+  /**
+   * Register all pre-processors called during state initialization here.
+   */
+
+  useGridSelectionPreProcessors(apiRef, props);
+  useGridRowGroupingPreProcessors(apiRef, props);
+  useGridTreeDataPreProcessors(apiRef, props);
+  useGridDetailPanelPreProcessors(apiRef, props); // The column pinning `hydrateColumns` pre-processor must be after every other `hydrateColumns` pre-processors
+  // Because it changes the order of the columns.
+
+  useGridColumnPinningPreProcessors(apiRef, props);
+  useGridRowsPreProcessors(apiRef);
+  /**
+   * Register all state initializers here.
+   */
+
+  useGridInitializeState(rowGroupingStateInitializer, apiRef, props);
+  useGridInitializeState(selectionStateInitializer, apiRef, props);
+  useGridInitializeState(detailPanelStateInitializer, apiRef, props);
+  useGridInitializeState(columnPinningStateInitializer, apiRef, props);
+  useGridInitializeState(columnsStateInitializer, apiRef, props);
+  useGridInitializeState(rowsStateInitializer, apiRef, props);
+  useGridInitializeState((_props$experimentalFe = props.experimentalFeatures) != null && _props$experimentalFe.newEditingApi ? editingStateInitializer_new : editingStateInitializer_old, apiRef, props);
+  useGridInitializeState(focusStateInitializer, apiRef, props);
+  useGridInitializeState(sortingStateInitializer, apiRef, props);
+  useGridInitializeState(preferencePanelStateInitializer, apiRef, props);
+  useGridInitializeState(filterStateInitializer, apiRef, props);
+  useGridInitializeState(densityStateInitializer, apiRef, props);
+  useGridInitializeState(columnReorderStateInitializer, apiRef, props);
+  useGridInitializeState(columnResizeStateInitializer, apiRef, props);
+  useGridInitializeState(paginationStateInitializer, apiRef, props);
+  useGridInitializeState(rowsMetaStateInitializer, apiRef, props);
+  useGridInitializeState(columnMenuStateInitializer, apiRef, props);
+  useGridRowGrouping(apiRef, props);
+  useGridTreeData(apiRef);
+  useGridSelection(apiRef, props);
+  useGridDetailPanel(apiRef, props);
+  useGridColumnPinning(apiRef, props);
+  useGridColumns(apiRef, props);
+  useGridRows(apiRef, props);
+  useGridParamsApi(apiRef);
+  useGridDetailPanelCache(apiRef, props);
+  const useGridEditing = (_props$experimentalFe2 = props.experimentalFeatures) != null && _props$experimentalFe2.newEditingApi ? useGridEditing_new : useGridEditing_old;
+  useGridEditing(apiRef, props);
+  useGridFocus(apiRef, props);
+  useGridSorting(apiRef, props);
+  useGridPreferencesPanel(apiRef);
+  useGridFilter(apiRef, props);
+  useGridDensity(apiRef, props);
+  useGridColumnReorder(apiRef, props);
+  useGridColumnResize(apiRef, props);
+  useGridPagination(apiRef, props);
+  useGridRowsMeta(apiRef, props);
+  useGridScroll(apiRef, props);
+  useGridInfiniteLoader(apiRef, props);
+  useGridColumnMenu(apiRef);
+  useGridKeyboard(apiRef);
+  useGridKeyboardNavigation(apiRef, props);
+  useGridCsvExport(apiRef);
+  useGridPrintExport(apiRef, props);
+  useGridClipboard(apiRef);
+  useGridDimensions(apiRef, props);
+  useGridEvents(apiRef, props);
+  useGridStatePersistence(apiRef);
+  return apiRef;
+};

package/DataGridPro/useDataGridProProps.d.ts

@@ -0,0 +1,6 @@
+import { DataGridProProps, DataGridProProcessedProps, DataGridProPropsWithDefaultValue } from '../models/dataGridProProps';
+/**
+ * The default values of `DataGridProPropsWithDefaultValue` to inject in the props of DataGridPro.
+ */
+export declare const DATA_GRID_PRO_PROPS_DEFAULT_VALUES: DataGridProPropsWithDefaultValue;
+export declare const useDataGridProProps: (inProps: DataGridProProps) => DataGridProProcessedProps;

package/DataGridPro/useDataGridProProps.js

@@ -0,0 +1,49 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { useThemeProps } from '@mui/material/styles';
+import { DATA_GRID_DEFAULT_SLOTS_COMPONENTS, GRID_DEFAULT_LOCALE_TEXT, DATA_GRID_PROPS_DEFAULT_VALUES } from '@mui/x-data-grid';
+
+/**
+ * The default values of `DataGridProPropsWithDefaultValue` to inject in the props of DataGridPro.
+ */
+export const DATA_GRID_PRO_PROPS_DEFAULT_VALUES = _extends({}, DATA_GRID_PROPS_DEFAULT_VALUES, {
+  scrollEndThreshold: 80,
+  treeData: false,
+  defaultGroupingExpansionDepth: 0,
+  disableColumnPinning: false,
+  disableRowGrouping: false,
+  disableChildrenFiltering: false,
+  disableChildrenSorting: false,
+  rowGroupingColumnMode: 'single',
+  getDetailPanelHeight: () => 500
+});
+export const useDataGridProProps = inProps => {
+  const themedProps = useThemeProps({
+    props: inProps,
+    name: 'MuiDataGrid'
+  });
+  const localeText = React.useMemo(() => _extends({}, GRID_DEFAULT_LOCALE_TEXT, themedProps.localeText), [themedProps.localeText]);
+  const components = React.useMemo(() => {
+    const overrides = themedProps.components;
+
+    if (!overrides) {
+      return _extends({}, DATA_GRID_DEFAULT_SLOTS_COMPONENTS);
+    }
+
+    const mergedComponents = {};
+    Object.entries(DATA_GRID_DEFAULT_SLOTS_COMPONENTS).forEach(([key, defaultComponent]) => {
+      mergedComponents[key] = overrides[key] === undefined ? defaultComponent : overrides[key];
+    });
+    return mergedComponents;
+  }, [themedProps.components]);
+  return React.useMemo(() => {
+    var _themedProps$experime;
+
+    return _extends({}, DATA_GRID_PRO_PROPS_DEFAULT_VALUES, themedProps, {
+      disableRowGrouping: themedProps.disableRowGrouping || !((_themedProps$experime = themedProps.experimentalFeatures) != null && _themedProps$experime.rowGrouping),
+      localeText,
+      components,
+      signature: 'DataGridPro'
+    });
+  }, [themedProps, localeText, components]);
+};

package/components/DataGridProColumnHeaders.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+interface DataGridProColumnHeadersProps extends React.HTMLAttributes<HTMLDivElement> {
+    innerRef?: React.Ref<HTMLDivElement>;
+}
+export declare const DataGridProColumnHeaders: React.ForwardRefExoticComponent<DataGridProColumnHeadersProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/components/DataGridProColumnHeaders.js

@@ -0,0 +1,165 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["style", "className", "innerRef"];
+import * as React from 'react';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { styled, alpha } from '@mui/material/styles';
+import { getDataGridUtilityClass, gridClasses, useGridSelector, useGridApiEventHandler, gridVisibleColumnFieldsSelector, GridEvents, GridColumnHeaderSeparatorSides } from '@mui/x-data-grid';
+import { GridColumnHeaders, GridColumnHeadersInner, useGridColumnHeaders } from '@mui/x-data-grid/internals';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { gridPinnedColumnsSelector, GridPinnedPosition } from '../hooks/features/columnPinning';
+import { filterColumns } from './DataGridProVirtualScroller';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+
+const useUtilityClasses = ownerState => {
+  const {
+    leftPinnedColumns,
+    rightPinnedColumns,
+    classes
+  } = ownerState;
+  const slots = {
+    leftPinnedColumns: ['pinnedColumnHeaders', leftPinnedColumns && leftPinnedColumns.length > 0 && `pinnedColumnHeaders--left`],
+    rightPinnedColumns: ['pinnedColumnHeaders', rightPinnedColumns && rightPinnedColumns.length > 0 && `pinnedColumnHeaders--right`]
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+// Inspired by https://github.com/material-components/material-components-ios/blob/bca36107405594d5b7b16265a5b0ed698f85a5ee/components/Elevation/src/UIColor%2BMaterialElevation.m#L61
+const getOverlayAlpha = elevation => {
+  let alphaValue;
+
+  if (elevation < 1) {
+    alphaValue = 5.11916 * elevation ** 2;
+  } else {
+    alphaValue = 4.5 * Math.log(elevation + 1) + 2;
+  }
+
+  return alphaValue / 100;
+};
+
+const GridColumnHeadersPinnedColumnHeaders = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'PinnedColumnHeaders',
+  overridesResolver: (props, styles) => [{
+    [`&.${gridClasses['pinnedColumnHeaders--left']}`]: styles['pinnedColumnHeaders--left']
+  }, {
+    [`&.${gridClasses['pinnedColumnHeaders--right']}`]: styles['pinnedColumnHeaders--right']
+  }, styles.pinnedColumnHeaders]
+})(({
+  theme,
+  ownerState
+}) => _extends({
+  position: 'absolute',
+  overflow: 'hidden',
+  height: '100%',
+  zIndex: 1,
+  display: 'flex',
+  boxShadow: theme.shadows[2],
+  backgroundColor: theme.palette.background.default
+}, theme.palette.mode === 'dark' && {
+  backgroundImage: `linear-gradient(${alpha('#fff', getOverlayAlpha(2))}, ${alpha('#fff', getOverlayAlpha(2))})`
+}, ownerState.side === GridPinnedPosition.left && {
+  left: 0
+}, ownerState.side === GridPinnedPosition.right && {
+  right: 0
+}));
+export const DataGridProColumnHeaders = /*#__PURE__*/React.forwardRef(function DataGridProColumnHeaders(props, ref) {
+  const {
+    className,
+    innerRef
+  } = props,
+        other = _objectWithoutPropertiesLoose(props, _excluded);
+
+  const rootProps = useGridRootProps();
+  const apiRef = useGridApiContext();
+  const visibleColumnFields = useGridSelector(apiRef, gridVisibleColumnFieldsSelector);
+  const [scrollbarSize, setScrollbarSize] = React.useState(0);
+  const handleContentSizeChange = React.useCallback(() => {
+    var _apiRef$current$windo;
+
+    if (!((_apiRef$current$windo = apiRef.current.windowRef) != null && _apiRef$current$windo.current)) {
+      return;
+    } // TODO expose scrollbar size on getRootDimensions
+
+
+    const newScrollbarSize = apiRef.current.windowRef.current.offsetWidth - apiRef.current.windowRef.current.clientWidth;
+    setScrollbarSize(newScrollbarSize);
+  }, [apiRef]);
+  useGridApiEventHandler(apiRef, GridEvents.virtualScrollerContentSizeChange, handleContentSizeChange);
+  const pinnedColumns = useGridSelector(apiRef, gridPinnedColumnsSelector);
+  const [leftPinnedColumns, rightPinnedColumns] = filterColumns(pinnedColumns, visibleColumnFields);
+  const {
+    isDragging,
+    renderContext,
+    updateInnerPosition,
+    getRootProps,
+    getInnerProps,
+    getColumns
+  } = useGridColumnHeaders({
+    innerRef,
+    minColumnIndex: leftPinnedColumns.length
+  });
+  const ownerState = {
+    leftPinnedColumns,
+    rightPinnedColumns,
+    classes: rootProps.classes
+  };
+  const classes = useUtilityClasses(ownerState);
+  React.useEffect(() => {
+    if (renderContext) {
+      updateInnerPosition(renderContext);
+    }
+  }, [renderContext, updateInnerPosition]);
+  const leftRenderContext = renderContext && leftPinnedColumns.length ? _extends({}, renderContext, {
+    firstColumnIndex: 0,
+    lastColumnIndex: leftPinnedColumns.length
+  }) : null;
+  const rightRenderContext = renderContext && rightPinnedColumns.length ? _extends({}, renderContext, {
+    firstColumnIndex: visibleColumnFields.length - rightPinnedColumns.length,
+    lastColumnIndex: visibleColumnFields.length
+  }) : null;
+  return /*#__PURE__*/_jsxs(GridColumnHeaders, _extends({
+    ref: ref,
+    className: className
+  }, getRootProps(other), {
+    children: [leftRenderContext && /*#__PURE__*/_jsx(GridColumnHeadersPinnedColumnHeaders, {
+      className: classes.leftPinnedColumns,
+      ownerState: {
+        side: GridPinnedPosition.left
+      },
+      children: getColumns({
+        renderContext: leftRenderContext,
+        minFirstColumn: leftRenderContext.firstColumnIndex,
+        maxLastColumn: leftRenderContext.lastColumnIndex
+      }, {
+        disableReorder: true
+      })
+    }), /*#__PURE__*/_jsx(GridColumnHeadersInner, _extends({
+      isDragging: isDragging
+    }, getInnerProps(), {
+      children: getColumns({
+        renderContext,
+        minFirstColumn: leftPinnedColumns.length,
+        maxLastColumn: visibleColumnFields.length - rightPinnedColumns.length
+      })
+    })), rightRenderContext && /*#__PURE__*/_jsx(GridColumnHeadersPinnedColumnHeaders, {
+      ownerState: {
+        side: GridPinnedPosition.right
+      },
+      className: classes.rightPinnedColumns,
+      style: {
+        paddingRight: scrollbarSize
+      },
+      children: getColumns({
+        renderContext: rightRenderContext,
+        minFirstColumn: rightRenderContext.firstColumnIndex,
+        maxLastColumn: rightRenderContext.lastColumnIndex
+      }, {
+        disableReorder: true,
+        separatorSide: GridColumnHeaderSeparatorSides.Left
+      })
+    })]
+  }));
+});

package/components/DataGridProVirtualScroller.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { GridPinnedColumns } from '../hooks/features/columnPinning';
+export declare const filterColumns: (pinnedColumns: GridPinnedColumns, columns: string[]) => any[][];
+interface DataGridProVirtualScrollerProps extends React.HTMLAttributes<HTMLDivElement> {
+    disableVirtualization?: boolean;
+}
+declare const DataGridProVirtualScroller: React.ForwardRefExoticComponent<DataGridProVirtualScrollerProps & React.RefAttributes<HTMLDivElement>>;
+export { DataGridProVirtualScroller };

package/components/DataGridProVirtualScroller.js

@@ -0,0 +1,270 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime/helpers/esm/extends";
+const _excluded = ["className", "disableVirtualization"];
+import * as React from 'react';
+import { styled, alpha } from '@mui/material/styles';
+import Box from '@mui/material/Box';
+import { unstable_composeClasses as composeClasses } from '@mui/material';
+import { useGridSelector, getDataGridUtilityClass, gridClasses, gridVisibleColumnFieldsSelector, gridRowsMetaSelector, useGridApiEventHandler, GridEvents } from '@mui/x-data-grid';
+import { GridVirtualScroller, GridVirtualScrollerContent, GridVirtualScrollerRenderZone, useGridVirtualScroller } from '@mui/x-data-grid/internals';
+import { useGridApiContext } from '../hooks/utils/useGridApiContext';
+import { useGridRootProps } from '../hooks/utils/useGridRootProps';
+import { gridPinnedColumnsSelector, GridPinnedPosition } from '../hooks/features/columnPinning';
+import { gridDetailPanelExpandedRowsContentCacheSelector, gridDetailPanelExpandedRowsHeightCacheSelector, gridDetailPanelExpandedRowIdsSelector } from '../hooks/features/detailPanel';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export const filterColumns = (pinnedColumns, columns) => {
+  var _pinnedColumns$left, _pinnedColumns$right;
+
+  if (!Array.isArray(pinnedColumns.left) && !Array.isArray(pinnedColumns.right)) {
+    return [[], []];
+  }
+
+  if (((_pinnedColumns$left = pinnedColumns.left) == null ? void 0 : _pinnedColumns$left.length) === 0 && ((_pinnedColumns$right = pinnedColumns.right) == null ? void 0 : _pinnedColumns$right.length) === 0) {
+    return [[], []];
+  }
+
+  const filter = (newPinnedColumns, remainingColumns) => {
+    if (!Array.isArray(newPinnedColumns)) {
+      return [];
+    }
+
+    return newPinnedColumns.filter(field => remainingColumns.includes(field));
+  };
+
+  const leftPinnedColumns = filter(pinnedColumns.left, columns);
+  const columnsWithoutLeftPinnedColumns = columns.filter( // Filter out from the remaining columns those columns already pinned to the left
+  field => !leftPinnedColumns.includes(field));
+  const rightPinnedColumns = filter(pinnedColumns.right, columnsWithoutLeftPinnedColumns);
+  return [leftPinnedColumns, rightPinnedColumns];
+};
+
+const useUtilityClasses = ownerState => {
+  const {
+    classes,
+    leftPinnedColumns,
+    rightPinnedColumns
+  } = ownerState;
+  const slots = {
+    leftPinnedColumns: ['pinnedColumns', leftPinnedColumns && leftPinnedColumns.length > 0 && 'pinnedColumns--left'],
+    rightPinnedColumns: ['pinnedColumns', rightPinnedColumns && rightPinnedColumns.length > 0 && 'pinnedColumns--right'],
+    detailPanels: ['detailPanels'],
+    detailPanel: ['detailPanel']
+  };
+  return composeClasses(slots, getDataGridUtilityClass, classes);
+};
+
+// Inspired by https://github.com/material-components/material-components-ios/blob/bca36107405594d5b7b16265a5b0ed698f85a5ee/components/Elevation/src/UIColor%2BMaterialElevation.m#L61
+const getOverlayAlpha = elevation => {
+  let alphaValue;
+
+  if (elevation < 1) {
+    alphaValue = 5.11916 * elevation ** 2;
+  } else {
+    alphaValue = 4.5 * Math.log(elevation + 1) + 2;
+  }
+
+  return alphaValue / 100;
+};
+
+const VirtualScrollerDetailPanels = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'DetailPanels',
+  overridesResolver: (props, styles) => styles.detailPanels
+})({});
+const VirtualScrollerDetailPanel = styled(Box, {
+  name: 'MuiDataGrid',
+  slot: 'DetailPanel',
+  overridesResolver: (props, styles) => styles.detailPanel
+})(({
+  theme
+}) => ({
+  zIndex: 2,
+  width: '100%',
+  position: 'absolute',
+  backgroundColor: theme.palette.background.default
+}));
+const VirtualScrollerPinnedColumns = styled('div', {
+  name: 'MuiDataGrid',
+  slot: 'PinnedColumns',
+  overridesResolver: (props, styles) => [{
+    [`&.${gridClasses['pinnedColumns--left']}`]: styles['pinnedColumns--left']
+  }, {
+    [`&.${gridClasses['pinnedColumns--right']}`]: styles['pinnedColumns--right']
+  }, styles.pinnedColumns]
+})(({
+  theme,
+  ownerState
+}) => _extends({
+  position: 'sticky',
+  overflow: 'hidden',
+  zIndex: 1,
+  boxShadow: theme.shadows[2],
+  backgroundColor: theme.palette.background.default
+}, theme.palette.mode === 'dark' && {
+  backgroundImage: `linear-gradient(${alpha('#fff', getOverlayAlpha(2))}, ${alpha('#fff', getOverlayAlpha(2))})`
+}, ownerState.side === GridPinnedPosition.left && {
+  left: 0,
+  float: 'left'
+}, ownerState.side === GridPinnedPosition.right && {
+  right: 0,
+  float: 'right'
+}));
+const DataGridProVirtualScroller = /*#__PURE__*/React.forwardRef(function DataGridProVirtualScroller(props, ref) {
+  const other = _objectWithoutPropertiesLoose(props, _excluded);
+
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const visibleColumnFields = useGridSelector(apiRef, gridVisibleColumnFieldsSelector);
+  const expandedRowIds = useGridSelector(apiRef, gridDetailPanelExpandedRowIdsSelector);
+  const detailPanelsContent = useGridSelector(apiRef, gridDetailPanelExpandedRowsContentCacheSelector);
+  const detailPanelsHeights = useGridSelector(apiRef, gridDetailPanelExpandedRowsHeightCacheSelector);
+  const leftColumns = React.useRef(null);
+  const rightColumns = React.useRef(null);
+  const handleRenderZonePositioning = React.useCallback(({
+    top
+  }) => {
+    if (leftColumns.current) {
+      leftColumns.current.style.transform = `translate3d(0px, ${top}px, 0px)`;
+    }
+
+    if (rightColumns.current) {
+      rightColumns.current.style.transform = `translate3d(0px, ${top}px, 0px)`;
+    }
+  }, []);
+
+  const getRowProps = id => {
+    if (!expandedRowIds.includes(id)) {
+      return null;
+    }
+
+    const height = detailPanelsHeights[id];
+    return {
+      style: {
+        marginBottom: height
+      }
+    };
+  };
+
+  const pinnedColumns = useGridSelector(apiRef, gridPinnedColumnsSelector);
+  const [leftPinnedColumns, rightPinnedColumns] = filterColumns(pinnedColumns, visibleColumnFields);
+  const ownerState = {
+    classes: rootProps.classes,
+    leftPinnedColumns,
+    rightPinnedColumns
+  };
+  const classes = useUtilityClasses(ownerState);
+  const {
+    renderContext,
+    getRows,
+    getRootProps,
+    getContentProps,
+    getRenderZoneProps,
+    updateRenderZonePosition
+  } = useGridVirtualScroller(_extends({
+    ref,
+    renderZoneMinColumnIndex: leftPinnedColumns.length,
+    renderZoneMaxColumnIndex: visibleColumnFields.length - rightPinnedColumns.length,
+    onRenderZonePositioning: handleRenderZonePositioning,
+    getRowProps
+  }, props));
+  const refreshRenderZonePosition = React.useCallback(() => {
+    if (renderContext) {
+      updateRenderZonePosition(renderContext);
+    }
+  }, [renderContext, updateRenderZonePosition]);
+  useGridApiEventHandler(apiRef, GridEvents.columnWidthChange, refreshRenderZonePosition);
+  useGridApiEventHandler(apiRef, GridEvents.columnOrderChange, refreshRenderZonePosition);
+  React.useEffect(() => {
+    refreshRenderZonePosition();
+  }, [refreshRenderZonePosition]);
+  const leftRenderContext = renderContext && leftPinnedColumns.length > 0 ? _extends({}, renderContext, {
+    firstColumnIndex: 0,
+    lastColumnIndex: leftPinnedColumns.length
+  }) : null;
+  const rightRenderContext = renderContext && rightPinnedColumns.length > 0 ? _extends({}, renderContext, {
+    firstColumnIndex: visibleColumnFields.length - rightPinnedColumns.length,
+    lastColumnIndex: visibleColumnFields.length
+  }) : null;
+  const contentProps = getContentProps();
+  const pinnedColumnsStyle = {
+    minHeight: contentProps.style.minHeight
+  };
+
+  const getDetailPanels = () => {
+    const panels = [];
+
+    if (rootProps.getDetailPanelContent == null) {
+      return panels;
+    }
+
+    const rowsMeta = gridRowsMetaSelector(apiRef.current.state);
+    const uniqueExpandedRowIds = Array.from(new Set([...expandedRowIds]).values());
+
+    for (let i = 0; i < uniqueExpandedRowIds.length; i += 1) {
+      const id = uniqueExpandedRowIds[i];
+      const content = detailPanelsContent[id]; // Check if the id exists in the current page
+
+      const rowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(id);
+      const exists = rowIndex !== undefined;
+
+      if ( /*#__PURE__*/React.isValidElement(content) && exists) {
+        const height = detailPanelsHeights[id];
+        const sizes = apiRef.current.unstable_getRowInternalSizes(id);
+        const spacingTop = (sizes == null ? void 0 : sizes.spacingTop) || 0;
+        const top = rowsMeta.positions[rowIndex] + apiRef.current.unstable_getRowHeight(id) + spacingTop;
+        panels.push( /*#__PURE__*/_jsx(VirtualScrollerDetailPanel, {
+          style: {
+            top,
+            height
+          },
+          className: classes.detailPanel,
+          children: content
+        }, i));
+      }
+    }
+
+    return panels;
+  };
+
+  const detailPanels = getDetailPanels();
+  return /*#__PURE__*/_jsx(GridVirtualScroller, _extends({}, getRootProps(other), {
+    children: /*#__PURE__*/_jsxs(GridVirtualScrollerContent, _extends({}, contentProps, {
+      children: [leftRenderContext && /*#__PURE__*/_jsx(VirtualScrollerPinnedColumns, {
+        ref: leftColumns,
+        className: classes.leftPinnedColumns,
+        ownerState: {
+          side: GridPinnedPosition.left
+        },
+        style: pinnedColumnsStyle,
+        children: getRows({
+          renderContext: leftRenderContext,
+          minFirstColumn: leftRenderContext.firstColumnIndex,
+          maxLastColumn: leftRenderContext.lastColumnIndex,
+          availableSpace: 0
+        })
+      }), /*#__PURE__*/_jsx(GridVirtualScrollerRenderZone, _extends({}, getRenderZoneProps(), {
+        children: getRows({
+          renderContext
+        })
+      })), rightRenderContext && /*#__PURE__*/_jsx(VirtualScrollerPinnedColumns, {
+        ref: rightColumns,
+        ownerState: {
+          side: GridPinnedPosition.right
+        },
+        className: classes.rightPinnedColumns,
+        style: pinnedColumnsStyle,
+        children: getRows({
+          renderContext: rightRenderContext,
+          minFirstColumn: rightRenderContext.firstColumnIndex,
+          maxLastColumn: rightRenderContext.lastColumnIndex,
+          availableSpace: 0
+        })
+      }), detailPanels.length > 0 && /*#__PURE__*/_jsx(VirtualScrollerDetailPanels, {
+        className: classes.detailPanels,
+        children: detailPanels
+      })]
+    }))
+  }));
+});
+export { DataGridProVirtualScroller };

package/components/GridColumnPinningMenuItems.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { GridColDef } from '@mui/x-data-grid';
+interface GridColumnPinningMenuItemsProps {
+    column?: GridColDef;
+    onClick?: (event: React.MouseEvent<any>) => void;
+}
+declare const GridColumnPinningMenuItems: {
+    (props: GridColumnPinningMenuItemsProps): JSX.Element | null;
+    propTypes: any;
+};
+export { GridColumnPinningMenuItems };