@mui/x-data-grid 8.0.0-alpha.11 → 8.0.0-alpha.13

package/esm/hooks/features/rowSelection/utils.js

@@ -0,0 +1,163 @@
+import { GridSignature } from "../../../constants/signature.js";
+import { GRID_ROOT_GROUP_ID } from "../rows/gridRowsUtils.js";
+import { gridFilteredRowsLookupSelector } from "../filter/gridFilterSelector.js";
+import { gridSortedRowIdsSelector } from "../sorting/gridSortingSelector.js";
+import { gridRowSelectionManagerSelector } from "./gridRowSelectionSelector.js";
+import { gridRowTreeSelector } from "../rows/gridRowsSelector.js";
+import { createSelector } from "../../../utils/createSelector.js";
+export const ROW_SELECTION_PROPAGATION_DEFAULT = {
+  parents: true,
+  descendants: true
+};
+function getGridRowGroupSelectableDescendants(apiRef, groupId) {
+  const rowTree = gridRowTreeSelector(apiRef);
+  const sortedRowIds = gridSortedRowIdsSelector(apiRef);
+  const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
+  const groupNode = rowTree[groupId];
+  if (!groupNode || groupNode.type !== 'group') {
+    return [];
+  }
+  const descendants = [];
+  const startIndex = sortedRowIds.findIndex(id => id === groupId) + 1;
+  for (let index = startIndex; index < sortedRowIds.length && rowTree[sortedRowIds[index]]?.depth > groupNode.depth; index += 1) {
+    const id = sortedRowIds[index];
+    if (filteredRowsLookup[id] !== false && apiRef.current.isRowSelectable(id)) {
+      descendants.push(id);
+    }
+  }
+  return descendants;
+}
+
+// TODO v8: Use `createSelectorV8`
+export function getCheckboxPropsSelector(groupId, autoSelectParents) {
+  return createSelector(gridRowTreeSelector, gridSortedRowIdsSelector, gridFilteredRowsLookupSelector, gridRowSelectionManagerSelector, (rowTree, sortedRowIds, filteredRowsLookup, rowSelectionManager) => {
+    const groupNode = rowTree[groupId];
+    if (!groupNode || groupNode.type !== 'group') {
+      return {
+        isIndeterminate: false,
+        isChecked: rowSelectionManager.has(groupId)
+      };
+    }
+    if (rowSelectionManager.has(groupId)) {
+      return {
+        isIndeterminate: false,
+        isChecked: true
+      };
+    }
+    let selectableDescendantsCount = 0;
+    let selectedDescendantsCount = 0;
+    const startIndex = sortedRowIds.findIndex(id => id === groupId) + 1;
+    for (let index = startIndex; index < sortedRowIds.length && rowTree[sortedRowIds[index]]?.depth > groupNode.depth; index += 1) {
+      const id = sortedRowIds[index];
+      if (filteredRowsLookup[id] !== false) {
+        selectableDescendantsCount += 1;
+        if (rowSelectionManager.has(id)) {
+          selectedDescendantsCount += 1;
+        }
+      }
+    }
+    return {
+      isIndeterminate: selectedDescendantsCount > 0 && (selectedDescendantsCount < selectableDescendantsCount || !rowSelectionManager.has(groupId)),
+      isChecked: autoSelectParents ? selectedDescendantsCount > 0 : rowSelectionManager.has(groupId)
+    };
+  });
+}
+export function isMultipleRowSelectionEnabled(props) {
+  if (props.signature === GridSignature.DataGrid) {
+    // DataGrid Community has multiple row selection enabled only if checkbox selection is enabled.
+    return props.checkboxSelection && props.disableMultipleRowSelection !== true;
+  }
+  return !props.disableMultipleRowSelection;
+}
+const getRowNodeParents = (tree, id) => {
+  const parents = [];
+  let parent = id;
+  while (parent != null && parent !== GRID_ROOT_GROUP_ID) {
+    const node = tree[parent];
+    if (!node) {
+      return parents;
+    }
+    parents.push(parent);
+    parent = node.parent;
+  }
+  return parents;
+};
+const getFilteredRowNodeSiblings = (tree, filteredRows, id) => {
+  const node = tree[id];
+  if (!node) {
+    return [];
+  }
+  const parent = node.parent;
+  if (parent == null) {
+    return [];
+  }
+  const parentNode = tree[parent];
+  return parentNode.children.filter(childId => childId !== id && filteredRows[childId] !== false);
+};
+export const findRowsToSelect = (apiRef, tree, selectedRow, autoSelectDescendants, autoSelectParents, addRow) => {
+  const filteredRows = gridFilteredRowsLookupSelector(apiRef);
+  const rowSelectionManager = gridRowSelectionManagerSelector(apiRef);
+  const selectedDescendants = new Set([]);
+  if (!autoSelectDescendants && !autoSelectParents) {
+    return;
+  }
+  if (autoSelectDescendants) {
+    const rowNode = tree[selectedRow];
+    if (rowNode?.type === 'group') {
+      const descendants = getGridRowGroupSelectableDescendants(apiRef, selectedRow);
+      descendants.forEach(rowId => {
+        addRow(rowId);
+        selectedDescendants.add(rowId);
+      });
+    }
+  }
+  if (autoSelectParents) {
+    const checkAllDescendantsSelected = rowId => {
+      if (!rowSelectionManager.has(rowId) && !selectedDescendants.has(rowId)) {
+        return false;
+      }
+      const node = tree[rowId];
+      if (node?.type !== 'group') {
+        return true;
+      }
+      return node.children.every(checkAllDescendantsSelected);
+    };
+    const traverseParents = rowId => {
+      const siblings = getFilteredRowNodeSiblings(tree, filteredRows, rowId);
+      if (siblings.length === 0 || siblings.every(checkAllDescendantsSelected)) {
+        const rowNode = tree[rowId];
+        const parent = rowNode.parent;
+        if (parent != null && parent !== GRID_ROOT_GROUP_ID && apiRef.current.isRowSelectable(parent)) {
+          addRow(parent);
+          selectedDescendants.add(parent);
+          traverseParents(parent);
+        }
+      }
+    };
+    traverseParents(selectedRow);
+  }
+};
+export const findRowsToDeselect = (apiRef, tree, deselectedRow, autoSelectDescendants, autoSelectParents, removeRow) => {
+  const rowSelectionManager = gridRowSelectionManagerSelector(apiRef);
+  if (!autoSelectParents && !autoSelectDescendants) {
+    return;
+  }
+  if (autoSelectParents) {
+    const allParents = getRowNodeParents(tree, deselectedRow);
+    allParents.forEach(parent => {
+      const isSelected = rowSelectionManager.has(parent);
+      if (isSelected) {
+        removeRow(parent);
+      }
+    });
+  }
+  if (autoSelectDescendants) {
+    const rowNode = tree[deselectedRow];
+    if (rowNode?.type === 'group') {
+      const descendants = getGridRowGroupSelectableDescendants(apiRef, deselectedRow);
+      descendants.forEach(descendant => {
+        removeRow(descendant);
+      });
+    }
+  }
+};

