@mui/x-data-grid 9.0.0-alpha.1 → 9.0.0-alpha.2

package/hooks/features/rows/useGridRows.mjs

@@ -0,0 +1,485 @@
+'use client';
+
+import _formatErrorMessage from "@mui/x-internals/formatErrorMessage";
+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.mjs";
+import { useGridLogger } from "../../utils/useGridLogger.mjs";
+import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridDataRowIdsSelector, gridRowMaximumTreeDepthSelector, gridRowGroupsToFetchSelector, gridRowNodeSelector, gridDataRowsSelector } from "./gridRowsSelector.mjs";
+import { gridRowIdSelector } from "../../core/gridPropsSelectors.mjs";
+import { useTimeout } from "../../utils/useTimeout.mjs";
+import { GridSignature } from "../../../constants/signature.mjs";
+import { useGridEvent } from "../../utils/useGridEvent.mjs";
+import { getVisibleRows } from "../../utils/useGridVisibleRows.mjs";
+import { gridSortedRowIdsSelector } from "../sorting/gridSortingSelector.mjs";
+import { gridFilteredRowsLookupSelector } from "../filter/gridFilterSelector.mjs";
+import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, isAutogeneratedRowNode, GRID_ROOT_GROUP_ID, GRID_ID_AUTOGENERATED, updateCacheWithNewRows, getTopLevelRowCount, getRowIdFromRowModel, computeRowsUpdates } from "./gridRowsUtils.mjs";
+import { useGridRegisterPipeApplier } from "../../core/pipeProcessing/index.mjs";
+import { GridStrategyGroup } from "../../core/strategyProcessing/index.mjs";
+import { gridPivotActiveSelector } from "../pivoting/index.mjs";
+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, configuration) => {
+  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();
+
+  // Get overridable methods from configuration
+  const {
+    setRowIndex,
+    setRowPosition
+  } = configuration.hooks.useGridRowsOverridableMethods(apiRef, props);
+  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}`);
+    if (!props.dataSource && gridPivotActiveSelector(apiRef)) {
+      apiRef.current.updateNonPivotRows(rows, false);
+      return;
+    }
+    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.dataSource, props.loading, props.rowCount, throttledRowsChange, apiRef]);
+  const updateRows = React.useCallback(updates => {
+    if (props.signature === GridSignature.DataGrid && updates.length > 1) {
+      throw new Error(process.env.NODE_ENV !== "production" ? `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.` : _formatErrorMessage(88));
+    }
+    if (!props.dataSource && gridPivotActiveSelector(apiRef)) {
+      apiRef.current.updateNonPivotRows(updates);
+      return;
+    }
+    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.dataSource, props.getRowId, throttledRowsChange, apiRef]);
+  const updateNestedRows = 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 => {
+    logger.debug(`Setting loading to ${loading}`);
+    apiRef.current.setState(state => _extends({}, state, {
+      rows: _extends({}, state.rows, {
+        loading
+      })
+    }));
+    apiRef.current.caches.rows.loadingPropBeforePartialUpdates = 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(process.env.NODE_ENV !== "production" ? `MUI X: No row with id #${id} found.` : _formatErrorMessage(89, id));
+    }
+    if (currentNode.type !== 'group') {
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X: Only group nodes can be expanded or collapsed.' : _formatErrorMessage(90));
+    }
+    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 expandAllRows = React.useCallback(() => {
+    const tree = _extends({}, gridRowTreeSelector(apiRef));
+    const traverse = nodeId => {
+      const node = tree[nodeId];
+      if (node?.type === 'group') {
+        tree[nodeId] = _extends({}, node, {
+          childrenExpanded: true
+        });
+        node.children.forEach(traverse);
+      }
+    };
+    traverse(GRID_ROOT_GROUP_ID);
+    apiRef.current.setState(state => _extends({}, state, {
+      rows: _extends({}, state.rows, {
+        tree
+      })
+    }));
+    apiRef.current.publishEvent('rowExpansionChange', tree[GRID_ROOT_GROUP_ID]);
+  }, [apiRef]);
+  const collapseAllRows = React.useCallback(() => {
+    const tree = _extends({}, gridRowTreeSelector(apiRef));
+    const traverse = nodeId => {
+      const node = tree[nodeId];
+      if (node?.type === 'group') {
+        tree[nodeId] = _extends({}, node, {
+          childrenExpanded: false
+        });
+        node.children.forEach(traverse);
+      }
+    };
+    traverse(GRID_ROOT_GROUP_ID);
+    apiRef.current.setState(state => _extends({}, state, {
+      rows: _extends({}, state.rows, {
+        tree
+      })
+    }));
+    apiRef.current.publishEvent('rowExpansionChange', tree[GRID_ROOT_GROUP_ID]);
+  }, [apiRef]);
+  const getRowNode = React.useCallback(id => gridRowNodeSelector(apiRef, id) ?? null, [apiRef]);
+  const getRowGroupChildren = React.useCallback(({
+    skipAutoGeneratedRows = true,
+    groupId,
+    applySorting,
+    applyFiltering,
+    directChildrenOnly = false
+  }) => {
+    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 && (directChildrenOnly ? tree[sortedRowIds[index]].depth === groupNode.depth + 1 : 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, directChildrenOnly);
+    }
+    if (applyFiltering) {
+      const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
+      children = isObjectEmpty(filteredRowsLookup) ? children : children.filter(childId => filteredRowsLookup[childId] !== false);
+    }
+    return children;
+  }, [apiRef]);
+  const replaceRows = React.useCallback((firstRowToRender, newRows) => {
+    if (props.signature === GridSignature.DataGrid && newRows.length > 1) {
+      throw new Error(process.env.NODE_ENV !== "production" ? `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.` : _formatErrorMessage(91));
+    }
+    if (newRows.length === 0) {
+      return;
+    }
+    const treeDepth = gridRowMaximumTreeDepthSelector(apiRef);
+    if (treeDepth > 1) {
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X: `apiRef.current.unstable_replaceRows` is not compatible with tree data and row grouping' : _formatErrorMessage(92));
+    }
+    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,
+    setRowPosition,
+    setRowChildrenExpansion,
+    getRowGroupChildren,
+    expandAllRows,
+    collapseAllRows
+  };
+  const rowProPrivateApi = {
+    updateNestedRows
+  };
+
+  /**
+   * 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/hooks/features/rows/useGridRowsMeta.d.mts

@@ -0,0 +1,10 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.mjs";
+import type { DataGridProcessedProps } from "../../../models/props/DataGridProps.mjs";
+import type { GridStateInitializer } from "../../utils/useGridInitializeState.mjs";
+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/hooks/features/rows/useGridRowsMeta.mjs

@@ -0,0 +1,60 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { useGridApiMethod } from "../../utils/useGridApiMethod.mjs";
+import { gridPaginationSelector } from "../pagination/gridPaginationSelector.mjs";
+import { useGridRegisterPipeApplier } from "../../core/pipeProcessing/index.mjs";
+import { gridRowCountSelector } from "./gridRowsSelector.mjs";
+import { gridRowHeightSelector } from "../dimensions/gridDimensionsSelectors.mjs";
+export const rowsMetaStateInitializer = (state, props, apiRef) => {
+  // FIXME: This should be handled in the virtualizer eventually, but there are interdependencies
+  // between state initializers that need to be untangled carefully.
+
+  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 virtualizer = apiRef.current.virtualizer;
+  const {
+    getRowHeight,
+    setLastMeasuredRowIndex,
+    storeRowHeightMeasurement,
+    resetRowHeights,
+    hydrateRowsMeta,
+    observeRowHeight,
+    rowHasAutoHeight,
+    getRowHeightEntry,
+    getLastMeasuredRowIndex
+  } = virtualizer.api.rowsMeta;
+  useGridRegisterPipeApplier(apiRef, 'rowHeight', 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');
+};

package/hooks/features/rows/useGridRowsOverridableMethods.d.mts

@@ -0,0 +1,7 @@
+import type { RefObject } from '@mui/x-internals/types';
+import type { GridRowId } from "../../../models/gridRows.mjs";
+import type { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.mjs";
+export declare const useGridRowsOverridableMethods: (apiRef: RefObject<GridPrivateApiCommunity>) => {
+  setRowIndex: (rowId: GridRowId, targetIndex: number) => void;
+  setRowPosition: (sourceRowId: GridRowId, targetRowId: GridRowId, position: import("../../../internals/index.mjs").RowReorderDropPosition) => void | Promise<void>;
+};

package/hooks/features/rows/useGridRowsOverridableMethods.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.useGridRowsOverridableMethods = void 0;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _formatErrorMessage2 = _interopRequireDefault(require("@mui/x-internals/formatErrorMessage"));
 var React = _interopRequireWildcard(require("react"));
 var _gridRowsSelector = require("./gridRowsSelector");
 var _gridFilterSelector = require("../filter/gridFilterSelector");
@@ -16,27 +17,27 @@ const useGridRowsOverridableMethods = apiRef => {
     const sourceNode = (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, sourceRowId);
     const targetNode = (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, targetRowId);
     if (!sourceNode) {
-      throw new Error(`MUI X: No row with id #${sourceRowId} found.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: No row with id #${sourceRowId} found.` : (0, _formatErrorMessage2.default)(89, sourceRowId));
     }
     if (!targetNode) {
-      throw new Error(`MUI X: No row with id #${targetRowId} found.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: No row with id #${targetRowId} found.` : (0, _formatErrorMessage2.default)(89, targetRowId));
     }
     if (sourceNode.type !== 'leaf') {
-      throw new Error(`MUI X: The row reordering does not support reordering of footer or grouping rows.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: The row reordering does not support reordering of footer or grouping rows.` : (0, _formatErrorMessage2.default)(93));
     }
     if (position === 'inside') {
-      throw new Error(`MUI X: The 'inside' position is only supported for tree data. Use 'above' or 'below' for flat data.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: The 'inside' position is only supported for tree data. Use 'above' or 'below' for flat data.` : (0, _formatErrorMessage2.default)(94));
     }
 
     // Get the target index from the targetRowId using the lookup selector
     const sortedFilteredRowIndexLookup = (0, _gridFilterSelector.gridExpandedSortedRowIndexLookupSelector)(apiRef);
     const targetRowIndexUnadjusted = sortedFilteredRowIndexLookup[targetRowId];
     if (targetRowIndexUnadjusted === undefined) {
-      throw new Error(`MUI X: Target row with id #${targetRowId} not found in current view.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: Target row with id #${targetRowId} not found in current view.` : (0, _formatErrorMessage2.default)(95, targetRowId));
     }
     const sourceRowIndex = sortedFilteredRowIndexLookup[sourceRowId];
     if (sourceRowIndex === undefined) {
-      throw new Error(`MUI X: Source row with id #${sourceRowId} not found in current view.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X: Source row with id #${sourceRowId} not found in current view.` : (0, _formatErrorMessage2.default)(96, sourceRowId));
     }
     const dragDirection = targetRowIndexUnadjusted < sourceRowIndex ? 'up' : 'down';
     let targetRowIndex;
@@ -68,10 +69,10 @@ const useGridRowsOverridableMethods = apiRef => {
   const setRowIndex = React.useCallback((rowId, targetIndex) => {
     const node = (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, rowId);
     if (!node) {
-      throw new Error(`MUI X: No row with id #${rowId} found.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? `MUI X Data Grid: No row with id "${rowId}" found. ` + 'The row to reorder does not exist in the grid. ' + 'Verify the row id is correct and the row exists.' : (0, _formatErrorMessage2.default)(97, rowId));
     }
     if (node.type !== 'leaf') {
-      throw new Error(`MUI X: The row reordering does not support reordering of footer or grouping rows.`);
+      throw new Error(process.env.NODE_ENV !== "production" ? 'MUI X Data Grid: Row reordering does not support reordering of footer or grouping rows. ' + 'Only leaf (data) rows can be reordered. ' + 'Ensure you are only reordering data rows.' : (0, _formatErrorMessage2.default)(98));
     }
     apiRef.current.setState(state => {
       const group = (0, _gridRowsSelector.gridRowTreeSelector)(apiRef)[_gridRowsUtils.GRID_ROOT_GROUP_ID];