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

package/modern/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -10,7 +10,7 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
   // that the pre-processor is called it will already have been updated with the current rules.
   const rulesOnLastColumnHydration = React.useRef({});
   const updateAggregatedColumns = React.useCallback(columnsState => {
-    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(columnsState.lookup, gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(columnsState.lookup, gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.dataSource);
     columnsState.orderedFields.forEach(field => {
       const shouldHaveAggregationValue = !!aggregationRules[field];
       const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
@@ -32,9 +32,9 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
     rulesOnLastColumnHydration.current = aggregationRules;
     apiRef.current.caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
     return columnsState;
-  }, [apiRef, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [apiRef, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   const addGroupFooterRows = React.useCallback(value => {
-    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.dataSource);
     const hasAggregationRule = Object.keys(aggregationRules).length > 0;
 
     // If we did not have any aggregation footer before, and we still don't have any,
@@ -49,7 +49,7 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
       getAggregationPosition: props.getAggregationPosition,
       hasAggregationRule
     });
-  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions, props.unstable_dataSource]);
+  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions, props.dataSource]);
   const addColumnMenuButtons = React.useCallback((columnMenuItems, colDef) => {
     if (props.disableAggregation || !colDef.aggregable) {
       return columnMenuItems;
@@ -57,13 +57,13 @@ export const useGridAggregationPreProcessors = (apiRef, props) => {
     const availableAggregationFunctions = getAvailableAggregationFunctions({
       aggregationFunctions: props.aggregationFunctions,
       colDef,
-      isDataSource: !!props.unstable_dataSource
+      isDataSource: !!props.dataSource
     });
     if (availableAggregationFunctions.length === 0) {
       return columnMenuItems;
     }
     return [...columnMenuItems, 'columnMenuAggregationItem'];
-  }, [props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   const stateExportPreProcessing = React.useCallback(prevState => {
     if (props.disableAggregation) {
       return prevState;

package/modern/hooks/features/aggregation/wrapColumnWithAggregation.d.ts

@@ -0,0 +1,81 @@
+import * as React from 'react';
+import { RefObject } from '@mui/x-internals/types';
+import { GridColDef, GridFilterOperator } from '@mui/x-data-grid-pro';
+import { type GridBaseColDef } from '@mui/x-data-grid-pro/internals';
+import { GridApiPremium } from "../../../models/gridApiPremium.js";
+import type { GridAggregationRule } from './gridAggregationInterfaces';
+type WrappableColumnProperty = 'valueGetter' | 'valueFormatter' | 'renderCell' | 'renderHeader' | 'filterOperators';
+interface GridColDefWithAggregationWrappers extends GridBaseColDef {
+  aggregationWrappedProperties: {
+    name: WrappableColumnProperty;
+    originalValue: GridBaseColDef[WrappableColumnProperty];
+    wrappedValue: GridBaseColDef[WrappableColumnProperty];
+  }[];
+}
+/**
+ * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
+ */
+export declare const wrapColumnWithAggregationValue: ({
+  column,
+  apiRef,
+  aggregationRule
+}: {
+  column: GridBaseColDef;
+  apiRef: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
+}) => GridBaseColDef;
+/**
+ * Remove the aggregation wrappers around the wrappable properties of the column.
+ */
+export declare const unwrapColumnFromAggregation: ({
+  column
+}: {
+  column: GridColDef | GridColDefWithAggregationWrappers;
+}) => GridBaseColDef<any, any, any> | {
+  field: string;
+  headerName?: string;
+  description?: string;
+  width?: number;
+  flex?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  hideable?: boolean;
+  sortable?: boolean;
+  sortingOrder?: readonly import("@mui/x-data-grid").GridSortDirection[];
+  resizable?: boolean;
+  editable?: boolean;
+  groupable?: boolean;
+  pinnable?: boolean;
+  sortComparator?: import("@mui/x-data-grid").GridComparatorFn<any> | undefined;
+  getSortComparator?: ((sortDirection: import("@mui/x-data-grid").GridSortDirection) => import("@mui/x-data-grid").GridComparatorFn<any> | undefined) | undefined;
+  type?: import("@mui/x-data-grid").GridColType;
+  align?: import("@mui/x-data-grid").GridAlignment;
+  valueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  rowSpanValueGetter?: import("@mui/x-data-grid").GridValueGetter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  valueSetter?: import("@mui/x-data-grid").GridValueSetter<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  valueFormatter?: import("@mui/x-data-grid").GridValueFormatter<import("@mui/x-data-grid").GridValidRowModel, any, any, never> | undefined;
+  valueParser?: import("@mui/x-data-grid").GridValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  cellClassName?: import("@mui/x-data-grid").GridCellClassNamePropType<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
+  display?: "text" | "flex";
+  renderCell?: ((params: import("@mui/x-data-grid").GridRenderCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
+  renderEditCell?: ((params: import("@mui/x-data-grid").GridRenderEditCellParams<import("@mui/x-data-grid").GridValidRowModel, any, any, import("@mui/x-data-grid").GridTreeNodeWithRender>) => React.ReactNode) | undefined;
+  preProcessEditCellProps?: ((params: import("@mui/x-data-grid").GridPreProcessEditCellProps) => import("@mui/x-data-grid").GridEditCellProps | Promise<import("@mui/x-data-grid").GridEditCellProps>) | undefined;
+  headerClassName?: import("@mui/x-data-grid").GridColumnHeaderClassNamePropType;
+  renderHeader?: ((params: import("@mui/x-data-grid").GridColumnHeaderParams<import("@mui/x-data-grid").GridValidRowModel, any, any>) => React.ReactNode) | undefined;
+  headerAlign?: import("@mui/x-data-grid").GridAlignment;
+  hideSortIcons?: boolean;
+  disableColumnMenu?: boolean;
+  filterable?: boolean;
+  filterOperators?: readonly GridFilterOperator<import("@mui/x-data-grid").GridValidRowModel, any, any, any>[] | undefined;
+  getApplyQuickFilterFn?: import("@mui/x-data-grid").GetApplyQuickFilterFn<import("@mui/x-data-grid").GridValidRowModel, any> | undefined;
+  disableReorder?: boolean;
+  disableExport?: boolean;
+  colSpan?: number | import("@mui/x-data-grid").GridColSpanFn<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+  unstable_examples?: any[] | undefined;
+  renderHeaderFilter?: (params: import("@mui/x-data-grid-pro").GridRenderHeaderFilterProps) => React.ReactNode;
+  aggregable?: boolean;
+  availableAggregationFunctions?: string[];
+  groupingValueGetter?: import("../../..").GridGroupingValueGetter<import("@mui/x-data-grid").GridValidRowModel> | undefined;
+  pastedValueParser?: import("../../..").GridPastedValueParser<import("@mui/x-data-grid").GridValidRowModel, any, any> | undefined;
+};
+export {};

package/modern/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -2,17 +2,17 @@ import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWith
 import _extends from "@babel/runtime/helpers/esm/extends";
 const _excluded = ["aggregationWrappedProperties"];
 import * as React from 'react';
+import { gridRowIdSelector, gridRowNodeSelector } from '@mui/x-data-grid-pro';
 import { gridAggregationLookupSelector } from "./gridAggregationSelectors.js";
 import { GridFooterCell } from "../../../components/GridFooterCell.js";
 import { GridAggregationHeader } from "../../../components/GridAggregationHeader.js";
 import { jsx as _jsx } from "react/jsx-runtime";
-const AGGREGATION_WRAPPABLE_PROPERTIES = ['valueGetter', 'valueFormatter', 'renderCell', 'renderHeader', 'filterOperators'];
 const getAggregationValueWrappedValueGetter = ({
   value: valueGetter,
   getCellAggregationResult
 }) => {
   const wrappedValueGetter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId?.(row);
+    const rowId = gridRowIdSelector(apiRef, row);
     const cellAggregationResult = rowId ? getCellAggregationResult(rowId, column.field) : null;
     if (cellAggregationResult != null) {
       return cellAggregationResult?.value ?? null;
@@ -35,7 +35,7 @@ const getAggregationValueWrappedValueFormatter = ({
     return valueFormatter;
   }
   const wrappedValueFormatter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId(row);
+    const rowId = gridRowIdSelector(apiRef, row);
     if (rowId != null) {
       const cellAggregationResult = getCellAggregationResult(rowId, column.field);
       if (cellAggregationResult != null) {
@@ -94,7 +94,8 @@ const getWrappedFilterOperators = ({
       return null;
     }
     return (value, row, column, api) => {
-      if (getCellAggregationResult(apiRef.current.getRowId(row), column.field) != null) {
+      const rowId = gridRowIdSelector(apiRef, row);
+      if (getCellAggregationResult(rowId, column.field) != null) {
         return true;
       }
       return filterFn(value, row, column, api);
@@ -133,7 +134,7 @@ export const wrapColumnWithAggregationValue = ({
 }) => {
   const getCellAggregationResult = (id, field) => {
     let cellAggregationPosition = null;
-    const rowNode = apiRef.current.getRowNode(id);
+    const rowNode = gridRowNodeSelector(apiRef, id);
     if (rowNode.type === 'group') {
       cellAggregationPosition = 'inline';
     } else if (id.toString().startsWith('auto-generated-group-footer-')) {

package/modern/hooks/features/cellSelection/gridCellSelectionInterfaces.d.ts

@@ -0,0 +1,40 @@
+import { GridCellCoordinates, GridColDef, GridRowId } from '@mui/x-data-grid-pro';
+export type GridCellSelectionModel = Record<GridRowId, Record<GridColDef['field'], boolean>>;
+/**
+ * The cell selection API interface that is available in the grid [[apiRef]].
+ */
+export interface GridCellSelectionApi {
+  /**
+   * Determines if a cell is selected or not.
+   * @param {GridRowId} id The id of the row.
+   * @param {GridColDef['field']} field The field.
+   * @returns {boolean} A boolean indicating if the cell is selected.
+   */
+  isCellSelected: (id: GridRowId, field: GridColDef['field']) => boolean;
+  /**
+   * Returns an object containing the selection state of the cells.
+   * The keys of the object correspond to the row IDs.
+   * The value of each key is also an object, which has a column field for a key and a boolean value for its selection state.
+   * @returns {GridCellSelectionModel} Object containing the selection state of the cells
+   */
+  getCellSelectionModel: () => GridCellSelectionModel;
+  /**
+   * Updates the cell selection model according to the value passed to the `newModel` argument.
+   * Any cell already selected will be unselected.
+   * @param {GridCellSelectionModel} newModel The cells to select.
+   */
+  setCellSelectionModel: (newModel: GridCellSelectionModel) => void;
+  /**
+   * Selects all cells that are inside the range given by `start` and `end` coordinates.
+   * @param {GridCellCoordinates} start Object containing the row ID and field of the first cell to select.
+   * @param {GridCellCoordinates} end Object containing the row ID and field of the last cell to select.
+   * @param {boolean} keepOtherSelected Whether to keep current selected cells or discard. Default is false.
+   */
+  selectCellRange: (start: GridCellCoordinates, end: GridCellCoordinates, keepOtherSelected?: boolean) => void;
+  /**
+   * Returns an array containing only the selected cells.
+   * Each item is an object with the ID and field of the cell.
+   * @returns {GridCellCoordinates[]} Array with the selected cells.
+   */
+  getSelectedCellsAsArray: () => GridCellCoordinates[];
+}

package/modern/hooks/features/cellSelection/gridCellSelectionSelector.d.ts

@@ -0,0 +1,2 @@
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+export declare const gridCellSelectionStateSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, unknown, import("./gridCellSelectionInterfaces").GridCellSelectionModel>;

package/modern/hooks/features/cellSelection/gridCellSelectionSelector.js

@@ -1 +1,2 @@
-export const gridCellSelectionStateSelector = state => state.cellSelection;
+import { createRootSelector } from '@mui/x-data-grid-pro/internals';
+export const gridCellSelectionStateSelector = createRootSelector(state => state.cellSelection);

package/modern/hooks/features/cellSelection/index.d.ts

@@ -0,0 +1 @@
+export * from "./gridCellSelectionInterfaces.js";

package/modern/hooks/features/cellSelection/useGridCellSelection.d.ts

@@ -0,0 +1,6 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+export declare const cellSelectionStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'cellSelectionModel' | 'initialState'>>;
+export declare const useGridCellSelection: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "cellSelection" | "cellSelectionModel" | "onCellSelectionModelChange" | "pagination" | "paginationMode" | "ignoreValueFormatterDuringExport" | "clipboardCopyCellDelimiter" | "columnHeaderHeight">) => void;

package/modern/hooks/features/cellSelection/useGridCellSelection.js

@@ -40,11 +40,11 @@ export const useGridCellSelection = (apiRef, props) => {
     if (!props.cellSelection) {
       return false;
     }
-    const cellSelectionModel = gridCellSelectionStateSelector(apiRef.current.state);
+    const cellSelectionModel = gridCellSelectionStateSelector(apiRef);
     return cellSelectionModel[id] ? !!cellSelectionModel[id][field] : false;
   }, [apiRef, props.cellSelection]);
   const getCellSelectionModel = React.useCallback(() => {
-    return gridCellSelectionStateSelector(apiRef.current.state);
+    return gridCellSelectionStateSelector(apiRef);
   }, [apiRef]);
   const setCellSelectionModel = React.useCallback(newModel => {
     if (!props.cellSelection) {
@@ -53,7 +53,6 @@ export const useGridCellSelection = (apiRef, props) => {
     apiRef.current.setState(prevState => _extends({}, prevState, {
       cellSelection: newModel
     }));
-    apiRef.current.forceUpdate();
   }, [apiRef, props.cellSelection]);
   const selectCellRange = React.useCallback((start, end, keepOtherSelected = false) => {
     const startRowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(start.id);
@@ -184,7 +183,7 @@ export const useGridCellSelection = (apiRef, props) => {
       if (!mousePosition.current || !apiRef.current.virtualScrollerRef?.current) {
         return;
       }
-      const dimensions = gridDimensionsSelector(apiRef.current.state);
+      const dimensions = gridDimensionsSelector(apiRef);
       const {
         x: mouseX,
         y: mouseY
@@ -244,7 +243,7 @@ export const useGridCellSelection = (apiRef, props) => {
     if (!virtualScrollerRect) {
       return;
     }
-    const dimensions = gridDimensionsSelector(apiRef.current.state);
+    const dimensions = gridDimensionsSelector(apiRef);
     const {
       x,
       y
@@ -453,7 +452,7 @@ export const useGridCellSelection = (apiRef, props) => {
     if (apiRef.current.getSelectedCellsAsArray().length <= 1) {
       return value;
     }
-    const sortedRowIds = gridSortedRowIdsSelector(apiRef.current.state);
+    const sortedRowIds = gridSortedRowIdsSelector(apiRef);
     const cellSelectionModel = apiRef.current.getCellSelectionModel();
     const unsortedSelectedRowIds = Object.keys(cellSelectionModel);
     const sortedSelectedRowIds = sortedRowIds.filter(id => unsortedSelectedRowIds.includes(`${id}`));

package/modern/hooks/features/clipboard/useGridClipboardImport.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import type { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
+export declare const useGridClipboardImport: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "pagination" | "paginationMode" | "processRowUpdate" | "onProcessRowUpdateError" | "getRowId" | "onClipboardPasteStart" | "onClipboardPasteEnd" | "splitClipboardPastedText" | "disableClipboardPaste" | "onBeforeClipboardPasteStart">) => void;

package/modern/hooks/features/clipboard/useGridClipboardImport.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
-import { GRID_CHECKBOX_SELECTION_FIELD, gridFocusCellSelector, gridVisibleColumnFieldsSelector, useGridApiOptionHandler, useGridApiEventHandler, gridPaginatedVisibleSortedGridRowIdsSelector, gridExpandedSortedRowIdsSelector } from '@mui/x-data-grid';
+import { GRID_CHECKBOX_SELECTION_FIELD, gridFocusCellSelector, gridVisibleColumnFieldsSelector, useGridApiOptionHandler, useGridApiEventHandler, gridPaginatedVisibleSortedGridRowIdsSelector, gridExpandedSortedRowIdsSelector, gridRowSelectionIdsSelector, gridRowSelectionCountSelector } from '@mui/x-data-grid';
 import { getRowIdFromRowModel, getActiveElement, useGridRegisterPipeProcessor, getPublicApiRef, isPasteShortcut, useGridLogger } from '@mui/x-data-grid/internals';
 import { warnOnce } from '@mui/x-internals/warning';
 import { GRID_DETAIL_PANEL_TOGGLE_FIELD, GRID_REORDER_COL_DEF } from '@mui/x-data-grid-pro';
@@ -193,10 +193,10 @@ function defaultPasteResolver({
     }
     return true;
   });
-  const selectedRows = apiRef.current.getSelectedRows();
-  if (selectedRows.size > 0 && !isSingleValuePasted) {
+  if (gridRowSelectionCountSelector(apiRef) > 0 && !isSingleValuePasted) {
     // Multiple values are pasted starting from the first and top-most cell
     const pastedRowsDataCount = pastedData.length;
+    const selectedRows = gridRowSelectionIdsSelector(apiRef);
 
     // There's no guarantee that the selected rows are in the same order as the pasted rows
     selectedRows.forEach((row, rowId) => {
@@ -255,7 +255,6 @@ export const useGridClipboardImport = (apiRef, props) => {
   const onProcessRowUpdateError = props.onProcessRowUpdateError;
   const getRowId = props.getRowId;
   const enableClipboardPaste = !props.disableClipboardPaste;
-  const rootEl = apiRef.current.rootElementRef?.current;
   const logger = useGridLogger(apiRef, 'useGridClipboardImport');
   const splitClipboardPastedText = props.splitClipboardPastedText;
   const {
@@ -278,6 +277,7 @@ export const useGridClipboardImport = (apiRef, props) => {
         return;
       }
     }
+    const rootEl = apiRef.current.rootElementRef?.current;
     if (!rootEl) {
       return;
     }
@@ -318,7 +318,7 @@ export const useGridClipboardImport = (apiRef, props) => {
       paginationMode
     });
     cellUpdater.applyUpdates();
-  }, [apiRef, processRowUpdate, onProcessRowUpdateError, getRowId, enableClipboardPaste, rootEl, splitClipboardPastedText, pagination, paginationMode, onBeforeClipboardPasteStart, logger]);
+  }, [apiRef, processRowUpdate, onProcessRowUpdateError, getRowId, enableClipboardPaste, splitClipboardPastedText, pagination, paginationMode, onBeforeClipboardPasteStart, logger]);
   const checkIfCanStartEditing = React.useCallback((initialValue, {
     event
   }) => {

package/modern/hooks/features/dataSource/models.d.ts

@@ -0,0 +1,54 @@
+import type { GridColDef, GridRowId, GridValidRowModel, GridDataSource, GridGetRowsResponse, GridGetRowsParams, GridDataSourceApiBase, GridDataSourcePrivateApi } from '@mui/x-data-grid-pro';
+import type { GridAggregationModel } from '../aggregation/gridAggregationInterfaces';
+export interface GridGetRowsResponsePremium extends GridGetRowsResponse {
+  /**
+   * Row to be used for aggregation footer row.
+   * It must provide the values for the aggregated columns passed in
+   * `GridGetRowsParams.aggregationModel`.
+   */
+  aggregateRow?: GridValidRowModel;
+}
+export interface GridGetRowsParamsPremium extends GridGetRowsParams {
+  /**
+   * List of aggregated columns.
+   */
+  aggregationModel?: GridAggregationModel;
+  /**
+   * List of grouped columns (only applicable with `rowGrouping`).
+   */
+  groupFields?: GridColDef['field'][];
+}
+export interface GridDataSourcePremium extends Omit<GridDataSource, 'getRows'> {
+  /**
+   * This method will be called when the grid needs to fetch some rows.
+   * @param {GridGetRowsParamsPremium} params The parameters required to fetch the rows.
+   * @returns {Promise<GridGetRowsResponsePremium>} A promise that resolves to the data of type [GridGetRowsResponsePremium].
+   */
+  getRows(params: GridGetRowsParamsPremium): Promise<GridGetRowsResponsePremium>;
+  /**
+   * Used to get the aggregated value for a parent row.
+   * @param {GridValidRowModel} row The row to extract the aggregated value from.
+   * @param {GridColDef['field']} field The field to extract the aggregated value for.
+   * @returns {string} The aggregated value for a specific aggregated column.
+   */
+  getAggregatedValue?: (row: GridValidRowModel, field: GridColDef['field']) => string;
+}
+export interface GridDataSourceApiBasePremium extends Omit<GridDataSourceApiBase, 'fetchRows'> {
+  /**
+   * Fetches the rows from the server.
+   * If no `parentId` option is provided, it fetches the root rows.
+   * Any missing parameter from `params` will be filled from the state (sorting, filtering, etc.).
+   * @param {GridRowId} parentId The id of the parent node (default: `GRID_ROOT_GROUP_ID`).
+   * @param {Partial<GridGetRowsParamsPremium>} params Request parameters override.
+   */
+  fetchRows: (parentId?: GridRowId, params?: Partial<GridGetRowsParamsPremium>) => void;
+}
+export interface GridDataSourceApiPremium {
+  /**
+   * The data source API.
+   */
+  dataSource: GridDataSourceApiBasePremium;
+}
+export interface GridDataSourcePremiumPrivateApi extends GridDataSourcePrivateApi {
+  resolveGroupAggregation: (groupId: GridRowId, field: string) => any;
+}

package/modern/hooks/features/dataSource/useGridDataSourcePremium.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+export declare const useGridDataSourcePremium: (apiRef: RefObject<GridPrivateApiPremium>, props: DataGridPremiumProcessedProps) => void;

package/modern/hooks/features/dataSource/useGridDataSourcePremium.js

@@ -1,8 +1,10 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useGridApiEventHandler as addEventHandler, useGridApiMethod, GRID_ROOT_GROUP_ID } from '@mui/x-data-grid-pro';
-import { useGridDataSourceBase, useGridRegisterStrategyProcessor, useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
-import { getKeyPremium } from "./cache.js";
+import { useGridDataSourceBasePro, useGridRegisterStrategyProcessor, useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
+function getKeyPremium(params) {
+  return JSON.stringify([params.filterModel, params.sortModel, params.groupKeys, params.groupFields, params.start, params.end, params.aggregationModel]);
+}
 const options = {
   cacheOptions: {
     getKey: getKeyPremium
@@ -12,8 +14,9 @@ export const useGridDataSourcePremium = (apiRef, props) => {
   const {
     api,
     strategyProcessor,
-    events
-  } = useGridDataSourceBase(apiRef, props, options);
+    events,
+    setStrategyAvailability
+  } = useGridDataSourceBasePro(apiRef, props, options);
   const aggregateRowRef = React.useRef({});
   const processDataSourceRows = React.useCallback(({
     params,
@@ -35,11 +38,11 @@ export const useGridDataSourcePremium = (apiRef, props) => {
   }, [apiRef]);
   const resolveGroupAggregation = React.useCallback((groupId, field) => {
     if (groupId === GRID_ROOT_GROUP_ID) {
-      return props.unstable_dataSource?.getAggregatedValue?.(aggregateRowRef.current, field);
+      return props.dataSource?.getAggregatedValue?.(aggregateRowRef.current, field);
     }
     const row = apiRef.current.getRow(groupId);
-    return props.unstable_dataSource?.getAggregatedValue?.(row, field);
-  }, [apiRef, props.unstable_dataSource]);
+    return props.dataSource?.getAggregatedValue?.(row, field);
+  }, [apiRef, props.dataSource]);
   const privateApi = _extends({}, api.private, {
     resolveGroupAggregation
   });
@@ -50,4 +53,7 @@ export const useGridDataSourcePremium = (apiRef, props) => {
   Object.entries(events).forEach(([event, handler]) => {
     addEventHandler(apiRef, event, handler);
   });
+  React.useEffect(() => {
+    setStrategyAvailability();
+  }, [setStrategyAvailability]);
 };

package/modern/hooks/features/export/gridExcelExportInterface.d.ts

@@ -0,0 +1,71 @@
+import type * as Excel from 'exceljs';
+import { GridFileExportOptions, GridExportFormat as GridExportFormatCommunity, GridExportExtension as GridExportExtensionCommunity } from '@mui/x-data-grid-pro';
+export type GridExportFormat = GridExportFormatCommunity | 'excel';
+export type GridExportExtension = GridExportExtensionCommunity | 'xlsx';
+export interface GridExceljsProcessInput {
+  workbook: Excel.Workbook;
+  worksheet: Excel.Worksheet;
+}
+export interface ColumnsStylesInterface {
+  [field: string]: Partial<Excel.Style>;
+}
+/**
+ * The options to apply on the Excel export.
+ * @demos
+ *   - [Excel export](/x/react-data-grid/export/#excel-export)
+ */
+export interface GridExcelExportOptions extends GridFileExportOptions {
+  /**
+   * Function to return the Worker instance to be called.
+   * @returns {() => Worker} A Worker instance.
+   */
+  worker?: () => Worker;
+  /**
+   * Name given to the worksheet containing the columns valueOptions.
+   * valueOptions are added to this worksheet if they are provided as an array.
+   */
+  valueOptionsSheetName?: string;
+  /**
+   * Method called before adding the rows to the workbook.
+   * Not supported when `worker` is set.
+   * To use with web workers, use the option in `setupExcelExportWebWorker`.
+   * @param {GridExceljsProcessInput} processInput object containing the workbook and the worksheet.
+   * @returns {Promise<void>} A promise which resolves after processing the input.
+   * */
+  exceljsPreProcess?: (processInput: GridExceljsProcessInput) => Promise<void>;
+  /**
+   * Method called after adding the rows to the workbook.
+   * Not supported when `worker` is set.
+   * To use with web workers, use the option in `setupExcelExportWebWorker`.
+   * @param {GridExceljsProcessInput} processInput object containing the workbook and the worksheet.
+   * @returns {Promise<void>} A promise which resolves after processing the input.
+   * */
+  exceljsPostProcess?: (processInput: GridExceljsProcessInput) => Promise<void>;
+  /**
+   * Object mapping column field to Exceljs style
+   * */
+  columnsStyles?: ColumnsStylesInterface;
+  /**
+   * If `true`, the headers of the column groups will be added into the file.
+   * @default true
+   */
+  includeColumnGroupsHeaders?: boolean;
+}
+/**
+ * The excel export API interface that is available in the grid [[apiRef]].
+ */
+export interface GridExcelExportApi {
+  /**
+   * Returns the grid data as an exceljs workbook.
+   * This method is used internally by `exportDataAsExcel`.
+   * @param {GridExcelExportOptions} options The options to apply on the export.
+   * @returns {Promise<Excel.Workbook>} The data in a exceljs workbook object.
+   */
+  getDataAsExcel: (options?: GridExcelExportOptions) => Promise<Excel.Workbook> | null;
+  /**
+   * Downloads and exports an Excel file of the grid's data.
+   * @param {GridExcelExportOptions} options The options to apply on the export.
+   * @returns {Promise<void>} A promise which resolves after exporting to Excel.
+   */
+  exportDataAsExcel: (options?: GridExcelExportOptions) => Promise<void>;
+}

package/modern/hooks/features/export/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./gridExcelExportInterface.js";
+export { setupExcelExportWebWorker } from "./serializer/setupExcelExportWebWorker.js";

package/modern/hooks/features/export/index.js

@@ -1,2 +1,2 @@
 export * from "./gridExcelExportInterface.js";
-export { setupExcelExportWebWorker } from "./serializer/excelSerializer.js";
+export { setupExcelExportWebWorker } from "./serializer/setupExcelExportWebWorker.js";

package/modern/hooks/features/export/serializer/excelSerializer.d.ts

@@ -0,0 +1,40 @@
+import type * as Excel from 'exceljs';
+import { RefObject } from '@mui/x-internals/types';
+import { GridRowId, GridColDef } from '@mui/x-data-grid-pro';
+import { GridStateColDef } from '@mui/x-data-grid/internals';
+import { ColumnsStylesInterface, GridExcelExportOptions } from "../gridExcelExportInterface.js";
+import { GridPrivateApiPremium } from "../../../../models/gridApiPremium.js";
+import { SerializedColumns, SerializedRow, ValueOptionsData } from "./utils.js";
+export type { ExcelExportInitEvent } from './utils';
+/**
+ * FIXME: This function mutates the colspan info, but colspan info assumes that the columns
+ * passed to it are always consistent. In this case, the exported columns may differ from the
+ * actual rendered columns.
+ * The caller of this function MUST call `resetColSpan()` before and after usage.
+ */
+export declare const serializeRowUnsafe: (id: GridRowId, columns: GridStateColDef[], apiRef: RefObject<GridPrivateApiPremium>, defaultValueOptionsFormulae: {
+  [field: string]: {
+    address: string;
+  };
+}, options: Pick<BuildExcelOptions, "escapeFormulas">) => SerializedRow;
+export declare const serializeColumn: (column: GridColDef, columnsStyles: ColumnsStylesInterface) => {
+  key: string;
+  headerText: string;
+  width: number;
+  style: {
+    numFmt?: string | undefined;
+    font?: Partial<Excel.Font> | undefined;
+    alignment?: Partial<Excel.Alignment> | undefined;
+    protection?: Partial<Excel.Protection> | undefined;
+    border?: Partial<Excel.Borders> | undefined;
+    fill?: Excel.Fill | undefined;
+  };
+};
+export declare function serializeColumns(columns: GridStateColDef[], styles: ColumnsStylesInterface): SerializedColumns;
+export declare function getDataForValueOptionsSheet(columns: GridStateColDef[], valueOptionsSheetName: string, api: GridPrivateApiPremium): Promise<ValueOptionsData>;
+interface BuildExcelOptions extends Pick<GridExcelExportOptions, 'exceljsPreProcess' | 'exceljsPostProcess'>, Pick<Required<GridExcelExportOptions>, 'valueOptionsSheetName' | 'includeHeaders' | 'includeColumnGroupsHeaders' | 'escapeFormulas'> {
+  columns: GridStateColDef[];
+  rowIds: GridRowId[];
+  columnsStyles?: ColumnsStylesInterface;
+}
+export declare function buildExcel(options: BuildExcelOptions, apiRef: RefObject<GridPrivateApiPremium>): Promise<Excel.Workbook>;