package/esm/hooks/features/rows/gridRowSpanningSelectors.d.ts

@@ -0,0 +1,4 @@
+import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
+export declare const gridRowSpanningHiddenCellsSelector: import("../../..").OutputSelector<GridStateCommunity, import("./useGridRowSpanning").GridRowSpanningState, Record<import("../../..").GridRowId, Record<string, boolean>>>;
+export declare const gridRowSpanningSpannedCellsSelector: import("../../..").OutputSelector<GridStateCommunity, import("./useGridRowSpanning").GridRowSpanningState, Record<import("../../..").GridRowId, Record<string, number>>>;
+export declare const gridRowSpanningHiddenCellsOriginMapSelector: import("../../..").OutputSelector<GridStateCommunity, import("./useGridRowSpanning").GridRowSpanningState, Record<number, Record<string, number>>>;

package/esm/hooks/features/rows/gridRowSpanningSelectors.js

@@ -0,0 +1,5 @@
+import { createSelector, createRootSelector } from "../../../utils/createSelector.js";
+const gridRowSpanningStateSelector = createRootSelector(state => state.rowSpanning);
+export const gridRowSpanningHiddenCellsSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.hiddenCells);
+export const gridRowSpanningSpannedCellsSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.spannedCells);
+export const gridRowSpanningHiddenCellsOriginMapSelector = createSelector(gridRowSpanningStateSelector, rowSpanning => rowSpanning.hiddenCellOriginMap);

