@mui/x-data-grid 6.0.0-alpha.0 → 6.0.0-alpha.2

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

@@ -0,0 +1,106 @@
+import { GridRowEntry, GridRowId, GridRowTreeConfig, GridValidRowModel } from '../../../models/gridRows';
+import type { DataGridProcessedProps } from '../../../models/props/DataGridProps';
+export interface GridRowsInternalCache {
+    /**
+     * The rows as they were the last time all the rows have been updated at once
+     * It is used to avoid processing several time the same set of rows
+     */
+    rowsBeforePartialUpdates: DataGridProcessedProps['rows'];
+    /**
+     * The value of the `loading` prop since the last time that the rows state was updated.
+     */
+    loadingPropBeforePartialUpdates: DataGridProcessedProps['loading'];
+    /**
+     * Lookup containing the latest model at all time (even those not stored in the state yet).
+     */
+    dataRowIdToModelLookup: GridRowIdToModelLookup;
+    /**
+     * Lookup containing the latest ids at all time (even those not stored in the state yet).
+     */
+    dataRowIdToIdLookup: GridRowIdToIdLookup;
+    /**
+     * List of updates (partial or full) applied since the last time the state was synced with the cache.
+     * It is used to build the tree.
+     * If the update is a full update, we rebuild the tree from scratch.
+     * If the update is a partial update, we only modify the impacted nodes.
+     */
+    updates: GridRowsPartialUpdates | GridRowsFullUpdate;
+}
+export interface GridRowsState {
+    /**
+     * Name of the algorithm used to group the rows
+     * It is useful to decide which filtering / sorting algorithm to apply, to avoid applying tree-data filtering on a grouping-by-column dataset for instance.
+     */
+    groupingName: string;
+    tree: GridRowTreeConfig;
+    /**
+     * Amount of nodes at each depth (including auto-generated ones)
+     */
+    treeDepths: GridTreeDepths;
+    dataRowIds: GridRowId[];
+    /**
+     * Matches the value of the `loading` prop.
+     */
+    loading?: boolean;
+    /**
+     * Amount of data rows provided to the grid.
+     * Includes the filtered and collapsed rows.
+     * Does not include the auto-generated rows (auto generated groups and footers).
+     */
+    totalRowCount: number;
+    /**
+     * Amount of top level rows.
+     * Includes the filtered rows and the auto-generated root footer if any.
+     * Does not include the rows of depth > 0 (rows inside a group).
+     */
+    totalTopLevelRowCount: number;
+    dataRowIdToModelLookup: GridRowIdToModelLookup;
+    dataRowIdToIdLookup: GridRowIdToIdLookup;
+    additionalRowGroups?: {
+        pinnedRows?: GridPinnedRowsState;
+    };
+}
+export interface GridRowTreeCreationParams {
+    previousTree: GridRowTreeConfig | null;
+    previousTreeDepths: GridTreeDepths | null;
+    updates: GridRowsPartialUpdates | GridRowsFullUpdate;
+    dataRowIdToIdLookup: GridRowIdToIdLookup;
+    dataRowIdToModelLookup: GridRowIdToModelLookup;
+}
+export declare type GridRowTreeUpdateGroupAction = 'removeChildren' | 'insertChildren' | 'modifyChildren';
+export declare type GridRowTreeUpdatedGroupsValue = {
+    [groupId: GridRowId]: {
+        [action in GridRowTreeUpdateGroupAction]?: boolean;
+    };
+};
+export declare type GridRowTreeUpdatedGroupsManager = {
+    value: GridRowTreeUpdatedGroupsValue;
+    addAction: (groupId: GridRowId, action: GridRowTreeUpdateGroupAction) => void;
+};
+export declare type GridRowTreeCreationValue = Pick<GridRowsState, 'groupingName' | 'tree' | 'treeDepths' | 'dataRowIds'> & {
+    updatedGroupsManager?: GridRowTreeUpdatedGroupsManager;
+};
+export declare type GridHydrateRowsValue = Pick<GridRowsState, 'tree' | 'treeDepths' | 'dataRowIds' | 'dataRowIdToIdLookup' | 'dataRowIdToModelLookup' | 'additionalRowGroups'>;
+export declare type GridRowsPartialUpdateAction = 'insert' | 'modify' | 'remove';
+export declare type GridRowIdToModelLookup<R extends GridValidRowModel = GridValidRowModel> = Record<string, R>;
+export declare type GridRowIdToIdLookup = Record<string, GridRowId>;
+export declare type GridTreeDepths = {
+    [depth: number]: number;
+};
+export interface GridRowsFullUpdate {
+    type: 'full';
+    rows: GridRowId[];
+}
+export interface GridRowsPartialUpdates {
+    type: 'partial';
+    actions: {
+        [action in GridRowsPartialUpdateAction]: GridRowId[];
+    };
+    idToActionLookup: {
+        [id: GridRowId]: GridRowsPartialUpdateAction | undefined;
+    };
+}
+export interface GridPinnedRowsState {
+    top?: GridRowEntry[];
+    bottom?: GridRowEntry[];
+}

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

