@mui/x-data-grid 8.0.0-beta.3 → 8.0.0

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

@@ -1,459 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useLazyRef from '@mui/utils/useLazyRef';
-import { isObjectEmpty } from '@mui/x-internals/isObjectEmpty';
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-import { useGridLogger } from "../../utils/useGridLogger.js";
-import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridDataRowIdsSelector, gridRowMaximumTreeDepthSelector, gridRowGroupsToFetchSelector, gridRowNodeSelector, gridDataRowsSelector } from "./gridRowsSelector.js";
-import { gridRowIdSelector } from "../../core/gridPropsSelectors.js";
-import { useTimeout } from "../../utils/useTimeout.js";
-import { GridSignature } from "../../../constants/signature.js";
-import { useGridEvent } from "../../utils/useGridEvent.js";
-import { getVisibleRows } from "../../utils/useGridVisibleRows.js";
-import { gridSortedRowIdsSelector } from "../sorting/gridSortingSelector.js";
-import { gridFilteredRowsLookupSelector } from "../filter/gridFilterSelector.js";
-import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, isAutogeneratedRowNode, GRID_ROOT_GROUP_ID, GRID_ID_AUTOGENERATED, updateCacheWithNewRows, getTopLevelRowCount, getRowIdFromRowModel, computeRowsUpdates } from "./gridRowsUtils.js";
-import { useGridRegisterPipeApplier } from "../../core/pipeProcessing/index.js";
-import { GridStrategyGroup } from "../../core/strategyProcessing/index.js";
-export const rowsStateInitializer = (state, props, apiRef) => {
-  const isDataSourceAvailable = !!props.dataSource;
-  apiRef.current.caches.rows = createRowsInternalCache({
-    rows: isDataSourceAvailable ? [] : props.rows,
-    getRowId: props.getRowId,
-    loading: props.loading,
-    rowCount: props.rowCount
-  });
-  return _extends({}, state, {
-    rows: getRowsStateFromCache({
-      apiRef,
-      rowCountProp: props.rowCount,
-      loadingProp: isDataSourceAvailable ? true : props.loading,
-      previousTree: null,
-      previousTreeDepths: null
-    })
-  });
-};
-export const useGridRows = (apiRef, props) => {
-  if (process.env.NODE_ENV !== 'production') {
-    try {
-      // Freeze the `rows` prop so developers have a fast failure if they try to use Array.prototype.push().
-      Object.freeze(props.rows);
-    } catch (error) {
-      // Sometimes, it's impossible to freeze, so we give up on it.
-    }
-  }
-  const logger = useGridLogger(apiRef, 'useGridRows');
-  const lastUpdateMs = React.useRef(Date.now());
-  const lastRowCount = React.useRef(props.rowCount);
-  const timeout = useTimeout();
-  const getRow = React.useCallback(id => {
-    const model = gridRowsLookupSelector(apiRef)[id];
-    if (model) {
-      return model;
-    }
-    const node = gridRowNodeSelector(apiRef, id);
-    if (node && isAutogeneratedRowNode(node)) {
-      return {
-        [GRID_ID_AUTOGENERATED]: id
-      };
-    }
-    return null;
-  }, [apiRef]);
-  const getRowId = React.useCallback(row => gridRowIdSelector(apiRef, row), [apiRef]);
-  const throttledRowsChange = React.useCallback(({
-    cache,
-    throttle
-  }) => {
-    const run = () => {
-      lastUpdateMs.current = Date.now();
-      apiRef.current.setState(state => _extends({}, state, {
-        rows: getRowsStateFromCache({
-          apiRef,
-          rowCountProp: props.rowCount,
-          loadingProp: props.loading,
-          previousTree: gridRowTreeSelector(apiRef),
-          previousTreeDepths: gridRowTreeDepthsSelector(apiRef),
-          previousGroupsToFetch: gridRowGroupsToFetchSelector(apiRef)
-        })
-      }));
-      apiRef.current.publishEvent('rowsSet');
-    };
-    timeout.clear();
-    apiRef.current.caches.rows = cache;
-    if (!throttle) {
-      run();
-      return;
-    }
-    const throttleRemainingTimeMs = props.throttleRowsMs - (Date.now() - lastUpdateMs.current);
-    if (throttleRemainingTimeMs > 0) {
-      timeout.start(throttleRemainingTimeMs, run);
-      return;
-    }
-    run();
-  }, [props.throttleRowsMs, props.rowCount, props.loading, apiRef, timeout]);
-
-  /**
-   * API METHODS
-   */
-  const setRows = React.useCallback(rows => {
-    logger.debug(`Updating all rows, new length ${rows.length}`);
-    const cache = createRowsInternalCache({
-      rows,
-      getRowId: props.getRowId,
-      loading: props.loading,
-      rowCount: props.rowCount
-    });
-    const prevCache = apiRef.current.caches.rows;
-    cache.rowsBeforePartialUpdates = prevCache.rowsBeforePartialUpdates;
-    throttledRowsChange({
-      cache,
-      throttle: true
-    });
-  }, [logger, props.getRowId, props.loading, props.rowCount, throttledRowsChange, apiRef]);
-  const updateRows = React.useCallback(updates => {
-    if (props.signature === GridSignature.DataGrid && updates.length > 1) {
-      throw new Error(['MUI X: You cannot update several rows at once in `apiRef.current.updateRows` on the DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
-    }
-    const nonPinnedRowsUpdates = computeRowsUpdates(apiRef, updates, props.getRowId);
-    const cache = updateCacheWithNewRows({
-      updates: nonPinnedRowsUpdates,
-      getRowId: props.getRowId,
-      previousCache: apiRef.current.caches.rows
-    });
-    throttledRowsChange({
-      cache,
-      throttle: true
-    });
-  }, [props.signature, props.getRowId, throttledRowsChange, apiRef]);
-  const updateServerRows = React.useCallback((updates, groupKeys) => {
-    const nonPinnedRowsUpdates = computeRowsUpdates(apiRef, updates, props.getRowId);
-    const cache = updateCacheWithNewRows({
-      updates: nonPinnedRowsUpdates,
-      getRowId: props.getRowId,
-      previousCache: apiRef.current.caches.rows,
-      groupKeys: groupKeys ?? []
-    });
-    throttledRowsChange({
-      cache,
-      throttle: false
-    });
-  }, [props.getRowId, throttledRowsChange, apiRef]);
-  const setLoading = React.useCallback(loading => {
-    if (loading === props.loading) {
-      return;
-    }
-    logger.debug(`Setting loading to ${loading}`);
-    apiRef.current.setState(state => _extends({}, state, {
-      rows: _extends({}, state.rows, {
-        loading
-      })
-    }));
-    apiRef.current.caches.rows.loadingPropBeforePartialUpdates = loading;
-  }, [props.loading, apiRef, logger]);
-  const getRowModels = React.useCallback(() => {
-    const dataRows = gridDataRowIdsSelector(apiRef);
-    const idRowsLookup = gridRowsLookupSelector(apiRef);
-    return new Map(dataRows.map(id => [id, idRowsLookup[id] ?? {}]));
-  }, [apiRef]);
-  const getRowsCount = React.useCallback(() => gridRowCountSelector(apiRef), [apiRef]);
-  const getAllRowIds = React.useCallback(() => gridDataRowIdsSelector(apiRef), [apiRef]);
-  const getRowIndexRelativeToVisibleRows = React.useCallback(id => {
-    const {
-      rowIdToIndexMap
-    } = getVisibleRows(apiRef);
-    return rowIdToIndexMap.get(id);
-  }, [apiRef]);
-  const setRowChildrenExpansion = React.useCallback((id, isExpanded) => {
-    const currentNode = gridRowNodeSelector(apiRef, id);
-    if (!currentNode) {
-      throw new Error(`MUI X: No row with id #${id} found.`);
-    }
-    if (currentNode.type !== 'group') {
-      throw new Error('MUI X: Only group nodes can be expanded or collapsed.');
-    }
-    const newNode = _extends({}, currentNode, {
-      childrenExpanded: isExpanded
-    });
-    apiRef.current.setState(state => {
-      return _extends({}, state, {
-        rows: _extends({}, state.rows, {
-          tree: _extends({}, state.rows.tree, {
-            [id]: newNode
-          })
-        })
-      });
-    });
-    apiRef.current.publishEvent('rowExpansionChange', newNode);
-  }, [apiRef]);
-  const getRowNode = React.useCallback(id => gridRowNodeSelector(apiRef, id) ?? null, [apiRef]);
-  const getRowGroupChildren = React.useCallback(({
-    skipAutoGeneratedRows = true,
-    groupId,
-    applySorting,
-    applyFiltering
-  }) => {
-    const tree = gridRowTreeSelector(apiRef);
-    let children;
-    if (applySorting) {
-      const groupNode = tree[groupId];
-      if (!groupNode) {
-        return [];
-      }
-      const sortedRowIds = gridSortedRowIdsSelector(apiRef);
-      children = [];
-      const startIndex = sortedRowIds.findIndex(id => id === groupId) + 1;
-      for (let index = startIndex; index < sortedRowIds.length && tree[sortedRowIds[index]].depth > groupNode.depth; index += 1) {
-        const id = sortedRowIds[index];
-        if (!skipAutoGeneratedRows || !isAutogeneratedRowNode(tree[id])) {
-          children.push(id);
-        }
-      }
-    } else {
-      children = getTreeNodeDescendants(tree, groupId, skipAutoGeneratedRows);
-    }
-    if (applyFiltering) {
-      const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
-      children = isObjectEmpty(filteredRowsLookup) ? children : children.filter(childId => filteredRowsLookup[childId] !== false);
-    }
-    return children;
-  }, [apiRef]);
-  const setRowIndex = React.useCallback((rowId, targetIndex) => {
-    const node = gridRowNodeSelector(apiRef, rowId);
-    if (!node) {
-      throw new Error(`MUI X: No row with id #${rowId} found.`);
-    }
-    if (node.parent !== GRID_ROOT_GROUP_ID) {
-      throw new Error(`MUI X: The row reordering do not support reordering of grouped rows yet.`);
-    }
-    if (node.type !== 'leaf') {
-      throw new Error(`MUI X: The row reordering do not support reordering of footer or grouping rows.`);
-    }
-    apiRef.current.setState(state => {
-      const group = gridRowTreeSelector(apiRef)[GRID_ROOT_GROUP_ID];
-      const allRows = group.children;
-      const oldIndex = allRows.findIndex(row => row === rowId);
-      if (oldIndex === -1 || oldIndex === targetIndex) {
-        return state;
-      }
-      logger.debug(`Moving row ${rowId} to index ${targetIndex}`);
-      const updatedRows = [...allRows];
-      updatedRows.splice(targetIndex, 0, updatedRows.splice(oldIndex, 1)[0]);
-      return _extends({}, state, {
-        rows: _extends({}, state.rows, {
-          tree: _extends({}, state.rows.tree, {
-            [GRID_ROOT_GROUP_ID]: _extends({}, group, {
-              children: updatedRows
-            })
-          })
-        })
-      });
-    });
-    apiRef.current.publishEvent('rowsSet');
-  }, [apiRef, logger]);
-  const replaceRows = React.useCallback((firstRowToRender, newRows) => {
-    if (props.signature === GridSignature.DataGrid && newRows.length > 1) {
-      throw new Error(['MUI X: You cannot replace rows using `apiRef.current.unstable_replaceRows` on the DataGrid.', 'You need to upgrade to DataGridPro or DataGridPremium component to unlock this feature.'].join('\n'));
-    }
-    if (newRows.length === 0) {
-      return;
-    }
-    const treeDepth = gridRowMaximumTreeDepthSelector(apiRef);
-    if (treeDepth > 1) {
-      throw new Error('`apiRef.current.unstable_replaceRows` is not compatible with tree data and row grouping');
-    }
-    const tree = _extends({}, gridRowTreeSelector(apiRef));
-    const dataRowIdToModelLookup = _extends({}, gridRowsLookupSelector(apiRef));
-    const rootGroup = tree[GRID_ROOT_GROUP_ID];
-    const rootGroupChildren = [...rootGroup.children];
-    const seenIds = new Set();
-    for (let i = 0; i < newRows.length; i += 1) {
-      const rowModel = newRows[i];
-      const rowId = getRowIdFromRowModel(rowModel, props.getRowId, 'A row was provided without id when calling replaceRows().');
-      const [removedRowId] = rootGroupChildren.splice(firstRowToRender + i, 1, rowId);
-      if (!seenIds.has(removedRowId)) {
-        delete dataRowIdToModelLookup[removedRowId];
-        delete tree[removedRowId];
-      }
-      const rowTreeNodeConfig = {
-        id: rowId,
-        depth: 0,
-        parent: GRID_ROOT_GROUP_ID,
-        type: 'leaf',
-        groupingKey: null
-      };
-      dataRowIdToModelLookup[rowId] = rowModel;
-      tree[rowId] = rowTreeNodeConfig;
-      seenIds.add(rowId);
-    }
-    tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
-      children: rootGroupChildren
-    });
-
-    // Removes potential remaining skeleton rows from the dataRowIds.
-    const dataRowIds = rootGroupChildren.filter(childId => tree[childId]?.type === 'leaf');
-    apiRef.current.caches.rows.dataRowIdToModelLookup = dataRowIdToModelLookup;
-    apiRef.current.setState(state => _extends({}, state, {
-      rows: _extends({}, state.rows, {
-        loading: props.loading,
-        totalRowCount: Math.max(props.rowCount || 0, rootGroupChildren.length),
-        dataRowIdToModelLookup,
-        dataRowIds,
-        tree
-      })
-    }));
-    apiRef.current.publishEvent('rowsSet');
-  }, [apiRef, props.signature, props.getRowId, props.loading, props.rowCount]);
-  const rowApi = {
-    getRow,
-    setLoading,
-    getRowId,
-    getRowModels,
-    getRowsCount,
-    getAllRowIds,
-    setRows,
-    updateRows,
-    getRowNode,
-    getRowIndexRelativeToVisibleRows,
-    unstable_replaceRows: replaceRows
-  };
-  const rowProApi = {
-    setRowIndex,
-    setRowChildrenExpansion,
-    getRowGroupChildren
-  };
-  const rowProPrivateApi = {
-    updateServerRows
-  };
-
-  /**
-   * EVENTS
-   */
-  const groupRows = React.useCallback(() => {
-    logger.info(`Row grouping pre-processing have changed, regenerating the row tree`);
-    let cache;
-    if (apiRef.current.caches.rows.rowsBeforePartialUpdates === props.rows) {
-      // The `props.rows` did not change since the last row grouping
-      // We can use the current rows cache which contains the partial updates done recently.
-      cache = _extends({}, apiRef.current.caches.rows, {
-        updates: {
-          type: 'full',
-          rows: gridDataRowIdsSelector(apiRef)
-        }
-      });
-    } else {
-      // The `props.rows` has changed since the last row grouping
-      // We must use the new `props.rows` on the new grouping
-      // This occurs because this event is triggered before the `useEffect` on the rows when both the grouping pre-processing and the rows changes on the same render
-      cache = createRowsInternalCache({
-        rows: props.rows,
-        getRowId: props.getRowId,
-        loading: props.loading,
-        rowCount: props.rowCount
-      });
-    }
-    throttledRowsChange({
-      cache,
-      throttle: false
-    });
-  }, [logger, apiRef, props.rows, props.getRowId, props.loading, props.rowCount, throttledRowsChange]);
-  const previousDataSource = useLazyRef(() => props.dataSource);
-  const handleStrategyProcessorChange = React.useCallback(methodName => {
-    if (props.dataSource && props.dataSource !== previousDataSource.current) {
-      previousDataSource.current = props.dataSource;
-      return;
-    }
-    if (methodName === 'rowTreeCreation') {
-      groupRows();
-    }
-  }, [groupRows, previousDataSource, props.dataSource]);
-  const handleStrategyActivityChange = React.useCallback(() => {
-    // `rowTreeCreation` is the only processor ran when `strategyAvailabilityChange` is fired.
-    // All the other processors listen to `rowsSet` which will be published by the `groupRows` method below.
-    if (apiRef.current.getActiveStrategy(GridStrategyGroup.RowTree) !== gridRowGroupingNameSelector(apiRef)) {
-      groupRows();
-    }
-  }, [apiRef, groupRows]);
-  useGridEvent(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
-  useGridEvent(apiRef, 'strategyAvailabilityChange', handleStrategyActivityChange);
-
-  /**
-   * APPLIERS
-   */
-  const applyHydrateRowsProcessor = React.useCallback(() => {
-    apiRef.current.setState(state => {
-      const response = apiRef.current.unstable_applyPipeProcessors('hydrateRows', {
-        tree: gridRowTreeSelector(apiRef),
-        treeDepths: gridRowTreeDepthsSelector(apiRef),
-        dataRowIds: gridDataRowIdsSelector(apiRef),
-        dataRowIdToModelLookup: gridRowsLookupSelector(apiRef)
-      });
-      return _extends({}, state, {
-        rows: _extends({}, state.rows, response, {
-          totalTopLevelRowCount: getTopLevelRowCount({
-            tree: response.tree,
-            rowCountProp: props.rowCount
-          })
-        })
-      });
-    });
-    apiRef.current.publishEvent('rowsSet');
-  }, [apiRef, props.rowCount]);
-  useGridRegisterPipeApplier(apiRef, 'hydrateRows', applyHydrateRowsProcessor);
-  useGridApiMethod(apiRef, rowApi, 'public');
-  useGridApiMethod(apiRef, rowProApi, props.signature === GridSignature.DataGrid ? 'private' : 'public');
-  useGridApiMethod(apiRef, rowProPrivateApi, 'private');
-
-  // The effect do not track any value defined synchronously during the 1st render by hooks called after `useGridRows`
-  // As a consequence, the state generated by the 1st run of this useEffect will always be equal to the initialization one
-  const isFirstRender = React.useRef(true);
-  React.useEffect(() => {
-    if (isFirstRender.current) {
-      isFirstRender.current = false;
-      return;
-    }
-    let isRowCountPropUpdated = false;
-    if (props.rowCount !== lastRowCount.current) {
-      isRowCountPropUpdated = true;
-      lastRowCount.current = props.rowCount;
-    }
-    const currentRows = props.dataSource ? gridDataRowsSelector(apiRef) : props.rows;
-    const areNewRowsAlreadyInState = apiRef.current.caches.rows.rowsBeforePartialUpdates === currentRows;
-    const isNewLoadingAlreadyInState = apiRef.current.caches.rows.loadingPropBeforePartialUpdates === props.loading;
-    const isNewRowCountAlreadyInState = apiRef.current.caches.rows.rowCountPropBeforePartialUpdates === props.rowCount;
-
-    // The new rows have already been applied (most likely in the `'rowGroupsPreProcessingChange'` listener)
-    if (areNewRowsAlreadyInState) {
-      // If the loading prop has changed, we need to update its value in the state because it won't be done by `throttledRowsChange`
-      if (!isNewLoadingAlreadyInState) {
-        apiRef.current.setState(state => _extends({}, state, {
-          rows: _extends({}, state.rows, {
-            loading: props.loading
-          })
-        }));
-        apiRef.current.caches.rows.loadingPropBeforePartialUpdates = props.loading;
-      }
-      if (!isNewRowCountAlreadyInState) {
-        apiRef.current.setState(state => _extends({}, state, {
-          rows: _extends({}, state.rows, {
-            totalRowCount: Math.max(props.rowCount || 0, state.rows.totalRowCount),
-            totalTopLevelRowCount: Math.max(props.rowCount || 0, state.rows.totalTopLevelRowCount)
-          })
-        }));
-        apiRef.current.caches.rows.rowCountPropBeforePartialUpdates = props.rowCount;
-      }
-      if (!isRowCountPropUpdated) {
-        return;
-      }
-    }
-    logger.debug(`Updating all rows, new length ${currentRows?.length}`);
-    throttledRowsChange({
-      cache: createRowsInternalCache({
-        rows: currentRows,
-        getRowId: props.getRowId,
-        loading: props.loading,
-        rowCount: props.rowCount
-      }),
-      throttle: false
-    });
-  }, [props.rows, props.rowCount, props.getRowId, props.loading, props.dataSource, logger, throttledRowsChange, apiRef]);
-};

package/modern/hooks/features/rows/useGridRowsMeta.d.ts

@@ -1,10 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
-import { DataGridProcessedProps } from "../../../models/props/DataGridProps.js";
-import { GridStateInitializer } from "../../utils/useGridInitializeState.js";
-export declare const rowsMetaStateInitializer: GridStateInitializer;
-/**
- * @requires useGridPageSize (method)
- * @requires useGridPage (method)
- */
-export declare const useGridRowsMeta: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "getRowHeight" | "getEstimatedRowHeight" | "getRowSpacing" | "pagination" | "paginationMode" | "rowHeight">) => void;

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