package/esm/hooks/features/rows/gridRowSpanningUtils.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from '@mui/x-internals/types';
+import type { GridRenderContext } from '../../../models';
+import type { GridValidRowModel } from '../../../models/gridRows';
+import type { GridColDef } from '../../../models/colDef';
+import type { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+import type { RowRange } from './useGridRowSpanning';
+export declare function getUnprocessedRange(testRange: RowRange, processedRange: RowRange): RowRange | null;
+export declare function isRowContextInitialized(renderContext: GridRenderContext): boolean;
+export declare function isRowRangeUpdated(range1: RowRange, range2: RowRange): boolean;
+export declare const getCellValue: (row: GridValidRowModel, colDef: GridColDef, apiRef: RefObject<GridApiCommunity>) => any;

package/esm/hooks/features/rows/gridRowSpanningUtils.js

@@ -0,0 +1,42 @@
+export function getUnprocessedRange(testRange, processedRange) {
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return null;
+  }
+  // Overflowing at the end
+  // Example: testRange={ firstRowIndex: 10, lastRowIndex: 20 }, processedRange={ firstRowIndex: 0, lastRowIndex: 15 }
+  // Unprocessed Range={ firstRowIndex: 16, lastRowIndex: 20 }
+  if (testRange.firstRowIndex >= processedRange.firstRowIndex && testRange.lastRowIndex > processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: processedRange.lastRowIndex,
+      lastRowIndex: testRange.lastRowIndex
+    };
+  }
+  // Overflowing at the beginning
+  // Example: testRange={ firstRowIndex: 0, lastRowIndex: 20 }, processedRange={ firstRowIndex: 16, lastRowIndex: 30 }
+  // Unprocessed Range={ firstRowIndex: 0, lastRowIndex: 15 }
+  if (testRange.firstRowIndex < processedRange.firstRowIndex && testRange.lastRowIndex <= processedRange.lastRowIndex) {
+    return {
+      firstRowIndex: testRange.firstRowIndex,
+      lastRowIndex: processedRange.firstRowIndex - 1
+    };
+  }
+  // TODO: Should return two ranges handle overflowing at both ends ?
+  return testRange;
+}
+export function isRowContextInitialized(renderContext) {
+  return renderContext.firstRowIndex !== 0 || renderContext.lastRowIndex !== 0;
+}
+export function isRowRangeUpdated(range1, range2) {
+  return range1.firstRowIndex !== range2.firstRowIndex || range1.lastRowIndex !== range2.lastRowIndex;
+}
+export const getCellValue = (row, colDef, apiRef) => {
+  if (!row) {
+    return null;
+  }
+  let cellValue = row[colDef.field];
+  const valueGetter = colDef.rowSpanValueGetter ?? colDef.valueGetter;
+  if (valueGetter) {
+    cellValue = valueGetter(cellValue, row, colDef, apiRef);
+  }
+  return cellValue;
+};

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