@@ -1,24 +1,34 @@
 import { GridStateCommunity } from '../../../models/gridStateCommunity';
-export declare const gridRowsStateSelector: (state: GridStateCommunity) => import("./gridRowsState").GridRowsState;
+export declare const gridRowsStateSelector: (state: GridStateCommunity) => import("./gridRowsInterfaces").GridRowsState;
 export declare const gridRowCountSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, number>;
 export declare const gridRowsLoadingSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, boolean | undefined>;
 export declare const gridTopLevelRowCountSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, number>;
-export declare const gridRowsLookupSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("../../..").GridRowsLookup<import("../../..").GridValidRowModel>>;
-export declare const gridRowsIdToIdLookupSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, Record<string, import("../../..").GridRowId>>;
+export declare const gridRowsLookupSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowIdToModelLookup<import("../../..").GridValidRowModel>>;
+export declare const gridRowsDataRowIdToIdLookupSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowIdToIdLookup>;
 export declare const gridRowTreeSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("../../..").GridRowTreeConfig>;
 export declare const gridRowGroupingNameSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, string>;
-export declare const gridRowTreeDepthSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, number>;
-export declare const gridRowIdsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("../../..").GridRowId[]>;
+export declare const gridRowTreeDepthsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridTreeDepths>;
+export declare const gridRowMaximumTreeDepthSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, number>;
+export declare const gridDataRowIdsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("../../..").GridRowId[]>;
 /**
  * @ignore - do not document.
  */
 export declare const gridAdditionalRowGroupsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, {
-    pinnedRows?: import("./gridRowsState").GridPinnedRowsState | undefined;
+    pinnedRows?: import("./gridRowsInterfaces").GridPinnedRowsState | undefined;
 } | undefined>;
 /**
  * @ignore - do not document.
  */
-export declare const gridPinnedRowsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, import("./gridRowsState").GridPinnedRowsState | undefined>;
+export declare const gridPinnedRowsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, {
+    bottom: {
+        id: import("../../..").GridRowId;
+        model: import("../../..").GridValidRowModel;
+    }[] | undefined;
+    top: {
+        id: import("../../..").GridRowId;
+        model: import("../../..").GridValidRowModel;
+    }[] | undefined;
+}>;
 /**
  * @ignore - do not document.
  */

package/hooks/features/rows/gridRowsSelector.js

@@ -2,13 +2,23 @@ import { createSelector } from '../../../utils/createSelector';
 export const gridRowsStateSelector = state => state.rows;
 export const gridRowCountSelector = createSelector(gridRowsStateSelector, rows => rows.totalRowCount);
 export const gridRowsLoadingSelector = createSelector(gridRowsStateSelector, rows => rows.loading);
-export const gridTopLevelRowCountSelector = createSelector(gridRowsStateSelector, rows => rows.totalTopLevelRowCount);
-export const gridRowsLookupSelector = createSelector(gridRowsStateSelector, rows => rows.idRowsLookup);
-export const gridRowsIdToIdLookupSelector = createSelector(gridRowsStateSelector, rows => rows.idToIdLookup);
+export const gridTopLevelRowCountSelector = createSelector(gridRowsStateSelector, rows => rows.totalTopLevelRowCount); // TODO rows v6: Rename
+
+export const gridRowsLookupSelector = createSelector(gridRowsStateSelector, rows => rows.dataRowIdToModelLookup);
+export const gridRowsDataRowIdToIdLookupSelector = createSelector(gridRowsStateSelector, rows => rows.dataRowIdToIdLookup);
 export const gridRowTreeSelector = createSelector(gridRowsStateSelector, rows => rows.tree);
 export const gridRowGroupingNameSelector = createSelector(gridRowsStateSelector, rows => rows.groupingName);
