@mui/x-data-grid-premium 8.0.0-alpha.8 → 8.0.0-beta.0

package/esm/components/export/ExportExcel.js

@@ -0,0 +1,209 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+const _excluded = ["render", "options", "onClick"];
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import { useGridComponentRenderer } from '@mui/x-data-grid/internals';
+import { forwardRef } from '@mui/x-internals/forwardRef';
+import { useGridApiContext } from "../../hooks/utils/useGridApiContext.js";
+import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * A button that triggers an Excel export.
+ * It renders the `baseButton` slot.
+ *
+ * Demos:
+ *
+ * - [Export](https://mui.com/x/react-data-grid/components/export/)
+ *
+ * API:
+ *
+ * - [ExportExcel API](https://mui.com/x/api/data-grid/export-excel/)
+ */
+const ExportExcel = forwardRef(function ExportExcel(props, ref) {
+  const {
+      render,
+      options,
+      onClick
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const rootProps = useGridRootProps();
+  const apiRef = useGridApiContext();
+  const handleClick = event => {
+    apiRef.current.exportDataAsExcel(options);
+    onClick?.(event);
+  };
+  const element = useGridComponentRenderer(rootProps.slots.baseButton, render, _extends({
+    onClick: handleClick
+  }, rootProps.slotProps?.baseButton, other, {
+    ref
+  }));
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: element
+  });
+});
+process.env.NODE_ENV !== "production" ? ExportExcel.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * A ref for imperative actions.
+   * It currently only supports `focusVisible()` action.
+   */
+  action: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    current: PropTypes.shape({
+      focusVisible: PropTypes.func.isRequired
+    })
+  })]),
+  /**
+   * If `true`, the ripples are centered.
+   * They won't start at the cursor interaction position.
+   * @default false
+   */
+  centerRipple: PropTypes.bool,
+  className: PropTypes.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: PropTypes.oneOf(['error', 'info', 'inherit', 'primary', 'secondary', 'success', 'warning']),
+  component: PropTypes.elementType,
+  /**
+   * If `true`, the component is disabled.
+   */
+  disabled: PropTypes.bool,
+  /**
+   * If `true`, no elevation is used.
+   * @default false
+   */
+  disableElevation: PropTypes.bool,
+  /**
+   * If `true`, the  keyboard focus ripple is disabled.
+   * @default false
+   */
+  disableFocusRipple: PropTypes.bool,
+  /**
+   * If `true`, the ripple effect is disabled.
+   *
+   * ⚠️ Without a ripple there is no styling for :focus-visible by default. Be sure
+   * to highlight the element by applying separate styles with the `.Mui-focusVisible` class.
+   * @default false
+   */
+  disableRipple: PropTypes.bool,
+  /**
+   * If `true`, the touch ripple effect is disabled.
+   * @default false
+   */
+  disableTouchRipple: PropTypes.bool,
+  /**
+   * Element placed after the children.
+   */
+  endIcon: PropTypes.node,
+  /**
+   * If `true`, the base button will have a keyboard focus ripple.
+   * @default false
+   */
+  focusRipple: PropTypes.bool,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: PropTypes.string,
+  /**
+   * If `true`, the button will take up the full width of its container.
+   * @default false
+   */
+  fullWidth: PropTypes.bool,
+  /**
+   * The URL to link to when the button is clicked.
+   * If defined, an `a` element will be used as the root node.
+   */
+  href: PropTypes.string,
+  /**
+   * The component used to render a link when the `href` prop is provided.
+   * @default 'a'
+   */
+  LinkComponent: PropTypes.elementType,
+  /**
+   * If `true`, the loading indicator is visible and the button is disabled.
+   * If `true | false`, the loading wrapper is always rendered before the children to prevent [Google Translation Crash](https://github.com/mui/material-ui/issues/27853).
+   * @default null
+   */
+  loading: PropTypes.bool,
+  /**
+   * Element placed before the children if the button is in loading state.
+   * The node should contain an element with `role="progressbar"` with an accessible name.
+   * By default, it renders a `CircularProgress` that is labeled by the button itself.
+   * @default <CircularProgress color="inherit" size={16} />
+   */
+  loadingIndicator: PropTypes.node,
+  /**
+   * The loading indicator can be positioned on the start, end, or the center of the button.
+   * @default 'center'
+   */
+  loadingPosition: PropTypes.oneOf(['center', 'end', 'start']),
+  /**
+   * Callback fired when the component is focused with a keyboard.
+   * We trigger a `onFocus` callback too.
+   */
+  onFocusVisible: PropTypes.func,
+  /**
+   * The options to apply on the Excel export.
+   * @demos
+   *   - [Excel export](/x/react-data-grid/export/#excel-export)
+   */
+  options: PropTypes.shape({
+    allColumns: PropTypes.bool,
+    columnsStyles: PropTypes.object,
+    escapeFormulas: PropTypes.bool,
+    exceljsPostProcess: PropTypes.func,
+    exceljsPreProcess: PropTypes.func,
+    fields: PropTypes.arrayOf(PropTypes.string),
+    fileName: PropTypes.string,
+    getRowsToExport: PropTypes.func,
+    includeColumnGroupsHeaders: PropTypes.bool,
+    includeHeaders: PropTypes.bool,
+    valueOptionsSheetName: PropTypes.string,
+    worker: PropTypes.func
+  }),
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),
+  /**
+   * The size of the component.
+   * `small` is equivalent to the dense button styling.
+   */
+  size: PropTypes.oneOf(['large', 'medium', 'small']),
+  /**
+   * Element placed before the children.
+   */
+  startIcon: PropTypes.node,
+  style: PropTypes.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.func, PropTypes.object, PropTypes.bool])), PropTypes.func, PropTypes.object]),
+  tabIndex: PropTypes.number,
+  /**
+   * Props applied to the `TouchRipple` element.
+   */
+  TouchRippleProps: PropTypes.object,
+  /**
+   * A ref that points to the `TouchRipple` element.
+   */
+  touchRippleRef: PropTypes.any,
+  /**
+   * The variant to use.
+   * @default 'text'
+   */
+  variant: PropTypes.oneOf(['contained', 'outlined', 'text'])
+} : void 0;
+export { ExportExcel };