@@ -0,0 +1,108 @@
+import { GridRowEntry, GridRowId, GridRowTreeConfig, GridValidRowModel } from "../../../models/gridRows.js";
+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'];
+  /**
+   * The value of the `rowCount` prop since the last time that the rows state was updated.
+   */
+  rowCountPropBeforePartialUpdates: DataGridProcessedProps['rowCount'];
+  /**
+   * Lookup containing the latest model at all time (even those not stored in the state yet).
+   */
+  dataRowIdToModelLookup: GridRowIdToModelLookup;
+  /**
+   * 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[];
+  /**
+   * The loading status of the rows.
+   */
+  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;
+  additionalRowGroups?: {
+    pinnedRows?: GridPinnedRowsState;
+  };
+  /**
+   * Contains some values of type `GridRowId` that have been requested to be fetched
+   * either by `defaultGroupingExpansionDepth` or `isGroupExpandedByDefault` props.
+   * Applicable with server-side grouped data and `dataSource` only.
+   */
+  groupsToFetch?: GridRowId[];
+}
+export interface GridRowTreeCreationParams {
+  previousTree: GridRowTreeConfig | null;
+  previousTreeDepths: GridTreeDepths | null;
+  updates: GridRowsPartialUpdates | GridRowsFullUpdate;
+  dataRowIdToModelLookup: GridRowIdToModelLookup;
+  previousGroupsToFetch?: GridRowId[];
+}
+export type GridRowTreeUpdateGroupAction = 'removeChildren' | 'insertChildren' | 'modifyChildren';
+export type GridRowTreeUpdatedGroupsValue = {
+  [groupId: GridRowId]: { [action in GridRowTreeUpdateGroupAction]?: boolean };
+};
+export type GridRowTreeUpdatedGroupsManager = {
+  value: GridRowTreeUpdatedGroupsValue;
+  addAction: (groupId: GridRowId, action: GridRowTreeUpdateGroupAction) => void;
+};
+export type GridRowTreeCreationValue = Pick<GridRowsState, 'groupingName' | 'tree' | 'treeDepths' | 'dataRowIds' | 'groupsToFetch'> & {
+  updatedGroupsManager?: GridRowTreeUpdatedGroupsManager;
+};
+export type GridHydrateRowsValue = Pick<GridRowsState, 'tree' | 'treeDepths' | 'dataRowIds' | 'dataRowIdToModelLookup' | 'additionalRowGroups'>;
+export type GridRowsPartialUpdateAction = 'insert' | 'modify' | 'remove';
+export type GridRowIdToModelLookup<R extends GridValidRowModel = GridValidRowModel> = Record<string, R>;
+export 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;
+  };
+  groupKeys?: string[];
+}
+export interface GridPinnedRowsState {
+  top?: GridRowEntry[];
+  bottom?: GridRowEntry[];
+}
+export type GridPinnedRowsPosition = keyof GridPinnedRowsState;

package/esm/hooks/features/rows/gridRowsInterfaces.js

@@ -0,0 +1 @@
+export {};

package/esm/hooks/features/rows/gridRowsMetaInterfaces.d.ts

@@ -0,0 +1,16 @@
+import { GridRowId } from "../../../models/gridRows.js";
+export type HeightEntry = {
+  content: number;
+  spacingTop: number;
+  spacingBottom: number;
+  detail: number;
+  autoHeight: boolean;
+  needsFirstMeasurement: boolean;
+};
+export type HeightCache = Map<GridRowId, HeightEntry>;
+export interface GridRowsMetaInternalCache {
+  /**
+   * Map of height cache entries.
+   */
+  heights: HeightCache;
+}

package/esm/hooks/features/rows/gridRowsMetaInterfaces.js

@@ -0,0 +1 @@
+export {};

package/esm/hooks/features/rows/gridRowsMetaSelector.d.ts

@@ -0,0 +1,2 @@
+import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
+export declare const gridRowsMetaSelector: import("../../..").OutputSelector<GridStateCommunity, unknown, import("./gridRowsMetaState").GridRowsMetaState>;

package/esm/hooks/features/rows/gridRowsMetaSelector.js

@@ -0,0 +1,2 @@
+import { createRootSelector } from "../../../utils/createSelector.js";
+export const gridRowsMetaSelector = createRootSelector(state => state.rowsMeta);

package/esm/hooks/features/rows/gridRowsMetaState.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The grid rows total height and row positions.
+ */
+export interface GridRowsMetaState {
+  /**
+   * The sum of all visible grid rows in the current rows.
+   */
+  currentPageTotalHeight: number;
+  /**
+   * The grid rows positions.
+   */
+  positions: number[];
+  /**
+   * The total height of the pinned top rows.
+   */
+  pinnedTopRowsTotalHeight: number;
+  /**
+   * The total height of the pinned bottom rows.
+   */
+  pinnedBottomRowsTotalHeight: number;
+}

