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

package/hooks/features/aggregation/gridAggregationUtils.d.ts

@@ -1,45 +1,62 @@
 import { RefObject } from '@mui/x-internals/types';
 import { GridColDef, GridRowId } from '@mui/x-data-grid-pro';
 import { GridColumnRawLookup, GridHydrateRowsValue } from '@mui/x-data-grid-pro/internals';
-import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationModel, GridAggregationRule, GridAggregationRules } from './gridAggregationInterfaces';
-import { GridStatePremium } from '../../../models/gridStatePremium';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-import { GridApiPremium, GridPrivateApiPremium } from '../../../models/gridApiPremium';
+import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationModel, GridAggregationRule, GridAggregationRules } from "./gridAggregationInterfaces.js";
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridApiPremium, GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = "auto-generated-group-footer-root";
 export declare const getAggregationFooterRowIdFromGroupId: (groupId: GridRowId | null) => string;
 type AggregationFunction = GridAggregationFunction | GridAggregationFunctionDataSource | undefined;
-export declare const canColumnHaveAggregationFunction: ({ colDef, aggregationFunctionName, aggregationFunction, isDataSource, }: {
-    colDef: GridColDef | undefined;
-    aggregationFunctionName: string;
-    aggregationFunction: AggregationFunction;
-    isDataSource: boolean;
+export declare const canColumnHaveAggregationFunction: ({
+  colDef,
+  aggregationFunctionName,
+  aggregationFunction,
+  isDataSource
+}: {
+  colDef: GridColDef | undefined;
+  aggregationFunctionName: string;
+  aggregationFunction: AggregationFunction;
+  isDataSource: boolean;
 }) => boolean;
-export declare const getAvailableAggregationFunctions: ({ aggregationFunctions, colDef, isDataSource, }: {
-    aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
-    colDef: GridColDef;
-    isDataSource: boolean;
+export declare const getAvailableAggregationFunctions: ({
+  aggregationFunctions,
+  colDef,
+  isDataSource
+}: {
+  aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
+  colDef: GridColDef;
+  isDataSource: boolean;
 }) => string[];
 export declare const mergeStateWithAggregationModel: (aggregationModel: GridAggregationModel) => (state: GridStatePremium) => GridStatePremium;
 export declare const getAggregationRules: (columnsLookup: GridColumnRawLookup, aggregationModel: GridAggregationModel, aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>, isDataSource: boolean) => GridAggregationRules;
 interface AddFooterRowsParams {
-    groupingParams: GridHydrateRowsValue;
-    getAggregationPosition: DataGridPremiumProcessedProps['getAggregationPosition'];
-    /**
-     * If `true`, there are some aggregation rules to apply
-     */
-    hasAggregationRule: boolean;
-    apiRef: RefObject<GridPrivateApiPremium>;
+  groupingParams: GridHydrateRowsValue;
+  getAggregationPosition: DataGridPremiumProcessedProps['getAggregationPosition'];
+  /**
+   * If `true`, there are some aggregation rules to apply
+   */
+  hasAggregationRule: boolean;
+  apiRef: RefObject<GridPrivateApiPremium>;
 }
 /**
  * Add a footer for each group that has at least one column with an aggregated value.
  */
-export declare const addFooterRows: ({ groupingParams, apiRef, getAggregationPosition, hasAggregationRule, }: AddFooterRowsParams) => GridHydrateRowsValue;
+export declare const addFooterRows: ({
+  groupingParams,
+  apiRef,
+  getAggregationPosition,
+  hasAggregationRule
+}: AddFooterRowsParams) => GridHydrateRowsValue;
 /**
  * Compares two sets of aggregation rules to determine if they are equal or not.
  */
 export declare const areAggregationRulesEqual: (previousValue: GridAggregationRules | undefined, newValue: GridAggregationRules) => boolean;
-export declare const getAggregationFunctionLabel: ({ apiRef, aggregationRule, }: {
-    apiRef: RefObject<GridApiPremium>;
-    aggregationRule: GridAggregationRule;
+export declare const getAggregationFunctionLabel: ({
+  apiRef,
+  aggregationRule
+}: {
+  apiRef: RefObject<GridApiPremium>;
+  aggregationRule: GridAggregationRule;
 }) => string;
-export {};
+export {};

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

@@ -1,4 +1,4 @@
-export type { GridAggregationState, GridAggregationInitialState, GridAggregationInternalCache, GridAggregationApi, GridAggregationGetCellValueParams, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationParams, GridAggregationModel, GridAggregationLookup, GridAggregationPosition, GridAggregationCellMeta, GridAggregationHeaderMeta, GridAggregationRule, GridAggregationRules, } from './gridAggregationInterfaces';
-export * from './gridAggregationSelectors';
-export * from './gridAggregationFunctions';
-export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId, } from './gridAggregationUtils';
+export type { GridAggregationState, GridAggregationInitialState, GridAggregationInternalCache, GridAggregationApi, GridAggregationGetCellValueParams, GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationParams, GridAggregationModel, GridAggregationLookup, GridAggregationPosition, GridAggregationCellMeta, GridAggregationHeaderMeta, GridAggregationRule, GridAggregationRules } from './gridAggregationInterfaces';
+export * from "./gridAggregationSelectors.js";
+export * from "./gridAggregationFunctions.js";
+export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId } from "./gridAggregationUtils.js";

package/hooks/features/aggregation/useGridAggregation.d.ts

@@ -1,6 +1,6 @@
 import { RefObject } from '@mui/x-internals/types';
 import { GridStateInitializer } from '@mui/x-data-grid-pro/internals';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-import { GridPrivateApiPremium } from '../../../models/gridApiPremium';
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
 export declare const aggregationStateInitializer: GridStateInitializer<Pick<DataGridPremiumProcessedProps, 'aggregationModel' | 'initialState'>, GridPrivateApiPremium>;
-export declare const useGridAggregation: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "onAggregationModelChange" | "initialState" | "aggregationModel" | "getAggregationPosition" | "aggregationFunctions" | "aggregationRowsScope" | "disableAggregation" | "rowGroupingColumnMode" | "unstable_dataSource">) => void;
+export declare const useGridAggregation: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "onAggregationModelChange" | "initialState" | "aggregationModel" | "getAggregationPosition" | "aggregationFunctions" | "aggregationRowsScope" | "disableAggregation" | "rowGroupingColumnMode" | "dataSource">) => void;

package/hooks/features/aggregation/useGridAggregation.js

@@ -49,14 +49,14 @@ const useGridAggregation = (apiRef, props) => {
       getAggregationPosition: props.getAggregationPosition,
       aggregationFunctions: props.aggregationFunctions,
       aggregationRowsScope: props.aggregationRowsScope,
-      isDataSource: !!props.unstable_dataSource
+      isDataSource: !!props.dataSource
     });
     apiRef.current.setState(state => (0, _extends2.default)({}, state, {
       aggregation: (0, _extends2.default)({}, state.aggregation, {
         lookup: aggregationLookup
       })
     }));
-  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope, props.unstable_dataSource]);
+  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope, props.dataSource]);
   const aggregationApi = {
     setAggregationModel
   };