-export const gridRowTreeDepthSelector = createSelector(gridRowsStateSelector, rows => rows.treeDepth);
-export const gridRowIdsSelector = createSelector(gridRowsStateSelector, rows => rows.ids);
+export const gridRowTreeDepthsSelector = createSelector(gridRowsStateSelector, rows => rows.treeDepths);
+export const gridRowMaximumTreeDepthSelector = createSelector(gridRowsStateSelector, rows => {
+  const entries = Object.entries(rows.treeDepths);
+
+  if (entries.length === 0) {
+    return 1;
+  }
+
+  return entries.filter(([, nodeCount]) => nodeCount > 0).map(([depth]) => Number(depth)).sort((a, b) => b - a)[0] + 1;
+});
+export const gridDataRowIdsSelector = createSelector(gridRowsStateSelector, rows => rows.dataRowIds);
 /**
  * @ignore - do not document.
  */
@@ -18,7 +28,29 @@ export const gridAdditionalRowGroupsSelector = createSelector(gridRowsStateSelec
  * @ignore - do not document.
  */
 
-export const gridPinnedRowsSelector = createSelector(gridAdditionalRowGroupsSelector, additionalRowGroups => additionalRowGroups == null ? void 0 : additionalRowGroups.pinnedRows);
+export const gridPinnedRowsSelector = createSelector(gridAdditionalRowGroupsSelector, additionalRowGroups => {
+  var _rawPinnedRows$bottom, _rawPinnedRows$top;
+
+  const rawPinnedRows = additionalRowGroups == null ? void 0 : additionalRowGroups.pinnedRows;
+  return {
+    bottom: rawPinnedRows == null ? void 0 : (_rawPinnedRows$bottom = rawPinnedRows.bottom) == null ? void 0 : _rawPinnedRows$bottom.map(rowEntry => {
+      var _rowEntry$model;
+
+      return {
+        id: rowEntry.id,
+        model: (_rowEntry$model = rowEntry.model) != null ? _rowEntry$model : {}
+      };
+    }),
+    top: rawPinnedRows == null ? void 0 : (_rawPinnedRows$top = rawPinnedRows.top) == null ? void 0 : _rawPinnedRows$top.map(rowEntry => {
+      var _rowEntry$model2;
+
+      return {
+        id: rowEntry.id,
+        model: (_rowEntry$model2 = rowEntry.model) != null ? _rowEntry$model2 : {}
+      };
+    })
+  };
+});
 /**
  * @ignore - do not document.
  */

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

@@ -1,8 +1,10 @@
 import * as React from 'react';
-import { GridRowId, GridRowIdGetter, GridRowModel, GridRowTreeConfig } from '../../../models';
+import { GridAutoGeneratedGroupNode, GridAutoGeneratedPinnedRowNode, GridFooterNode, GridGroupNode, GridRowId, GridRowIdGetter, GridRowModel, GridRowModelUpdate, GridRowTreeConfig, GridSkeletonRowNode, GridTreeNode } from '../../../models';
 import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
 import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
-import { GridRowsInternalCache, GridRowsState } from './gridRowsState';
+import { GridRowsInternalCache, GridRowsState, GridRowTreeCreationParams } from './gridRowsInterfaces';
+export declare const GRID_ROOT_GROUP_ID: GridRowId;
+export declare const buildRootGroup: () => GridGroupNode;
 /**
  * A helper function to check if the id provided is valid.
  * @param {GridRowId} id Id as [[GridRowId]].
@@ -12,14 +14,24 @@ import { GridRowsInternalCache, GridRowsState } from './gridRowsState';
 export declare function checkGridRowIdIsValid(id: GridRowId, row: GridRowModel | Partial<GridRowModel>, detailErrorMessage?: string): void;
 export declare const getRowIdFromRowModel: (rowModel: GridRowModel, getRowId?: GridRowIdGetter, detailErrorMessage?: string) => GridRowId;
 export declare const createRowsInternalCache: ({ rows, getRowId, loading, }: Pick<DataGridProcessedProps, 'rows' | 'getRowId' | 'loading'>) => GridRowsInternalCache;
-export declare const getRowsStateFromCache: ({ apiRef, previousTree, rowCountProp, loadingProp, }: {
+export declare const getTopLevelRowCount: ({ tree, rowCountProp, }: {
+    tree: GridRowTreeConfig;
+    rowCountProp: DataGridProcessedProps['rowCount'];
+}) => number;
+export declare const getRowsStateFromCache: ({ apiRef, rowCountProp, loadingProp, previousTree, previousTreeDepths, }: Pick<GridRowTreeCreationParams, "previousTree" | "previousTreeDepths"> & {
     apiRef: React.MutableRefObject<GridApiCommunity>;
-    previousTree: GridRowTreeConfig | null;
     rowCountProp: number | undefined;
     loadingProp: boolean | undefined;
 }) => GridRowsState;
+export declare const isAutoGeneratedRow: (rowNode: GridTreeNode) => rowNode is GridAutoGeneratedGroupNode | GridFooterNode | GridSkeletonRowNode | GridAutoGeneratedPinnedRowNode;
 export declare const getTreeNodeDescendants: (tree: GridRowTreeConfig, parentId: GridRowId, skipAutoGeneratedRows: boolean) => GridRowId[];
+export declare const updateCacheWithNewRows: ({ previousCache, getRowId, updates, }: {
+    previousCache: GridRowsInternalCache;
+    getRowId: DataGridProcessedProps['getRowId'];
+    updates: GridRowModelUpdate[];
+}) => GridRowsInternalCache;
 export declare function calculatePinnedRowsHeight(apiRef: React.MutableRefObject<GridApiCommunity>): {
     top: number;
     bottom: number;
 };
+export declare function getMinimalContentHeight(apiRef: React.MutableRefObject<GridApiCommunity>): number;

package/hooks/features/rows/gridRowsUtils.js

@@ -1,7 +1,19 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-const _excluded = ["rowsBeforePartialUpdates"];
 import { gridPinnedRowsSelector } from './gridRowsSelector';
+import { gridDensityRowHeightSelector } from '../density/densitySelector';
+export const GRID_ROOT_GROUP_ID = `auto-generated-group-node-root`;
+export const buildRootGroup = () => ({
+  type: 'group',
+  id: GRID_ROOT_GROUP_ID,
+  depth: -1,
+  groupingField: null,
+  groupingKey: null,
+  isAutoGenerated: true,
+  children: [],
+  childrenFromPath: {},
+  childrenExpanded: true,
+  parent: null
+});
 /**
  * A helper function to check if the id provided is valid.
  * @param {GridRowId} id Id as [[GridRowId]].
@@ -24,70 +36,237 @@ export const createRowsInternalCache = ({
   getRowId,
   loading
 }) => {
-  const cache = {
-    rowsBeforePartialUpdates: rows,
-    loadingPropBeforePartialUpdates: loading,
-    idRowsLookup: {},
-    idToIdLookup: {},
-    ids: []
+  const updates = {
+    type: 'full',
+    rows: []
   };
+  const dataRowIdToModelLookup = {};
+  const dataRowIdToIdLookup = {};
 
   for (let i = 0; i < rows.length; i += 1) {
-    const row = rows[i];
-    const id = getRowIdFromRowModel(row, getRowId);
-    cache.idRowsLookup[id] = row;
-    cache.idToIdLookup[id] = id;
-    cache.ids.push(id);
+    const model = rows[i];
+    const id = getRowIdFromRowModel(model, getRowId);
+    dataRowIdToModelLookup[id] = model;
+    dataRowIdToIdLookup[id] = id;
+    updates.rows.push(id);
   }
 
-  return cache;
+  return {
+    rowsBeforePartialUpdates: rows,
+    loadingPropBeforePartialUpdates: loading,
+    updates,
+    dataRowIdToIdLookup,
+    dataRowIdToModelLookup
+  };
+};
+export const getTopLevelRowCount = ({
+  tree,
+  rowCountProp = 0
+}) => {
+  const rootGroupNode = tree[GRID_ROOT_GROUP_ID];
+  return Math.max(rowCountProp, rootGroupNode.children.length + (rootGroupNode.footerId == null ? 0 : 1));
 };
 export const getRowsStateFromCache = ({
   apiRef,
+  rowCountProp = 0,
+  loadingProp,
   previousTree,
-  rowCountProp,
-  loadingProp
+  previousTreeDepths
 }) => {
-  const _apiRef$current$unsta = apiRef.current.unstable_caches.rows,
-        cacheForGrouping = _objectWithoutPropertiesLoose(_apiRef$current$unsta, _excluded);
-
-  const rowCount = rowCountProp != null ? rowCountProp : 0;
-  const groupingResponse = apiRef.current.unstable_applyStrategyProcessor('rowTreeCreation', _extends({}, cacheForGrouping, {
-    previousTree
-  }));
-  const processedGroupingResponse = apiRef.current.unstable_applyPipeProcessors('hydrateRows', groupingResponse);
-  const dataTopLevelRowCount = processedGroupingResponse.treeDepth === 1 ? processedGroupingResponse.ids.length : Object.values(processedGroupingResponse.tree).filter(node => node.parent == null && !node.isPinned).length;
-  return _extends({}, processedGroupingResponse, {
-    groupingResponseBeforeRowHydration: groupingResponse,
-    loading: loadingProp,
-    totalRowCount: Math.max(rowCount, processedGroupingResponse.ids.length),
-    totalTopLevelRowCount: Math.max(rowCount, dataTopLevelRowCount)
+  const cache = apiRef.current.unstable_caches.rows; // 1. Apply the "rowTreeCreation" family processing.
+
+  const {
+    tree: unProcessedTree,
+    treeDepths: unProcessedTreeDepths,
+    dataRowIds: unProcessedDataRowIds,
+    groupingName
+  } = apiRef.current.unstable_applyStrategyProcessor('rowTreeCreation', {
+    previousTree,
+    previousTreeDepths,
+    updates: cache.updates,
+    dataRowIdToIdLookup: cache.dataRowIdToIdLookup,
+    dataRowIdToModelLookup: cache.dataRowIdToModelLookup
+  }); // 2. Apply the "hydrateRows" pipe-processing.
+
+  const groupingParamsWithHydrateRows = apiRef.current.unstable_applyPipeProcessors('hydrateRows', {
+    tree: unProcessedTree,
+    treeDepths: unProcessedTreeDepths,
+    dataRowIdToIdLookup: cache.dataRowIdToIdLookup,
+    dataRowIds: unProcessedDataRowIds,
+    dataRowIdToModelLookup: cache.dataRowIdToModelLookup
+  }); // 3. Reset the cache updates
+
+  apiRef.current.unstable_caches.rows.updates = {
+    type: 'partial',
+    actions: {
+      insert: [],
+      modify: [],
+      remove: []
+    },
+    idToActionLookup: {}
+  };
+  return _extends({}, groupingParamsWithHydrateRows, {
+    totalRowCount: Math.max(rowCountProp, groupingParamsWithHydrateRows.dataRowIds.length),
+    totalTopLevelRowCount: getTopLevelRowCount({
+      tree: groupingParamsWithHydrateRows.tree,
+      rowCountProp
+    }),
+    groupingName,
+    loading: loadingProp
   });
 };
+export const isAutoGeneratedRow = rowNode => rowNode.type === 'skeletonRow' || rowNode.type === 'footer' || rowNode.type === 'group' && rowNode.isAutoGenerated || rowNode.type === 'pinnedRow' && rowNode.isAutoGenerated;
 export const getTreeNodeDescendants = (tree, parentId, skipAutoGeneratedRows) => {
-  var _tree$parentId;
-
-  const children = (_tree$parentId = tree[parentId]) == null ? void 0 : _tree$parentId.children;
+  const node = tree[parentId];
 
-  if (children == null) {
+  if (node.type !== 'group') {
     return [];
   }
 
   const validDescendants = [];
 
-  for (let i = 0; i < children.length; i += 1) {
-    const child = children[i];
-    const childNode = tree[child];
+  for (let i = 0; i < node.children.length; i += 1) {
+    const child = node.children[i];
 
-    if (!skipAutoGeneratedRows || !childNode.isAutoGenerated) {
+    if (!skipAutoGeneratedRows || !isAutoGeneratedRow(tree[child])) {
       validDescendants.push(child);
     }
 
-    validDescendants.push(...getTreeNodeDescendants(tree, childNode.id, skipAutoGeneratedRows));
+    validDescendants.push(...getTreeNodeDescendants(tree, child, skipAutoGeneratedRows));
+  }
+
+  if (!skipAutoGeneratedRows && node.footerId != null) {
+    validDescendants.push(node.footerId);
   }
 
   return validDescendants;
 };
+export const updateCacheWithNewRows = ({
+  previousCache,
+  getRowId,
+  updates
+}) => {
+  var _previousCache$update, _previousCache$update2, _previousCache$update3;
+
+  if (previousCache.updates.type === 'full') {
+    throw new Error('MUI: Unable to prepare a partial update if a full update is not applied yet');
+  } // Remove duplicate updates.
+  // A server can batch updates, and send several updates for the same row in one fn call.
+
+
+  const uniqueUpdates = new Map();
+  updates.forEach(update => {
+    const id = getRowIdFromRowModel(update, getRowId, 'A row was provided without id when calling updateRows():');
+
+    if (uniqueUpdates.has(id)) {
+      uniqueUpdates.set(id, _extends({}, uniqueUpdates.get(id), update));
+    } else {
+      uniqueUpdates.set(id, update);
+    }
+  });
+  const partialUpdates = {
+    type: 'partial',
+    actions: {
+      insert: [...((_previousCache$update = previousCache.updates.actions.insert) != null ? _previousCache$update : [])],
+      modify: [...((_previousCache$update2 = previousCache.updates.actions.modify) != null ? _previousCache$update2 : [])],
+      remove: [...((_previousCache$update3 = previousCache.updates.actions.remove) != null ? _previousCache$update3 : [])]
+    },
+    idToActionLookup: _extends({}, previousCache.updates.idToActionLookup)
+  };
+
+  const dataRowIdToModelLookup = _extends({}, previousCache.dataRowIdToModelLookup);
+
+  const dataRowIdToIdLookup = _extends({}, previousCache.dataRowIdToIdLookup);
+
+  const alreadyAppliedActionsToRemove = {
+    insert: {},
+    modify: {},
+    remove: {}
+  }; // Depending on the action already applied to the data row,
+  // We might want drop the already-applied-update.
+  // For instance:
+  // - if you delete then insert, then you don't want to apply the deletion in the tree.
+  // - if you insert, then modify, then you just want to apply the insertion in the tree.
+
+  uniqueUpdates.forEach((partialRow, id) => {
+    const actionAlreadyAppliedToRow = partialUpdates.idToActionLookup[id]; // Action === "delete"
+    // eslint-disable-next-line no-underscore-dangle
+
+    if (partialRow._action === 'delete') {
+      // If the data row has been removed since the last state update,
+      // Then do nothing.
+      if (actionAlreadyAppliedToRow === 'remove' || !dataRowIdToModelLookup[id]) {
+        return;
+      } // If the data row has been inserted / modified since the last state update,
+      // Then drop this "insert" / "modify" update.
+
+
+      if (actionAlreadyAppliedToRow != null) {
+        alreadyAppliedActionsToRemove[actionAlreadyAppliedToRow][id] = true;
+      } // Remove the data row from the lookups and add it to the "delete" update.
+
+
+      partialUpdates.actions.remove.push(id);
+      delete dataRowIdToModelLookup[id];
+      delete dataRowIdToIdLookup[id];
+      return;
+    }
+
+    const oldRow = dataRowIdToModelLookup[id]; // Action === "modify"
+
+    if (oldRow) {
+      // If the data row has been removed since the last state update,
+      // Then drop this "remove" update and add it to the "modify" update instead.
+      if (actionAlreadyAppliedToRow === 'remove') {
+        alreadyAppliedActionsToRemove.remove[id] = true;
+        partialUpdates.actions.modify.push(id);
+      } // If the date has not been inserted / modified since the last state update,
+      // Then add it to the "modify" update (if it has been inserted it should just remain "inserted").
+      else if (actionAlreadyAppliedToRow == null) {
+        partialUpdates.actions.modify.push(id);
+      } // Update the data row lookups.
+
+
+      dataRowIdToModelLookup[id] = _extends({}, oldRow, partialRow);
+      return;
+    } // Action === "insert"
+    // If the data row has been removed since the last state update,
+    // Then drop the "remove" update and add it to the "insert" update instead.
+
+
+    if (actionAlreadyAppliedToRow === 'remove') {
+      alreadyAppliedActionsToRemove.remove[id] = true;
+      partialUpdates.actions.insert.push(id);
+    } // If the data row has not been inserted since the last state update,
+    // Then add it to the "insert" update.
+    // `actionAlreadyAppliedToRow` can't be equal to "modify", otherwise we would have an `oldRow` above.
+    else if (actionAlreadyAppliedToRow == null) {
+      partialUpdates.actions.insert.push(id);
+    } // Update the data row lookups.
+
+
+    dataRowIdToModelLookup[id] = partialRow;
+    dataRowIdToIdLookup[id] = id;
+  });
+  const actionTypeWithActionsToRemove = Object.keys(alreadyAppliedActionsToRemove);
+
+  for (let i = 0; i < actionTypeWithActionsToRemove.length; i += 1) {
+    const actionType = actionTypeWithActionsToRemove[i];
+    const idsToRemove = alreadyAppliedActionsToRemove[actionType];
+
+    if (Object.keys(idsToRemove).length > 0) {
+      partialUpdates.actions[actionType] = partialUpdates.actions[actionType].filter(id => !idsToRemove[id]);
+    }
+  }
+
+  return {
+    dataRowIdToModelLookup,
+    dataRowIdToIdLookup,
+    updates: partialUpdates,
+    rowsBeforePartialUpdates: previousCache.rowsBeforePartialUpdates,
+    loadingPropBeforePartialUpdates: previousCache.loadingPropBeforePartialUpdates
+  };
+};
 export function calculatePinnedRowsHeight(apiRef) {
   var _pinnedRows$top, _pinnedRows$bottom;
 
@@ -104,4 +283,8 @@ export function calculatePinnedRowsHeight(apiRef) {
     top: topPinnedRowsHeight,
     bottom: bottomPinnedRowsHeight
   };
+}
+export function getMinimalContentHeight(apiRef) {
+  const rowHeight = gridDensityRowHeightSelector(apiRef);
+  return 2 * rowHeight;
 }

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

@@ -1,5 +1,5 @@
 export * from './gridRowsMetaSelector';
 export * from './gridRowsMetaState';
-export { gridRowsStateSelector, gridRowCountSelector, gridRowsLoadingSelector, gridTopLevelRowCountSelector, gridRowsLookupSelector, gridRowsIdToIdLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthSelector, gridRowIdsSelector, } from './gridRowsSelector';
-export type { GridRowsState } from './gridRowsState';
-export { checkGridRowIdIsValid } from './gridRowsUtils';
+export { gridRowsStateSelector, gridRowCountSelector, gridRowsLoadingSelector, gridTopLevelRowCountSelector, gridRowsLookupSelector, gridRowsDataRowIdToIdLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridRowMaximumTreeDepthSelector, gridDataRowIdsSelector, } from './gridRowsSelector';
+export type { GridRowsState, GridRowIdToModelLookup } from './gridRowsInterfaces';
+export { GRID_ROOT_GROUP_ID, checkGridRowIdIsValid } from './gridRowsUtils';

package/hooks/features/rows/index.js

@@ -1,4 +1,4 @@
 export * from './gridRowsMetaSelector';
 export * from './gridRowsMetaState';
-export { gridRowsStateSelector, gridRowCountSelector, gridRowsLoadingSelector, gridTopLevelRowCountSelector, gridRowsLookupSelector, gridRowsIdToIdLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthSelector, gridRowIdsSelector } from './gridRowsSelector';
-export { checkGridRowIdIsValid } from './gridRowsUtils';
+export { gridRowsStateSelector, gridRowCountSelector, gridRowsLoadingSelector, gridTopLevelRowCountSelector, gridRowsLookupSelector, gridRowsDataRowIdToIdLookupSelector, gridRowTreeSelector, gridRowGroupingNameSelector, gridRowTreeDepthsSelector, gridRowMaximumTreeDepthSelector, gridDataRowIdsSelector } from './gridRowsSelector';
+export { GRID_ROOT_GROUP_ID, checkGridRowIdIsValid } from './gridRowsUtils';