@@ -1,227 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useLazyRef from '@mui/utils/useLazyRef';
-import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
-import { ResizeObserver } from "../../../utils/ResizeObserver.js";
-import { useGridVisibleRows } from "../../utils/useGridVisibleRows.js";
-import { eslintUseValue } from "../../../utils/utils.js";
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-import { useGridSelector } from "../../utils/useGridSelector.js";
-import { gridDensityFactorSelector } from "../density/densitySelector.js";
-import { gridPaginationSelector } from "../pagination/gridPaginationSelector.js";
-import { useGridRegisterPipeApplier } from "../../core/pipeProcessing/index.js";
-import { gridPinnedRowsSelector, gridRowCountSelector } from "./gridRowsSelector.js";
-import { gridDimensionsSelector, gridRowHeightSelector } from "../dimensions/gridDimensionsSelectors.js";
-import { getValidRowHeight, getRowHeightWarning } from "./gridRowsUtils.js";
-import { gridFocusedVirtualCellSelector } from "../virtualization/gridFocusedVirtualCellSelector.js";
-/* eslint-disable no-underscore-dangle */
-
-export const rowsMetaStateInitializer = (state, props, apiRef) => {
-  apiRef.current.caches.rowsMeta = {
-    heights: new Map()
-  };
-  const baseRowHeight = gridRowHeightSelector(apiRef);
-  const dataRowCount = gridRowCountSelector(apiRef);
-  const pagination = gridPaginationSelector(apiRef);
-  const rowCount = Math.min(pagination.enabled ? pagination.paginationModel.pageSize : dataRowCount, dataRowCount);
-  return _extends({}, state, {
-    rowsMeta: {
-      currentPageTotalHeight: rowCount * baseRowHeight,
-      positions: Array.from({
-        length: rowCount
-      }, (_, i) => i * baseRowHeight),
-      pinnedTopRowsTotalHeight: 0,
-      pinnedBottomRowsTotalHeight: 0
-    }
-  });
-};
-
-/**
- * @requires useGridPageSize (method)
- * @requires useGridPage (method)
- */
-export const useGridRowsMeta = (apiRef, props) => {
-  const {
-    getRowHeight: getRowHeightProp,
-    getRowSpacing,
-    getEstimatedRowHeight
-  } = props;
-  const heightCache = apiRef.current.caches.rowsMeta.heights;
-  const lastMeasuredRowIndex = React.useRef(-1);
-  const hasRowWithAutoHeight = React.useRef(false);
-  const isHeightMetaValid = React.useRef(false);
-  const densityFactor = useGridSelector(apiRef, gridDensityFactorSelector);
-  const currentPage = useGridVisibleRows(apiRef, props);
-  const pinnedRows = useGridSelector(apiRef, gridPinnedRowsSelector);
-  const rowHeight = useGridSelector(apiRef, gridRowHeightSelector);
-  const getRowHeightEntry = rowId => {
-    let entry = heightCache.get(rowId);
-    if (entry === undefined) {
-      entry = {
-        content: rowHeight,
-        spacingTop: 0,
-        spacingBottom: 0,
-        detail: 0,
-        autoHeight: false,
-        needsFirstMeasurement: true
-      };
-      heightCache.set(rowId, entry);
-    }
-    return entry;
-  };
-  const processHeightEntry = React.useCallback(row => {
-    // HACK: rowHeight trails behind the most up-to-date value just enough to
-    // mess the initial rowsMeta hydration :/
-    const baseRowHeight = gridDimensionsSelector(apiRef).rowHeight;
-    eslintUseValue(rowHeight);
-    const entry = apiRef.current.getRowHeightEntry(row.id);
-    if (!getRowHeightProp) {
-      entry.content = baseRowHeight;
-      entry.needsFirstMeasurement = false;
-    } else {
-      const rowHeightFromUser = getRowHeightProp(_extends({}, row, {
-        densityFactor
-      }));
-      if (rowHeightFromUser === 'auto') {
-        if (entry.needsFirstMeasurement) {
-          const estimatedRowHeight = getEstimatedRowHeight ? getEstimatedRowHeight(_extends({}, row, {
-            densityFactor
-          })) : baseRowHeight;
-
-          // If the row was not measured yet use the estimated row height
-          entry.content = estimatedRowHeight ?? baseRowHeight;
-        }
-        hasRowWithAutoHeight.current = true;
-        entry.autoHeight = true;
-      } else {
-        // Default back to base rowHeight if getRowHeight returns invalid value.
-        entry.content = getValidRowHeight(rowHeightFromUser, baseRowHeight, getRowHeightWarning);
-        entry.needsFirstMeasurement = false;
-        entry.autoHeight = false;
-      }
-    }
-    if (getRowSpacing) {
-      const indexRelativeToCurrentPage = apiRef.current.getRowIndexRelativeToVisibleRows(row.id);
-      const spacing = getRowSpacing(_extends({}, row, {
-        isFirstVisible: indexRelativeToCurrentPage === 0,
-        isLastVisible: indexRelativeToCurrentPage === currentPage.rows.length - 1,
-        indexRelativeToCurrentPage
-      }));
-      entry.spacingTop = spacing.top ?? 0;
-      entry.spacingBottom = spacing.bottom ?? 0;
-    } else {
-      entry.spacingTop = 0;
-      entry.spacingBottom = 0;
-    }
-    apiRef.current.unstable_applyPipeProcessors('rowHeight', entry, row);
-    return entry;
-  }, [apiRef, currentPage.rows, getRowHeightProp, getEstimatedRowHeight, rowHeight, getRowSpacing, densityFactor]);
-  const hydrateRowsMeta = React.useCallback(() => {
-    hasRowWithAutoHeight.current = false;
-    const pinnedTopRowsTotalHeight = pinnedRows.top.reduce((acc, row) => {
-      const entry = processHeightEntry(row);
-      return acc + entry.content + entry.spacingTop + entry.spacingBottom + entry.detail;
-    }, 0);
-    const pinnedBottomRowsTotalHeight = pinnedRows.bottom.reduce((acc, row) => {
-      const entry = processHeightEntry(row);
-      return acc + entry.content + entry.spacingTop + entry.spacingBottom + entry.detail;
-    }, 0);
-    const positions = [];
-    const currentPageTotalHeight = currentPage.rows.reduce((acc, row) => {
-      positions.push(acc);
-      const entry = processHeightEntry(row);
-      const total = entry.content + entry.spacingTop + entry.spacingBottom + entry.detail;
-      return acc + total;
-    }, 0);
-    if (!hasRowWithAutoHeight.current) {
-      // No row has height=auto, so all rows are already measured
-      lastMeasuredRowIndex.current = Infinity;
-    }
-    const didHeightsChange = pinnedTopRowsTotalHeight !== apiRef.current.state.rowsMeta.pinnedTopRowsTotalHeight || pinnedBottomRowsTotalHeight !== apiRef.current.state.rowsMeta.pinnedBottomRowsTotalHeight || currentPageTotalHeight !== apiRef.current.state.rowsMeta.currentPageTotalHeight;
-    const rowsMeta = {
-      currentPageTotalHeight,
-      positions,
-      pinnedTopRowsTotalHeight,
-      pinnedBottomRowsTotalHeight
-    };
-    apiRef.current.setState(state => {
-      return _extends({}, state, {
-        rowsMeta
-      });
-    });
-    if (didHeightsChange) {
-      apiRef.current.updateDimensions();
-    }
-    isHeightMetaValid.current = true;
-  }, [apiRef, pinnedRows, currentPage.rows, processHeightEntry]);
-  const getRowHeight = rowId => {
-    return heightCache.get(rowId)?.content ?? rowHeight;
-  };
-  const storeRowHeightMeasurement = (id, height) => {
-    const entry = apiRef.current.getRowHeightEntry(id);
-    const didChange = entry.content !== height;
-    entry.needsFirstMeasurement = false;
-    entry.content = height;
-    isHeightMetaValid.current && (isHeightMetaValid.current = !didChange);
-  };
-  const rowHasAutoHeight = id => {
-    return heightCache.get(id)?.autoHeight ?? false;
-  };
-  const getLastMeasuredRowIndex = () => {
-    return lastMeasuredRowIndex.current;
-  };
-  const setLastMeasuredRowIndex = index => {
-    if (hasRowWithAutoHeight.current && index > lastMeasuredRowIndex.current) {
-      lastMeasuredRowIndex.current = index;
-    }
-  };
-  const resetRowHeights = () => {
-    heightCache.clear();
-    hydrateRowsMeta();
-  };
-  const resizeObserver = useLazyRef(() => new ResizeObserver(entries => {
-    for (let i = 0; i < entries.length; i += 1) {
-      const entry = entries[i];
-      const height = entry.borderBoxSize && entry.borderBoxSize.length > 0 ? entry.borderBoxSize[0].blockSize : entry.contentRect.height;
-      const rowId = entry.target.__mui_id;
-      const focusedVirtualRowId = gridFocusedVirtualCellSelector(apiRef)?.id;
-      if (focusedVirtualRowId === rowId && height === 0) {
-        // Focused virtual row has 0 height.
-        // We don't want to store it to avoid scroll jumping.
-        // https://github.com/mui/mui-x/issues/14726
-        return;
-      }
-      apiRef.current.unstable_storeRowHeightMeasurement(rowId, height);
-    }
-    if (!isHeightMetaValid.current) {
-      apiRef.current.requestPipeProcessorsApplication('rowHeight');
-    }
-  })).current;
-  const observeRowHeight = (element, rowId) => {
-    element.__mui_id = rowId;
-    resizeObserver.observe(element);
-    return () => resizeObserver.unobserve(element);
-  };
-  useGridRegisterPipeApplier(apiRef, 'rowHeight', hydrateRowsMeta);
-
-  // The effect is used to build the rows meta data - currentPageTotalHeight and positions.
-  // Because of variable row height this is needed for the virtualization
-  useEnhancedEffect(() => {
-    hydrateRowsMeta();
-  }, [hydrateRowsMeta]);
-  const rowsMetaApi = {
-    unstable_getRowHeight: getRowHeight,
-    unstable_setLastMeasuredRowIndex: setLastMeasuredRowIndex,
-    unstable_storeRowHeightMeasurement: storeRowHeightMeasurement,
-    resetRowHeights
-  };
-  const rowsMetaPrivateApi = {
-    hydrateRowsMeta,
-    observeRowHeight,
-    rowHasAutoHeight,
-    getRowHeightEntry,
-    getLastMeasuredRowIndex
-  };
-  useGridApiMethod(apiRef, rowsMetaApi, 'public');
-  useGridApiMethod(apiRef, rowsMetaPrivateApi, 'private');
-};