@@ -80,12 +80,12 @@ const useGridAggregation = (apiRef, props) => {
       rulesOnLastRowHydration,
       rulesOnLastColumnHydration
     } = apiRef.current.caches.aggregation;
-    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
 
     // Re-apply the row hydration to add / remove the aggregation footers
     if (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastRowHydration, aggregationRules)) {
-      if (props.unstable_dataSource) {
-        apiRef.current.unstable_dataSource.fetchRows();
+      if (props.dataSource) {
+        apiRef.current.dataSource.fetchRows();
       } else {
         apiRef.current.requestPipeProcessorsApplication('hydrateRows');
         applyAggregation();
@@ -96,7 +96,7 @@ const useGridAggregation = (apiRef, props) => {
     if (!(0, _gridAggregationUtils.areAggregationRulesEqual)(rulesOnLastColumnHydration, aggregationRules)) {
       apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
     }
-  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.unstable_dataSource]);
+  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'columnsChange', checkAggregationRulesDiff);
   (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'filteredRowsSet', applyAggregation);

package/hooks/features/aggregation/useGridAggregationPreProcessors.d.ts

@@ -1,4 +1,4 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiPremium } from '../../../models/gridApiPremium';
-import { DataGridPremiumProcessedProps } from '../../../models/dataGridPremiumProps';
-export declare const useGridAggregationPreProcessors: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "aggregationFunctions" | "disableAggregation" | "getAggregationPosition" | "slotProps" | "slots" | "unstable_dataSource">) => void;
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+export declare const useGridAggregationPreProcessors: (apiRef: RefObject<GridPrivateApiPremium>, props: Pick<DataGridPremiumProcessedProps, "aggregationFunctions" | "disableAggregation" | "getAggregationPosition" | "slotProps" | "slots" | "dataSource">) => void;