package/esm/components/export/index.d.ts

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

package/esm/components/export/index.js

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

package/esm/components/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./GridExcelExportMenuItem.js";
+export * from "../material/icons.js";
+export * from "./GridColumnMenuAggregationItem.js";
+export * from "./promptControl/index.js";
+export { GridColumnMenuGroupingItem } from "./GridPremiumColumnMenu.js";
+export * from "./export/index.js";

package/esm/components/index.js

@@ -2,4 +2,5 @@ export * from "./GridExcelExportMenuItem.js";
 export * from "../material/icons.js";
 export * from "./GridColumnMenuAggregationItem.js";
 export * from "./promptControl/index.js";
-export { GridColumnMenuGroupingItem } from "./GridPremiumColumnMenu.js";
+export { GridColumnMenuGroupingItem } from "./GridPremiumColumnMenu.js";
+export * from "./export/index.js";

package/esm/components/promptControl/GridToolbarPromptControl.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { PromptResponse } from "../../hooks/features/promptControl/types.js";
+type GridToolbarPromptControlProps = {
+  /**
+   * Called when the new prompt is ready to be processed.
+   * Provides the prompt and the data context and expects the grid state updates to be returned.
+   * @param {string} context The context of the prompt
+   * @param {string} query The query to process
+   * @returns {Promise<PromptResponse>} The grid state updates
+   */
+  onPrompt: (context: string, query: string) => Promise<PromptResponse>;
+  /**
+   * Allow taking couple of random cell values from each column to improve the prompt context.
+   * If allowed, samples are taken from different rows.
+   * If not allowed, the column examples are used.
+   * @default false
+   */
+  allowDataSampling?: boolean;
+  /**
+   * The BCP 47 language tag to use for the speech recognition.
+   * @default HTML lang attribute value or the user agent's language setting
+   */
+  lang?: string;
+};
+declare function GridToolbarPromptControl(props: GridToolbarPromptControlProps): React.JSX.Element;
+export { GridToolbarPromptControl };

package/esm/components/promptControl/GridToolbarPromptControl.js

@@ -10,9 +10,10 @@ import { useGridRootProps } from "../../hooks/utils/useGridRootProps.js";
 import { RecordButton, BrowserSpeechRecognition } from "./RecordButton.js";
 import { jsx as _jsx } from "react/jsx-runtime";
 const supportsSpeechRecognition = !!BrowserSpeechRecognition;