package/esm/hooks/features/rows/gridRowsMetaState.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,49 @@
+import { GridRowId } from "../../../models/gridRows.js";
+import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
+export declare const gridRowsStateSelector: import("../../..").OutputSelector<GridStateCommunity, unknown, import("./gridRowsInterfaces").GridRowsState>;
+export declare const gridRowCountSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, number>;
+export declare const gridRowsLoadingSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, boolean | undefined>;
+export declare const gridTopLevelRowCountSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, number>;
+export declare const gridRowsLookupSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, import("./gridRowsInterfaces").GridRowIdToModelLookup<import("../../..").GridValidRowModel>>;
+export declare const gridRowSelector: import("../../..").OutputSelector<GridStateCommunity, GridRowId, import("../../..").GridValidRowModel>;
+export declare const gridRowTreeSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, import("../../..").GridRowTreeConfig>;
+export declare const gridRowNodeSelector: import("../../..").OutputSelector<GridStateCommunity, GridRowId, import("../../..").GridTreeNode>;
+export declare const gridRowGroupsToFetchSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, GridRowId[] | undefined>;
+export declare const gridRowGroupingNameSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, string>;
+export declare const gridRowTreeDepthsSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, import("./gridRowsInterfaces").GridTreeDepths>;
+export declare const gridRowMaximumTreeDepthSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, number>;
+export declare const gridDataRowIdsSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, GridRowId[]>;
+/**
+ * @ignore - do not document.
+ */
+export declare const gridAdditionalRowGroupsSelector: import("../../..").OutputSelector<GridStateCommunity, import("./gridRowsInterfaces").GridRowsState, {
+  pinnedRows?: import("./gridRowsInterfaces").GridPinnedRowsState;
+} | undefined>;
+/**
+ * @ignore - do not document.
+ */
+export declare const gridPinnedRowsSelector: import("../../..").OutputSelector<GridStateCommunity, {
+  pinnedRows?: import("./gridRowsInterfaces").GridPinnedRowsState;
+} | undefined, {
+  bottom: {
+    id: GridRowId;
+    model: import("../../..").GridValidRowModel;
+  }[];
+  top: {
+    id: GridRowId;
+    model: import("../../..").GridValidRowModel;
+  }[];
+}>;
+/**
+ * @ignore - do not document.
+ */
+export declare const gridPinnedRowsCountSelector: import("../../..").OutputSelector<GridStateCommunity, {
+  bottom: {
+    id: GridRowId;
+    model: import("../../..").GridValidRowModel;
+  }[];
+  top: {
+    id: GridRowId;
+    model: import("../../..").GridValidRowModel;
+  }[];
+}, number>;

package/esm/hooks/features/rows/gridRowsSelector.js

@@ -0,0 +1,51 @@
+import { createRootSelector, createSelector, createSelectorMemoized } from "../../../utils/createSelector.js";
+export const gridRowsStateSelector = createRootSelector(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);
+
+// TODO rows v6: Rename
+export const gridRowsLookupSelector = createSelector(gridRowsStateSelector, rows => rows.dataRowIdToModelLookup);
+export const gridRowSelector = createSelector(gridRowsLookupSelector, (rows, id) => rows[id]);
+export const gridRowTreeSelector = createSelector(gridRowsStateSelector, rows => rows.tree);
+export const gridRowNodeSelector = createSelector(gridRowTreeSelector, (rowTree, rowId) => rowTree[rowId]);
+export const gridRowGroupsToFetchSelector = createSelector(gridRowsStateSelector, rows => rows.groupsToFetch);
+export const gridRowGroupingNameSelector = createSelector(gridRowsStateSelector, rows => rows.groupingName);
+export const gridRowTreeDepthsSelector = createSelector(gridRowsStateSelector, rows => rows.treeDepths);
+export const gridRowMaximumTreeDepthSelector = createSelectorMemoized(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] ?? 0) + 1;
+});
+export const gridDataRowIdsSelector = createSelector(gridRowsStateSelector, rows => rows.dataRowIds);
+
+/**
+ * @ignore - do not document.
+ */
+export const gridAdditionalRowGroupsSelector = createSelector(gridRowsStateSelector, rows => rows?.additionalRowGroups);
+
+/**
+ * @ignore - do not document.
+ */
+export const gridPinnedRowsSelector = createSelectorMemoized(gridAdditionalRowGroupsSelector, additionalRowGroups => {
+  const rawPinnedRows = additionalRowGroups?.pinnedRows;
+  return {
+    bottom: rawPinnedRows?.bottom?.map(rowEntry => ({
+      id: rowEntry.id,
+      model: rowEntry.model ?? {}
+    })) ?? [],
+    top: rawPinnedRows?.top?.map(rowEntry => ({
+      id: rowEntry.id,
+      model: rowEntry.model ?? {}
+    })) ?? []
+  };
+});
+
+/**
+ * @ignore - do not document.
+ */
+export const gridPinnedRowsCountSelector = createSelector(gridPinnedRowsSelector, pinnedRows => {
+  return (pinnedRows?.top?.length || 0) + (pinnedRows?.bottom?.length || 0);
+});

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

