@mui/x-data-grid 8.0.0-alpha.10 → 8.0.0-alpha.12

package/hooks/features/rows/useGridRows.js

@@ -1,27 +1,38 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import useLazyRef from '@mui/utils/useLazyRef';
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-import { useGridLogger } from "../../utils/useGridLogger.js";
-import { gridRowCountSelector, gridRowsLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridDataRowIdsSelector, gridRowMaximumTreeDepthSelector, gridRowGroupsToFetchSelector } from "./gridRowsSelector.js";
-import { useTimeout } from "../../utils/useTimeout.js";
-import { GridSignature, useGridApiEventHandler } from "../../utils/useGridApiEventHandler.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) => {
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRows = exports.rowsStateInitializer = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _useLazyRef = _interopRequireDefault(require("@mui/utils/useLazyRef"));
+var _isObjectEmpty = require("@mui/x-internals/isObjectEmpty");
+var _useGridApiMethod = require("../../utils/useGridApiMethod");
+var _useGridLogger = require("../../utils/useGridLogger");
+var _gridRowsSelector = require("./gridRowsSelector");
+var _gridPropsSelectors = require("../../core/gridPropsSelectors");
+var _useTimeout = require("../../utils/useTimeout");
+var _signature = require("../../../constants/signature");
+var _useGridApiEventHandler = require("../../utils/useGridApiEventHandler");
+var _useGridVisibleRows = require("../../utils/useGridVisibleRows");
+var _gridSortingSelector = require("../sorting/gridSortingSelector");
+var _gridFilterSelector = require("../filter/gridFilterSelector");
+var _gridRowsUtils = require("./gridRowsUtils");
+var _pipeProcessing = require("../../core/pipeProcessing");
+var _strategyProcessing = require("../../core/strategyProcessing");
+const rowsStateInitializer = (state, props, apiRef) => {
   const isDataSourceAvailable = !!props.unstable_dataSource;
-  apiRef.current.caches.rows = createRowsInternalCache({
+  apiRef.current.caches.rows = (0, _gridRowsUtils.createRowsInternalCache)({
     rows: isDataSourceAvailable ? [] : props.rows,
     getRowId: props.getRowId,
     loading: props.loading,
     rowCount: props.rowCount
   });
-  return _extends({}, state, {
-    rows: getRowsStateFromCache({
+  return (0, _extends2.default)({}, state, {
+    rows: (0, _gridRowsUtils.getRowsStateFromCache)({
       apiRef,
       rowCountProp: props.rowCount,
       loadingProp: isDataSourceAvailable ? true : props.loading,
@@ -30,7 +41,8 @@ export const rowsStateInitializer = (state, props, apiRef) => {
     })
   });
 };
-export const useGridRows = (apiRef, props) => {
+exports.rowsStateInitializer = rowsStateInitializer;
+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().
@@ -39,51 +51,41 @@ export const useGridRows = (apiRef, props) => {
       // Sometimes, it's impossible to freeze, so we give up on it.
     }
   }
-  const logger = useGridLogger(apiRef, 'useGridRows');
+  const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridRows');
   const lastUpdateMs = React.useRef(Date.now());
   const lastRowCount = React.useRef(props.rowCount);
-  const timeout = useTimeout();
+  const timeout = (0, _useTimeout.useTimeout)();
   const getRow = React.useCallback(id => {
-    const model = gridRowsLookupSelector(apiRef)[id];
+    const model = (0, _gridRowsSelector.gridRowsLookupSelector)(apiRef)[id];
     if (model) {
       return model;
     }
-    const node = apiRef.current.getRowNode(id);
-    if (node && isAutogeneratedRowNode(node)) {
+    const node = (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, id);
+    if (node && (0, _gridRowsUtils.isAutogeneratedRowNode)(node)) {
       return {
-        [GRID_ID_AUTOGENERATED]: id
+        [_gridRowsUtils.GRID_ID_AUTOGENERATED]: id
       };
     }
     return null;
   }, [apiRef]);
-  const getRowIdProp = props.getRowId;
-  const getRowId = React.useCallback(row => {
-    if (GRID_ID_AUTOGENERATED in row) {
-      return row[GRID_ID_AUTOGENERATED];
-    }
-    if (getRowIdProp) {
-      return getRowIdProp(row);
-    }
-    return row.id;
-  }, [getRowIdProp]);
+  const getRowId = React.useCallback(row => (0, _gridPropsSelectors.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.current.setState(state => (0, _extends2.default)({}, state, {
+        rows: (0, _gridRowsUtils.getRowsStateFromCache)({
           apiRef,
           rowCountProp: props.rowCount,
           loadingProp: props.loading,
-          previousTree: gridRowTreeSelector(apiRef),
-          previousTreeDepths: gridRowTreeDepthsSelector(apiRef),
-          previousGroupsToFetch: gridRowGroupsToFetchSelector(apiRef)
+          previousTree: (0, _gridRowsSelector.gridRowTreeSelector)(apiRef),
+          previousTreeDepths: (0, _gridRowsSelector.gridRowTreeDepthsSelector)(apiRef),
+          previousGroupsToFetch: (0, _gridRowsSelector.gridRowGroupsToFetchSelector)(apiRef)
         })
       }));
       apiRef.current.publishEvent('rowsSet');
-      apiRef.current.forceUpdate();
     };
     timeout.clear();
     apiRef.current.caches.rows = cache;
@@ -104,7 +106,7 @@ export const useGridRows = (apiRef, props) => {
    */
   const setRows = React.useCallback(rows => {
     logger.debug(`Updating all rows, new length ${rows.length}`);
-    const cache = createRowsInternalCache({
+    const cache = (0, _gridRowsUtils.createRowsInternalCache)({
       rows,
       getRowId: props.getRowId,
       loading: props.loading,
@@ -118,11 +120,11 @@ export const useGridRows = (apiRef, props) => {
     });
   }, [logger, props.getRowId, props.loading, props.rowCount, throttledRowsChange, apiRef]);
   const updateRows = React.useCallback(updates => {
-    if (props.signature === GridSignature.DataGrid && updates.length > 1) {
+    if (props.signature === _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({
+    const nonPinnedRowsUpdates = (0, _gridRowsUtils.computeRowsUpdates)(apiRef, updates, props.getRowId);
+    const cache = (0, _gridRowsUtils.updateCacheWithNewRows)({
       updates: nonPinnedRowsUpdates,
       getRowId: props.getRowId,
       previousCache: apiRef.current.caches.rows
@@ -133,8 +135,8 @@ export const useGridRows = (apiRef, props) => {
     });
   }, [props.signature, props.getRowId, throttledRowsChange, apiRef]);
   const updateServerRows = React.useCallback((updates, groupKeys) => {
-    const nonPinnedRowsUpdates = computeRowsUpdates(apiRef, updates, props.getRowId);
-    const cache = updateCacheWithNewRows({
+    const nonPinnedRowsUpdates = (0, _gridRowsUtils.computeRowsUpdates)(apiRef, updates, props.getRowId);
+    const cache = (0, _gridRowsUtils.updateCacheWithNewRows)({
       updates: nonPinnedRowsUpdates,
       getRowId: props.getRowId,
       previousCache: apiRef.current.caches.rows,
@@ -150,94 +152,93 @@ export const useGridRows = (apiRef, props) => {
       return;
     }
     logger.debug(`Setting loading to ${loading}`);
-    apiRef.current.setState(state => _extends({}, state, {
-      rows: _extends({}, state.rows, {
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      rows: (0, _extends2.default)({}, 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);
+    const dataRows = (0, _gridRowsSelector.gridDataRowIdsSelector)(apiRef);
+    const idRowsLookup = (0, _gridRowsSelector.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 getRowsCount = React.useCallback(() => (0, _gridRowsSelector.gridRowCountSelector)(apiRef), [apiRef]);
+  const getAllRowIds = React.useCallback(() => (0, _gridRowsSelector.gridDataRowIdsSelector)(apiRef), [apiRef]);
   const getRowIndexRelativeToVisibleRows = React.useCallback(id => {
     const {
       rowIdToIndexMap
-    } = getVisibleRows(apiRef);
+    } = (0, _useGridVisibleRows.getVisibleRows)(apiRef);
     return rowIdToIndexMap.get(id);
   }, [apiRef]);
   const setRowChildrenExpansion = React.useCallback((id, isExpanded) => {
-    const currentNode = apiRef.current.getRowNode(id);
+    const currentNode = (0, _gridRowsSelector.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, {
+    const newNode = (0, _extends2.default)({}, currentNode, {
       childrenExpanded: isExpanded
     });
     apiRef.current.setState(state => {
-      return _extends({}, state, {
-        rows: _extends({}, state.rows, {
-          tree: _extends({}, state.rows.tree, {
+      return (0, _extends2.default)({}, state, {
+        rows: (0, _extends2.default)({}, state.rows, {
+          tree: (0, _extends2.default)({}, state.rows.tree, {
             [id]: newNode
           })
         })
       });
     });
-    apiRef.current.forceUpdate();
     apiRef.current.publishEvent('rowExpansionChange', newNode);
   }, [apiRef]);
-  const getRowNode = React.useCallback(id => gridRowTreeSelector(apiRef)[id] ?? null, [apiRef]);
+  const getRowNode = React.useCallback(id => (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, id) ?? null, [apiRef]);
   const getRowGroupChildren = React.useCallback(({
     skipAutoGeneratedRows = true,
     groupId,
     applySorting,
     applyFiltering
   }) => {
-    const tree = gridRowTreeSelector(apiRef);
+    const tree = (0, _gridRowsSelector.gridRowTreeSelector)(apiRef);
     let children;
     if (applySorting) {
       const groupNode = tree[groupId];
       if (!groupNode) {
         return [];
       }
-      const sortedRowIds = gridSortedRowIdsSelector(apiRef);
+      const sortedRowIds = (0, _gridSortingSelector.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])) {
+        if (!skipAutoGeneratedRows || !(0, _gridRowsUtils.isAutogeneratedRowNode)(tree[id])) {
           children.push(id);
         }
       }
     } else {
-      children = getTreeNodeDescendants(tree, groupId, skipAutoGeneratedRows);
+      children = (0, _gridRowsUtils.getTreeNodeDescendants)(tree, groupId, skipAutoGeneratedRows);
     }
     if (applyFiltering) {
-      const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
-      children = children.filter(childId => filteredRowsLookup[childId] !== false);
+      const filteredRowsLookup = (0, _gridFilterSelector.gridFilteredRowsLookupSelector)(apiRef);
+      children = (0, _isObjectEmpty.isObjectEmpty)(filteredRowsLookup) ? children : children.filter(childId => filteredRowsLookup[childId] !== false);
     }
     return children;
   }, [apiRef]);
   const setRowIndex = React.useCallback((rowId, targetIndex) => {
-    const node = apiRef.current.getRowNode(rowId);
+    const node = (0, _gridRowsSelector.gridRowNodeSelector)(apiRef, rowId);
     if (!node) {
       throw new Error(`MUI X: No row with id #${rowId} found.`);
     }
-    if (node.parent !== GRID_ROOT_GROUP_ID) {
+    if (node.parent !== _gridRowsUtils.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(state, undefined, apiRef.current.instanceId)[GRID_ROOT_GROUP_ID];
+      const group = (0, _gridRowsSelector.gridRowTreeSelector)(apiRef)[_gridRowsUtils.GRID_ROOT_GROUP_ID];
       const allRows = group.children;
       const oldIndex = allRows.findIndex(row => row === rowId);
       if (oldIndex === -1 || oldIndex === targetIndex) {
@@ -246,10 +247,10 @@ export const useGridRows = (apiRef, props) => {
       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, {
+      return (0, _extends2.default)({}, state, {
+        rows: (0, _extends2.default)({}, state.rows, {
+          tree: (0, _extends2.default)({}, state.rows.tree, {
+            [_gridRowsUtils.GRID_ROOT_GROUP_ID]: (0, _extends2.default)({}, group, {
               children: updatedRows
             })
           })
@@ -259,24 +260,24 @@ export const useGridRows = (apiRef, props) => {
     apiRef.current.publishEvent('rowsSet');
   }, [apiRef, logger]);
   const replaceRows = React.useCallback((firstRowToRender, newRows) => {
-    if (props.signature === GridSignature.DataGrid && newRows.length > 1) {
+    if (props.signature === _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);
+    const treeDepth = (0, _gridRowsSelector.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 tree = (0, _extends2.default)({}, (0, _gridRowsSelector.gridRowTreeSelector)(apiRef));
+    const dataRowIdToModelLookup = (0, _extends2.default)({}, (0, _gridRowsSelector.gridRowsLookupSelector)(apiRef));
+    const rootGroup = tree[_gridRowsUtils.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 rowId = (0, _gridRowsUtils.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];
@@ -285,7 +286,7 @@ export const useGridRows = (apiRef, props) => {
       const rowTreeNodeConfig = {
         id: rowId,
         depth: 0,
-        parent: GRID_ROOT_GROUP_ID,
+        parent: _gridRowsUtils.GRID_ROOT_GROUP_ID,
         type: 'leaf',
         groupingKey: null
       };
@@ -293,15 +294,15 @@ export const useGridRows = (apiRef, props) => {
       tree[rowId] = rowTreeNodeConfig;
       seenIds.add(rowId);
     }
-    tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
+    tree[_gridRowsUtils.GRID_ROOT_GROUP_ID] = (0, _extends2.default)({}, 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, {
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      rows: (0, _extends2.default)({}, state.rows, {
         loading: props.loading,
         totalRowCount: Math.max(props.rowCount || 0, rootGroupChildren.length),
         dataRowIdToModelLookup,
@@ -342,17 +343,17 @@ export const useGridRows = (apiRef, props) => {
     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, {
+      cache = (0, _extends2.default)({}, apiRef.current.caches.rows, {
         updates: {
           type: 'full',
-          rows: gridDataRowIdsSelector(apiRef)
+          rows: (0, _gridRowsSelector.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({
+      cache = (0, _gridRowsUtils.createRowsInternalCache)({
         rows: props.rows,
         getRowId: props.getRowId,
         loading: props.loading,
@@ -364,7 +365,7 @@ export const useGridRows = (apiRef, props) => {
       throttle: false
     });
   }, [logger, apiRef, props.rows, props.getRowId, props.loading, props.rowCount, throttledRowsChange]);
-  const previousDataSource = useLazyRef(() => props.unstable_dataSource);
+  const previousDataSource = (0, _useLazyRef.default)(() => props.unstable_dataSource);
   const handleStrategyProcessorChange = React.useCallback(methodName => {
     if (props.unstable_dataSource && props.unstable_dataSource !== previousDataSource.current) {
       previousDataSource.current = props.unstable_dataSource;
@@ -377,12 +378,12 @@ export const useGridRows = (apiRef, props) => {
   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)) {
+    if (apiRef.current.getActiveStrategy(_strategyProcessing.GridStrategyGroup.RowTree) !== (0, _gridRowsSelector.gridRowGroupingNameSelector)(apiRef)) {
       groupRows();
     }
   }, [apiRef, groupRows]);
-  useGridApiEventHandler(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
-  useGridApiEventHandler(apiRef, 'strategyAvailabilityChange', handleStrategyActivityChange);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'strategyAvailabilityChange', handleStrategyActivityChange);
 
   /**
    * APPLIERS
@@ -390,14 +391,14 @@ export const useGridRows = (apiRef, props) => {
   const applyHydrateRowsProcessor = React.useCallback(() => {
     apiRef.current.setState(state => {
       const response = apiRef.current.unstable_applyPipeProcessors('hydrateRows', {
-        tree: gridRowTreeSelector(state, undefined, apiRef.current.instanceId),
-        treeDepths: gridRowTreeDepthsSelector(state, undefined, apiRef.current.instanceId),
-        dataRowIds: gridDataRowIdsSelector(state, undefined, apiRef.current.instanceId),
-        dataRowIdToModelLookup: gridRowsLookupSelector(state, undefined, apiRef.current.instanceId)
+        tree: (0, _gridRowsSelector.gridRowTreeSelector)(apiRef),
+        treeDepths: (0, _gridRowsSelector.gridRowTreeDepthsSelector)(apiRef),
+        dataRowIds: (0, _gridRowsSelector.gridDataRowIdsSelector)(apiRef),
+        dataRowIdToModelLookup: (0, _gridRowsSelector.gridRowsLookupSelector)(apiRef)
       });
-      return _extends({}, state, {
-        rows: _extends({}, state.rows, response, {
-          totalTopLevelRowCount: getTopLevelRowCount({
+      return (0, _extends2.default)({}, state, {
+        rows: (0, _extends2.default)({}, state.rows, response, {
+          totalTopLevelRowCount: (0, _gridRowsUtils.getTopLevelRowCount)({
             tree: response.tree,
             rowCountProp: props.rowCount
           })
@@ -405,12 +406,11 @@ export const useGridRows = (apiRef, props) => {
       });
     });
     apiRef.current.publishEvent('rowsSet');
-    apiRef.current.forceUpdate();
   }, [apiRef, props.rowCount]);
-  useGridRegisterPipeApplier(apiRef, 'hydrateRows', applyHydrateRowsProcessor);
-  useGridApiMethod(apiRef, rowApi, 'public');
-  useGridApiMethod(apiRef, rowProApi, props.signature === GridSignature.DataGrid ? 'private' : 'public');
-  useGridApiMethod(apiRef, rowProPrivateApi, 'private');
+  (0, _pipeProcessing.useGridRegisterPipeApplier)(apiRef, 'hydrateRows', applyHydrateRowsProcessor);
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, rowApi, 'public');
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, rowProApi, props.signature === _signature.GridSignature.DataGrid ? 'private' : 'public');
+  (0, _useGridApiMethod.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
@@ -434,23 +434,21 @@ export const useGridRows = (apiRef, props) => {
     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, {
+        apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+          rows: (0, _extends2.default)({}, state.rows, {
             loading: props.loading
           })
         }));
         apiRef.current.caches.rows.loadingPropBeforePartialUpdates = props.loading;
-        apiRef.current.forceUpdate();
       }
       if (!isNewRowCountAlreadyInState) {
-        apiRef.current.setState(state => _extends({}, state, {
-          rows: _extends({}, state.rows, {
+        apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+          rows: (0, _extends2.default)({}, 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;
-        apiRef.current.forceUpdate();
       }
       if (!isRowCountPropUpdated) {
         return;
@@ -458,7 +456,7 @@ export const useGridRows = (apiRef, props) => {
     }
     logger.debug(`Updating all rows, new length ${currentRows?.length}`);
     throttledRowsChange({
-      cache: createRowsInternalCache({
+      cache: (0, _gridRowsUtils.createRowsInternalCache)({
         rows: currentRows,
         getRowId: props.getRowId,
         loading: props.loading,
@@ -467,4 +465,5 @@ export const useGridRows = (apiRef, props) => {
       throttle: false
     });
   }, [props.rows, props.rowCount, props.getRowId, props.loading, props.unstable_dataSource, logger, throttledRowsChange, apiRef]);
-};
+};
+exports.useGridRows = useGridRows;

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

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