-const useUtilityClasses = (ownerState, recording) => {
+const useUtilityClasses = ownerState => {
   const {
-    classes
+    classes,
+    recording
   } = ownerState;
   const slots = {
     root: ['toolbarPromptControl', recording && 'toolbarPromptControl--recording'],
@@ -25,7 +26,12 @@ const useUtilityClasses = (ownerState, recording) => {
 const GridToolbarPromptControlRoot = styled('div', {
   name: 'MuiDataGrid',
   slot: 'ToolbarPromptControl',
-  overridesResolver: (_, styles) => styles.toolbarPromptControl
+  overridesResolver: (props, styles) => {
+    const {
+      ownerState
+    } = props;
+    return [styles.toolbarPromptControl, ownerState.recording && styles['toolbarPromptControl--recording']];
+  }
 })({
   flex: 1,
   display: 'flex',
@@ -71,7 +77,11 @@ function GridToolbarPromptControl(props) {
   const [error, setError] = React.useState(null);
   const [isRecording, setRecording] = React.useState(false);
   const [query, setQuery] = React.useState('');
-  const classes = useUtilityClasses(rootProps, isRecording);
+  const ownerState = {
+    classes: rootProps.classes,
+    recording: isRecording
+  };
+  const classes = useUtilityClasses(ownerState);
   const examplesFromData = React.useMemo(() => allowDataSampling ? sampleData(apiRef) : undefined, [apiRef, allowDataSampling]);
   const processPrompt = React.useCallback(() => {
     const context = generateContext(apiRef, examplesFromData);
@@ -109,10 +119,18 @@ function GridToolbarPromptControl(props) {
         sort: s.direction
       })));
       const rows = getVisibleRows(apiRef, rootProps);
-      const selectedRowIds = result.select === -1 ? [] : rows.rows.slice(0, result.select).map(r => {
-        return apiRef.current.getRowId(r);
-      });
-      apiRef.current.setRowSelectionModel(selectedRowIds);
+      const rowSelectionModel = {
+        type: 'include',
+        ids: new Set()
+      };
+      if (result.select !== -1) {
+        for (let i = 0; i < result.select; i += 1) {
+          const row = rows.rows[i];
+          const id = apiRef.current.getRowId(row);
+          rowSelectionModel.ids.add(id);
+        }
+      }
+      apiRef.current.setRowSelectionModel(rowSelectionModel);
       const columns = apiRef.current.getAllColumns();
       const targetIndex = Number(columns.find(c => c.field === GRID_CHECKBOX_SELECTION_FIELD) !== undefined) + Number(result.grouping.length);
       interestColumns.push(...Object.keys(result.aggregation));
@@ -145,10 +163,9 @@ function GridToolbarPromptControl(props) {
   });
   const placeholder = supportsSpeechRecognition ? apiRef.current.getLocaleText('toolbarPromptControlWithRecordingPlaceholder') : apiRef.current.getLocaleText('toolbarPromptControlPlaceholder');
   return /*#__PURE__*/_jsx(GridToolbarPromptControlRoot, {
-    ownerState: rootProps,
+    ownerState: ownerState,
     className: classes.root,
     children: /*#__PURE__*/_jsx(rootProps.slots.baseTextField, {
-      variant: "outlined",
       placeholder: isRecording ? apiRef.current.getLocaleText('toolbarPromptControlRecordingPlaceholder') : placeholder,
       "aria-label": apiRef.current.getLocaleText('toolbarPromptControlLabel'),
       disabled: isLoading,
@@ -161,10 +178,9 @@ function GridToolbarPromptControl(props) {
       onKeyDown: handleKeyDown,
       error: !!error,
       helperText: error,
-      InputProps: {
-        startAdornment: supportsSpeechRecognition && /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-          position: "start",
-          children: /*#__PURE__*/_jsx(RecordButton, {
+      slotProps: {
+        input: {
+          startAdornment: supportsSpeechRecognition && /*#__PURE__*/_jsx(RecordButton, {
             className: classes.recordButton,
             lang: lang,
             recording: isRecording,
@@ -173,11 +189,8 @@ function GridToolbarPromptControl(props) {
             onUpdate: setQuery,
             onDone: handleDone,
             onError: setError
-          })
-        }),
-        endAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseInputAdornment, {
-          position: "end",
-          children: /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
+          }),
+          endAdornment: /*#__PURE__*/_jsx(rootProps.slots.baseTooltip, {
             title: apiRef.current.getLocaleText('toolbarPromptControlSendActionLabel'),
             children: /*#__PURE__*/_jsx("div", {
               children: /*#__PURE__*/_jsx(rootProps.slots.baseIconButton, {
@@ -194,7 +207,7 @@ function GridToolbarPromptControl(props) {
               })
             })
           })
-        })
+        }
       }
     })
   });

package/esm/components/promptControl/RecordButton.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export declare const BrowserSpeechRecognition: any;
+type SpeechRecognitionOptions = {
+  onUpdate: (value: string) => void;
+  onDone: (value: string) => void;
+  onError: (error: string) => void;
+};
+interface RecordButtonProps extends SpeechRecognitionOptions {
+  disabled: boolean;
+  lang?: string;
+  recording: boolean;
+  setRecording: (value: boolean) => void;
+  className: string;
+}
+declare function RecordButton(props: RecordButtonProps): React.JSX.Element;
+export { RecordButton };

package/esm/components/promptControl/index.d.ts

@@ -0,0 +1 @@
+export { GridToolbarPromptControl as Unstable_GridToolbarPromptControl } from "./GridToolbarPromptControl.js";

package/esm/components/reexports.d.ts

@@ -0,0 +1 @@
+export { GridPremiumColumnMenu as GridColumnMenu, GRID_COLUMN_MENU_SLOTS_PREMIUM as GRID_COLUMN_MENU_SLOTS, GRID_COLUMN_MENU_SLOT_PROPS_PREMIUM as GRID_COLUMN_MENU_SLOT_PROPS } from "./GridPremiumColumnMenu.js";

package/esm/constants/dataGridPremiumDefaultSlotsComponents.d.ts

@@ -0,0 +1,2 @@
+import type { GridPremiumSlotsComponent } from '../models';
+export declare const DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS: GridPremiumSlotsComponent;

package/esm/constants/dataGridPremiumDefaultSlotsComponents.js

@@ -2,6 +2,10 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import { DATA_GRID_PRO_DEFAULT_SLOTS_COMPONENTS } from '@mui/x-data-grid-pro/internals';
 import { GridPremiumColumnMenu } from "../components/GridPremiumColumnMenu.js";
 import materialSlots from "../material/index.js";
+import { GridBottomContainer } from "../components/GridBottomContainer.js";
+import { GridPremiumToolbar } from "../components/GridPremiumToolbar.js";
 export const DATA_GRID_PREMIUM_DEFAULT_SLOTS_COMPONENTS = _extends({}, DATA_GRID_PRO_DEFAULT_SLOTS_COMPONENTS, materialSlots, {
-  columnMenu: GridPremiumColumnMenu
+  columnMenu: GridPremiumColumnMenu,
+  bottomContainer: GridBottomContainer,
+  toolbar: GridPremiumToolbar
 });

package/esm/hooks/features/aggregation/createAggregationLookup.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from '@mui/x-internals/types';
+import { GridPrivateApiPremium } from "../../../models/gridApiPremium.js";
+import { DataGridPremiumProcessedProps } from "../../../models/dataGridPremiumProps.js";
+import { GridAggregationFunction, GridAggregationFunctionDataSource, GridAggregationLookup } from "./gridAggregationInterfaces.js";
+export declare const createAggregationLookup: ({
+  apiRef,
+  aggregationFunctions,
+  aggregationRowsScope,
+  getAggregationPosition,
+  isDataSource
+}: {
+  apiRef: RefObject<GridPrivateApiPremium>;
+  aggregationFunctions: Record<string, GridAggregationFunction> | Record<string, GridAggregationFunctionDataSource>;
+  aggregationRowsScope: DataGridPremiumProcessedProps["aggregationRowsScope"];
+  getAggregationPosition: DataGridPremiumProcessedProps["getAggregationPosition"];
+  isDataSource: boolean;
+}) => GridAggregationLookup;

package/esm/hooks/features/aggregation/createAggregationLookup.js

@@ -1,4 +1,4 @@
-import { gridColumnLookupSelector, gridFilteredRowsLookupSelector, gridRowTreeSelector, GRID_ROOT_GROUP_ID } from '@mui/x-data-grid-pro';
+import { gridColumnLookupSelector, gridFilteredRowsLookupSelector, gridRowTreeSelector, GRID_ROOT_GROUP_ID, gridRowNodeSelector } from '@mui/x-data-grid-pro';
 import { getAggregationRules } from "./gridAggregationUtils.js";
 import { gridAggregationModelSelector } from "./gridAggregationSelectors.js";
 const getGroupAggregatedValue = (groupId, apiRef, aggregationRowsScope, aggregatedFields, aggregationRules, position) => {
@@ -20,7 +20,7 @@ const getGroupAggregatedValue = (groupId, apiRef, aggregationRowsScope, aggregat
     //   A.B
     //     A.B.A
     //     A.B.B
-    const rowNode = apiRef.current.getRowNode(rowId);
+    const rowNode = gridRowNodeSelector(apiRef, rowId);
     if (rowNode.type === 'group') {
       return;
     }
@@ -70,7 +70,7 @@ const getGroupAggregatedValueDataSource = (groupId, apiRef, aggregatedFields, po
     const aggregatedField = aggregatedFields[j];
     groupAggregationLookup[aggregatedField] = {
       position,
-      value: apiRef.current.resolveGroupAggregation(groupId, aggregatedField)
+      value: apiRef.current.resolveGroupAggregation?.(groupId, aggregatedField) ?? ''
     };
   }
   return groupAggregationLookup;

package/esm/hooks/features/aggregation/gridAggregationFunctions.d.ts

@@ -0,0 +1,8 @@
+import { GridAggregationFunction } from "./gridAggregationInterfaces.js";
+export declare const GRID_AGGREGATION_FUNCTIONS: {
+  sum: GridAggregationFunction<unknown, number>;
+  avg: GridAggregationFunction<unknown, number>;
+  min: GridAggregationFunction<number | Date, number | Date>;
+  max: GridAggregationFunction<number | Date, number | Date>;
+  size: GridAggregationFunction<unknown, number>;
+};

package/esm/hooks/features/aggregation/gridAggregationInterfaces.d.ts

@@ -0,0 +1,129 @@
+import { GridRowId, GridRowModel, GridColDef, GridValueFormatter } from '@mui/x-data-grid-pro';
+export interface GridAggregationState {
+  model: GridAggregationModel;
+  lookup: GridAggregationLookup;
+}
+export interface GridAggregationInitialState {
+  model?: GridAggregationModel;
+}
+export interface GridAggregationInternalCache {
+  rulesOnLastColumnHydration: GridAggregationRules;
+  rulesOnLastRowHydration: GridAggregationRules;
+}
+export interface GridAggregationApi {
+  /**
+   * Sets the aggregation model to the one given by `model`.
+   * @param {GridAggregationModel} model The aggregation model.
+   */
+  setAggregationModel: (model: GridAggregationModel) => void;
+}
+export interface GridAggregationPrivateApi {
+  /**
+   * Applies the aggregation to the rows.
+   */
+  applyAggregation: () => void;
+}
+export interface GridAggregationGetCellValueParams {
+  /**
+   * The row model of the row that the current cell belongs to.
+   */
+  row: GridRowModel;
+}
+/**
+ * Grid aggregation function definition interface.
+ * @demos
+ *   - [Aggregation functions](/x/react-data-grid/aggregation/#aggregation-functions)
+ */
+export interface GridAggregationFunction<V = any, AV = V> {
+  /**
+   * Function that takes the current cell values and generates the aggregated value.
+   * @template V, AV
+   * @param {GridAggregationParams<V>} params The params of the current aggregated cell.
+   * @returns {AV} The aggregated value.
+   */
+  apply: (params: GridAggregationParams<V>) => AV | null | undefined;
+  /**
+   * Label of the aggregation function.
+   * Used for adding a label to the footer of the grouping column when this aggregation function is the only one being used.
+   * @default apiRef.current.getLocaleText('aggregationFunctionLabel{capitalize(name)})
+   */
+  label?: string;
+  /**
+   * Column types supported by this aggregation function.
+   * If not defined, all types are supported (in most cases this property should be defined).
+   */
+  columnTypes?: string[];
+  /**
+   * Function for applying a formatter to the aggregated value.
+   * If not defined, the grid uses the formatter of the column.
+   */
+  valueFormatter?: GridValueFormatter;
+  /**
+   * Indicates if the aggregated value has the same unit as the cells used to generate it.
+   * It can be used to apply a custom cell renderer only if the aggregated value has the same unit.
+   * @default true
+   */
+  hasCellUnit?: boolean;
+  /**
+   * Function that allows to transform the value of the cell passed to the aggregation function applier.
+   * Useful for aggregating data from multiple row fields.
+   * @demo https://mui.com/x/react-data-grid/aggregation/#aggregating-data-from-multiple-row-fields
+   * @param {GridAggregationGetCellValueParams} params The params of the current cell
+   * @returns {V} The value of the cell that will be passed to the aggregation `apply` function
+   */
+  getCellValue?: (params: GridAggregationGetCellValueParams) => V;
+}
+/**
+ * Grid aggregation function data source definition interface.
+ * @demos
+ *   - [Server-side aggregation](/x/react-data-grid/server-side-data/aggregation/)
+ */
+export interface GridAggregationFunctionDataSource extends Omit<GridAggregationFunction, 'apply' | 'getCellValue'> {}
+export interface GridAggregationParams<V = any> {
+  values: (V | undefined)[];
+  groupId: GridRowId;
+  field: GridColDef['field'];
+}
+export type GridAggregationModel = {
+  [field: string]: string;
+};
+export type GridAggregationLookup = {
+  [rowId: GridRowId]: {
+    [field: string]: {
+      position: GridAggregationPosition;
+      value: any;
+    };
+  };
+};
+export type GridAggregationPosition = 'inline' | 'footer';
+export interface GridAggregationCellMeta {
+  /**
+   * If `true`, the current aggregated value has the same unit as the value of the other cells of this row.
+   * For instance, "min" / "max" aggregation have the same unit as the other cells.
+   * If `false`, the current aggregated value has another unit or not unit.
+   * For instance, "size" aggregation has no unit.
+   */
+  hasCellUnit: boolean;
+  /**
+   * Name of the aggregation function currently applied on this cell.
+   */
+  aggregationFunctionName: string;
+}
+export interface GridAggregationHeaderMeta {
+  aggregationRule: GridAggregationRule;
+}
+export interface GridAggregationRule {
+  aggregationFunctionName: string;
+  aggregationFunction: GridAggregationFunction | GridAggregationFunctionDataSource;
+}
+/**
+ * Object containing all the aggregation rules that must be applied to the current columns.
+ * Unlike the aggregation model, those rules are sanitized and do not contain:
+ * - items for non-existing columns
+ * - items for non-aggregable columns (GridColDef.aggregable = false)
+ * - items for non-existing aggregation function
+ * - items for non-available aggregation function on the column (GridColDef.availableAggregationFunctions)
+ */
+export type GridAggregationRules = {
+  [field: string]: GridAggregationRule;
+};

package/esm/hooks/features/aggregation/gridAggregationSelectors.d.ts

@@ -0,0 +1,13 @@
+import { GridStatePremium } from "../../../models/gridStatePremium.js";
+export declare const gridAggregationStateSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, unknown, import("./gridAggregationInterfaces").GridAggregationState>;
+/**
+ * Get the aggregation model, containing the aggregation function of each column.
+ * If a column is not in the model, it is not aggregated.
+ * @category Aggregation
+ */
+export declare const gridAggregationModelSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationModel>;
+/**
+ * Get the aggregation results as a lookup.
+ * @category Aggregation
+ */
+export declare const gridAggregationLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStatePremium, import("./gridAggregationInterfaces").GridAggregationState, import("./gridAggregationInterfaces").GridAggregationLookup>;

package/esm/hooks/features/aggregation/gridAggregationSelectors.js

@@ -1,5 +1,5 @@
-import { createSelector } from '@mui/x-data-grid-pro/internals';
-export const gridAggregationStateSelector = state => state.aggregation;
+import { createSelector, createRootSelector } from '@mui/x-data-grid-pro/internals';
+export const gridAggregationStateSelector = createRootSelector(state => state.aggregation);
 
 /**
  * Get the aggregation model, containing the aggregation function of each column.