@@ -0,0 +1,61 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridAutoGeneratedGroupNode, GridAutoGeneratedPinnedRowNode, GridColDef, GridFooterNode, GridGroupNode, GridRowId, GridRowIdGetter, GridRowModel, GridRowModelUpdate, GridRowTreeConfig, GridSkeletonRowNode, GridTreeNode, GridValidRowModel } from "../../../models/index.js";
+import { DataGridProcessedProps } from "../../../models/props/DataGridProps.js";
+import { GridApiCommunity, GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
+import { GridRowsInternalCache, GridRowsState, GridRowTreeCreationParams } from "./gridRowsInterfaces.js";
+export declare const GRID_ROOT_GROUP_ID: GridRowId;
+export declare const GRID_ID_AUTOGENERATED: unique symbol;
+export declare const buildRootGroup: () => GridGroupNode;
+/**
+ * A helper function to check if the id provided is valid.
+ * @param {GridRowId} id Id as [[GridRowId]].
+ * @param {GridRowModel | Partial<GridRowModel>} row Row as [[GridRowModel]].
+ * @param {string} detailErrorMessage A custom error message to display for invalid IDs
+ */
+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 getRowValue: (row: GridValidRowModel, colDef: GridColDef, apiRef: RefObject<GridApiCommunity>) => any;
+export declare const createRowsInternalCache: ({
+  rows,
+  getRowId,
+  loading,
+  rowCount
+}: Pick<DataGridProcessedProps, "rows" | "getRowId" | "loading" | "rowCount">) => GridRowsInternalCache;
+export declare const getTopLevelRowCount: ({
+  tree,
+  rowCountProp
+}: {
+  tree: GridRowTreeConfig;
+  rowCountProp: DataGridProcessedProps["rowCount"];
+}) => number;
+export declare const getRowsStateFromCache: ({
+  apiRef,
+  rowCountProp,
+  loadingProp,
+  previousTree,
+  previousTreeDepths,
+  previousGroupsToFetch
+}: Pick<GridRowTreeCreationParams, "previousTree" | "previousTreeDepths" | "previousGroupsToFetch"> & {
+  apiRef: RefObject<GridPrivateApiCommunity>;
+  rowCountProp: number | undefined;
+  loadingProp: boolean | undefined;
+}) => GridRowsState;
+export declare const isAutogeneratedRow: (row: GridRowModel) => boolean;
+export declare const isAutogeneratedRowNode: (rowNode: GridTreeNode) => rowNode is GridFooterNode | GridSkeletonRowNode | GridAutoGeneratedGroupNode | GridAutoGeneratedPinnedRowNode;
+export declare const getTreeNodeDescendants: (tree: GridRowTreeConfig, parentId: GridRowId, skipAutoGeneratedRows: boolean) => GridRowId[];
+export declare const updateCacheWithNewRows: ({
+  previousCache,
+  getRowId,
+  updates,
+  groupKeys
+}: {
+  previousCache: GridRowsInternalCache;
+  getRowId: DataGridProcessedProps["getRowId"];
+  updates: GridRowModelUpdate[];
+  groupKeys?: string[];
+}) => GridRowsInternalCache;
+export declare const minimalContentHeight = "var(--DataGrid-overlayHeight, calc(var(--height) * 2))";
+export declare function computeRowsUpdates(apiRef: RefObject<GridApiCommunity>, updates: GridRowModelUpdate[], getRowId: DataGridProcessedProps['getRowId']): GridRowModelUpdate[];
+export declare const getValidRowHeight: (rowHeightProp: any, defaultRowHeight: number, warningMessage: string) => number;
+export declare const rowHeightWarning: string;
+export declare const getRowHeightWarning: string;