package/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -18,7 +18,7 @@ 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 ? {} : (0, _gridAggregationUtils.getAggregationRules)(columnsState.lookup, (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)(columnsState.lookup, (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.dataSource);
     columnsState.orderedFields.forEach(field => {
       const shouldHaveAggregationValue = !!aggregationRules[field];
       const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
@@ -40,9 +40,9 @@ 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 ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef), props.aggregationFunctions, !!props.unstable_dataSource);
+    const aggregationRules = props.disableAggregation ? {} : (0, _gridAggregationUtils.getAggregationRules)((0, _xDataGridPro.gridColumnLookupSelector)(apiRef), (0, _gridAggregationSelectors.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,
@@ -57,7 +57,7 @@ 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;
@@ -65,13 +65,13 @@ const useGridAggregationPreProcessors = (apiRef, props) => {
     const availableAggregationFunctions = (0, _gridAggregationUtils.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/hooks/features/aggregation/wrapColumnWithAggregation.d.ts

@@ -1,76 +1,81 @@
 import * as React from 'react';
 import { RefObject } from '@mui/x-internals/types';
 import { GridColDef, GridFilterOperator } from '@mui/x-data-grid-pro';
-import { GridBaseColDef } from '@mui/x-data-grid-pro/internals';
-import { GridApiPremium } from '../../../models/gridApiPremium';
-import { GridAggregationRule } from './gridAggregationInterfaces';
-declare const AGGREGATION_WRAPPABLE_PROPERTIES: readonly ["valueGetter", "valueFormatter", "renderCell", "renderHeader", "filterOperators"];
-type WrappableColumnProperty = (typeof AGGREGATION_WRAPPABLE_PROPERTIES)[number];
+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];
-    }[];
+  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;
+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;
+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;
+  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 {};
+export {};

package/hooks/features/aggregation/wrapColumnWithAggregation.js

@@ -9,18 +9,18 @@ exports.wrapColumnWithAggregationValue = exports.unwrapColumnFromAggregation = v
 var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var React = _interopRequireWildcard(require("react"));
+var _xDataGridPro = require("@mui/x-data-grid-pro");
 var _gridAggregationSelectors = require("./gridAggregationSelectors");
 var _GridFooterCell = require("../../../components/GridFooterCell");
 var _GridAggregationHeader = require("../../../components/GridAggregationHeader");
 var _jsxRuntime = require("react/jsx-runtime");
 const _excluded = ["aggregationWrappedProperties"];
-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 = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
     const cellAggregationResult = rowId ? getCellAggregationResult(rowId, column.field) : null;
     if (cellAggregationResult != null) {
       return cellAggregationResult?.value ?? null;
@@ -43,7 +43,7 @@ const getAggregationValueWrappedValueFormatter = ({
     return valueFormatter;
   }
   const wrappedValueFormatter = (value, row, column, apiRef) => {
-    const rowId = apiRef.current.getRowId(row);
+    const rowId = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
     if (rowId != null) {
       const cellAggregationResult = getCellAggregationResult(rowId, column.field);
       if (cellAggregationResult != null) {
@@ -102,7 +102,8 @@ const getWrappedFilterOperators = ({
       return null;
     }
     return (value, row, column, api) => {
-      if (getCellAggregationResult(apiRef.current.getRowId(row), column.field) != null) {
+      const rowId = (0, _xDataGridPro.gridRowIdSelector)(apiRef, row);
+      if (getCellAggregationResult(rowId, column.field) != null) {
         return true;
       }
       return filterFn(value, row, column, api);
@@ -141,7 +142,7 @@ const wrapColumnWithAggregationValue = ({
 }) => {
   const getCellAggregationResult = (id, field) => {
     let cellAggregationPosition = null;
-    const rowNode = apiRef.current.getRowNode(id);
+    const rowNode = (0, _xDataGridPro.gridRowNodeSelector)(apiRef, id);
     if (rowNode.type === 'group') {
       cellAggregationPosition = 'inline';
     } else if (id.toString().startsWith('auto-generated-group-footer-')) {

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

@@ -4,37 +4,37 @@ export type GridCellSelectionModel = Record<GridRowId, Record<GridColDef['field'
  * 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[];
-}
+  /**
+   * 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/hooks/features/cellSelection/gridCellSelectionSelector.d.ts

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

package/hooks/features/cellSelection/gridCellSelectionSelector.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.gridCellSelectionStateSelector = void 0;
-const gridCellSelectionStateSelector = state => state.cellSelection;
-exports.gridCellSelectionStateSelector = gridCellSelectionStateSelector;
+var _internals = require("@mui/x-data-grid-pro/internals");
+const gridCellSelectionStateSelector = exports.gridCellSelectionStateSelector = (0, _internals.createRootSelector)(state => state.cellSelection);

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

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

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

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

package/hooks/features/cellSelection/useGridCellSelection.js

@@ -49,11 +49,11 @@ const useGridCellSelection = (apiRef, props) => {
     if (!props.cellSelection) {
       return false;
     }
-    const cellSelectionModel = (0, _gridCellSelectionSelector.gridCellSelectionStateSelector)(apiRef.current.state);
+    const cellSelectionModel = (0, _gridCellSelectionSelector.gridCellSelectionStateSelector)(apiRef);
     return cellSelectionModel[id] ? !!cellSelectionModel[id][field] : false;
   }, [apiRef, props.cellSelection]);
   const getCellSelectionModel = React.useCallback(() => {
-    return (0, _gridCellSelectionSelector.gridCellSelectionStateSelector)(apiRef.current.state);
+    return (0, _gridCellSelectionSelector.gridCellSelectionStateSelector)(apiRef);
   }, [apiRef]);
   const setCellSelectionModel = React.useCallback(newModel => {
     if (!props.cellSelection) {
@@ -62,7 +62,6 @@ const useGridCellSelection = (apiRef, props) => {
     apiRef.current.setState(prevState => (0, _extends2.default)({}, prevState, {
       cellSelection: newModel
     }));
-    apiRef.current.forceUpdate();
   }, [apiRef, props.cellSelection]);
   const selectCellRange = React.useCallback((start, end, keepOtherSelected = false) => {
     const startRowIndex = apiRef.current.getRowIndexRelativeToVisibleRows(start.id);
@@ -193,7 +192,7 @@ const useGridCellSelection = (apiRef, props) => {
       if (!mousePosition.current || !apiRef.current.virtualScrollerRef?.current) {
         return;
       }
-      const dimensions = (0, _xDataGridPro.gridDimensionsSelector)(apiRef.current.state);
+      const dimensions = (0, _xDataGridPro.gridDimensionsSelector)(apiRef);
       const {
         x: mouseX,
         y: mouseY
@@ -253,7 +252,7 @@ const useGridCellSelection = (apiRef, props) => {
     if (!virtualScrollerRect) {
       return;
     }
-    const dimensions = (0, _xDataGridPro.gridDimensionsSelector)(apiRef.current.state);
+    const dimensions = (0, _xDataGridPro.gridDimensionsSelector)(apiRef);
     const {
       x,
       y
@@ -462,7 +461,7 @@ const useGridCellSelection = (apiRef, props) => {
     if (apiRef.current.getSelectedCellsAsArray().length <= 1) {
       return value;
     }
-    const sortedRowIds = (0, _xDataGridPro.gridSortedRowIdsSelector)(apiRef.current.state);
+    const sortedRowIds = (0, _xDataGridPro.gridSortedRowIdsSelector)(apiRef);
     const cellSelectionModel = apiRef.current.getCellSelectionModel();
     const unsortedSelectedRowIds = Object.keys(cellSelectionModel);
     const sortedSelectedRowIds = sortedRowIds.filter(id => unsortedSelectedRowIds.includes(`${id}`));

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

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

package/hooks/features/clipboard/useGridClipboardImport.js

@@ -201,10 +201,10 @@ function defaultPasteResolver({
     }
     return true;
   });
-  const selectedRows = apiRef.current.getSelectedRows();
-  if (selectedRows.size > 0 && !isSingleValuePasted) {
+  if ((0, _xDataGrid.gridRowSelectionCountSelector)(apiRef) > 0 && !isSingleValuePasted) {
     // Multiple values are pasted starting from the first and top-most cell
     const pastedRowsDataCount = pastedData.length;
+    const selectedRows = (0, _xDataGrid.gridRowSelectionIdsSelector)(apiRef);
 
     // There's no guarantee that the selected rows are in the same order as the pasted rows
     selectedRows.forEach((row, rowId) => {
@@ -263,7 +263,6 @@ const useGridClipboardImport = (apiRef, props) => {
   const onProcessRowUpdateError = props.onProcessRowUpdateError;
   const getRowId = props.getRowId;
   const enableClipboardPaste = !props.disableClipboardPaste;
-  const rootEl = apiRef.current.rootElementRef?.current;
   const logger = (0, _internals.useGridLogger)(apiRef, 'useGridClipboardImport');
   const splitClipboardPastedText = props.splitClipboardPastedText;
   const {
@@ -286,6 +285,7 @@ const useGridClipboardImport = (apiRef, props) => {
         return;
       }
     }
+    const rootEl = apiRef.current.rootElementRef?.current;
     if (!rootEl) {
       return;
     }
@@ -326,7 +326,7 @@ 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
   }) => {