@mui/x-data-grid-premium 8.0.0-beta.3 → 8.0.0

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

@@ -1,129 +0,0 @@
-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/modern/hooks/features/aggregation/gridAggregationSelectors.d.ts

@@ -1,13 +0,0 @@
-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/modern/hooks/features/aggregation/gridAggregationSelectors.js

@@ -1,15 +0,0 @@
-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.
- * If a column is not in the model, it is not aggregated.
- * @category Aggregation
- */
-export const gridAggregationModelSelector = createSelector(gridAggregationStateSelector, aggregationState => aggregationState.model);
-
-/**
- * Get the aggregation results as a lookup.
- * @category Aggregation
- */
-export const gridAggregationLookupSelector = createSelector(gridAggregationStateSelector, aggregationState => aggregationState.lookup);

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

@@ -1,62 +0,0 @@
-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.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;
-}) => 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>;
-}
-/**
- * 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;
-/**
- * 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;
-}) => string;
-export {};

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

@@ -1,180 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { unstable_capitalize as capitalize } from '@mui/utils';
-import { GRID_ID_AUTOGENERATED } from '@mui/x-data-grid/internals';
-import { GRID_ROOT_GROUP_ID } from '@mui/x-data-grid-pro';
-import { addPinnedRow, insertNodeInTree, removeNodeFromTree } from '@mui/x-data-grid-pro/internals';
-import { isDeepEqual } from '@mui/x-internals/isDeepEqual';
-export const GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = 'auto-generated-group-footer-root';
-export const getAggregationFooterRowIdFromGroupId = groupId => {
-  if (groupId == null) {
-    return GRID_AGGREGATION_ROOT_FOOTER_ROW_ID;
-  }
-  return `auto-generated-group-footer-${groupId}`;
-};
-const isClientSideAggregateFunction = aggregationFunction => !!aggregationFunction && 'apply' in aggregationFunction;
-export const canColumnHaveAggregationFunction = ({
-  colDef,
-  aggregationFunctionName,
-  aggregationFunction,
-  isDataSource
-}) => {
-  if (!colDef) {
-    return false;
-  }
-  if (!isClientSideAggregateFunction(aggregationFunction) && !isDataSource) {
-    return false;
-  }
-  if (colDef.availableAggregationFunctions != null) {
-    return colDef.availableAggregationFunctions.includes(aggregationFunctionName);
-  }
-  if (!aggregationFunction?.columnTypes) {
-    return true;
-  }
-  return aggregationFunction.columnTypes.includes(colDef.type);
-};
-export const getAvailableAggregationFunctions = ({
-  aggregationFunctions,
-  colDef,
-  isDataSource
-}) => Object.keys(aggregationFunctions).filter(aggregationFunctionName => canColumnHaveAggregationFunction({
-  colDef,
-  aggregationFunctionName,
-  aggregationFunction: aggregationFunctions[aggregationFunctionName],
-  isDataSource
-}));
-export const mergeStateWithAggregationModel = aggregationModel => state => _extends({}, state, {
-  aggregation: _extends({}, state.aggregation, {
-    model: aggregationModel
-  })
-});
-export const getAggregationRules = (columnsLookup, aggregationModel, aggregationFunctions, isDataSource) => {
-  const aggregationRules = {};
-
-  // eslint-disable-next-line guard-for-in
-  for (const field in aggregationModel) {
-    const columnItem = aggregationModel[field];
-    if (columnsLookup[field] && canColumnHaveAggregationFunction({
-      colDef: columnsLookup[field],
-      aggregationFunctionName: columnItem,
-      aggregationFunction: aggregationFunctions[columnItem],
-      isDataSource
-    })) {
-      aggregationRules[field] = {
-        aggregationFunctionName: columnItem,
-        aggregationFunction: aggregationFunctions[columnItem]
-      };
-    }
-  }
-  return aggregationRules;
-};
-/**
- * Add a footer for each group that has at least one column with an aggregated value.
- */
-export const addFooterRows = ({
-  groupingParams,
-  apiRef,
-  getAggregationPosition,
-  hasAggregationRule
-}) => {
-  let newGroupingParams = _extends({}, groupingParams, {
-    tree: _extends({}, groupingParams.tree),
-    treeDepths: _extends({}, groupingParams.treeDepths)
-  });
-  const updateChildGroupFooter = groupNode => {
-    const shouldHaveFooter = hasAggregationRule && getAggregationPosition(groupNode) === 'footer';
-    if (shouldHaveFooter) {
-      const footerId = getAggregationFooterRowIdFromGroupId(groupNode.id);
-      if (groupNode.footerId !== footerId) {
-        if (groupNode.footerId != null) {
-          removeNodeFromTree({
-            node: newGroupingParams.tree[groupNode.footerId],
-            tree: newGroupingParams.tree,
-            treeDepths: newGroupingParams.treeDepths
-          });
-        }
-        const footerNode = {
-          id: footerId,
-          parent: groupNode.id,
-          depth: groupNode ? groupNode.depth + 1 : 0,
-          type: 'footer'
-        };
-        insertNodeInTree(footerNode, newGroupingParams.tree, newGroupingParams.treeDepths, null);
-      }
-    } else if (groupNode.footerId != null) {
-      removeNodeFromTree({
-        node: newGroupingParams.tree[groupNode.footerId],
-        tree: newGroupingParams.tree,
-        treeDepths: newGroupingParams.treeDepths
-      });
-      newGroupingParams.tree[groupNode.id] = _extends({}, newGroupingParams.tree[groupNode.id], {
-        footerId: null
-      });
-    }
-  };
-  const updateRootGroupFooter = groupNode => {
-    const shouldHaveFooter = hasAggregationRule && getAggregationPosition(groupNode) === 'footer' && groupNode.children.length > 0;
-    if (shouldHaveFooter) {
-      const rowId = getAggregationFooterRowIdFromGroupId(null);
-      newGroupingParams = addPinnedRow({
-        groupingParams: newGroupingParams,
-        rowModel: {
-          [GRID_ID_AUTOGENERATED]: rowId
-        },
-        rowId,
-        position: 'bottom',
-        apiRef,
-        isAutoGenerated: true
-      });
-    }
-  };
-  const updateGroupFooter = groupNode => {
-    if (groupNode.id === GRID_ROOT_GROUP_ID) {
-      updateRootGroupFooter(groupNode);
-    } else {
-      updateChildGroupFooter(groupNode);
-    }
-    groupNode.children.forEach(childId => {
-      const childNode = newGroupingParams.tree[childId];
-      if (childNode.type === 'group') {
-        updateGroupFooter(childNode);
-      }
-    });
-  };
-  updateGroupFooter(newGroupingParams.tree[GRID_ROOT_GROUP_ID]);
-  return newGroupingParams;
-};
-
-/**
- * Compares two sets of aggregation rules to determine if they are equal or not.
- */
-export const areAggregationRulesEqual = (previousValue, newValue) => {
-  const previousFields = Object.keys(previousValue ?? {});
-  const newFields = Object.keys(newValue);
-  if (!isDeepEqual(previousFields, newFields)) {
-    return false;
-  }
-  return newFields.every(field => {
-    const previousRule = previousValue?.[field];
-    const newRule = newValue[field];
-    if (previousRule?.aggregationFunction !== newRule?.aggregationFunction) {
-      return false;
-    }
-    if (previousRule?.aggregationFunctionName !== newRule?.aggregationFunctionName) {
-      return false;
-    }
-    return true;
-  });
-};
-export const getAggregationFunctionLabel = ({
-  apiRef,
-  aggregationRule
-}) => {
-  if (aggregationRule.aggregationFunction.label != null) {
-    return aggregationRule.aggregationFunction.label;
-  }
-  try {
-    return apiRef.current.getLocaleText(`aggregationFunctionLabel${capitalize(aggregationRule.aggregationFunctionName)}`);
-  } catch {
-    return aggregationRule.aggregationFunctionName;
-  }
-};

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

@@ -1,4 +0,0 @@
-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/modern/hooks/features/aggregation/index.js

@@ -1,3 +0,0 @@
-export * from "./gridAggregationSelectors.js";
-export * from "./gridAggregationFunctions.js";
-export { GRID_AGGREGATION_ROOT_FOOTER_ROW_ID, getAggregationFooterRowIdFromGroupId } from "./gridAggregationUtils.js";

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

@@ -1,6 +0,0 @@
-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 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" | "dataSource">) => void;

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

@@ -1,103 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { gridColumnLookupSelector, useGridEvent, useGridApiMethod } from '@mui/x-data-grid-pro';
-import { useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
-import { gridAggregationModelSelector } from "./gridAggregationSelectors.js";
-import { getAggregationRules, mergeStateWithAggregationModel, areAggregationRulesEqual } from "./gridAggregationUtils.js";
-import { createAggregationLookup } from "./createAggregationLookup.js";
-export const aggregationStateInitializer = (state, props, apiRef) => {
-  apiRef.current.caches.aggregation = {
-    rulesOnLastColumnHydration: {},
-    rulesOnLastRowHydration: {}
-  };
-  return _extends({}, state, {
-    aggregation: {
-      model: props.aggregationModel ?? props.initialState?.aggregation?.model ?? {}
-    }
-  });
-};
-export const useGridAggregation = (apiRef, props) => {
-  apiRef.current.registerControlState({
-    stateId: 'aggregation',
-    propModel: props.aggregationModel,
-    propOnChange: props.onAggregationModelChange,
-    stateSelector: gridAggregationModelSelector,
-    changeEvent: 'aggregationModelChange'
-  });
-
-  /**
-   * API METHODS
-   */
-  const setAggregationModel = React.useCallback(model => {
-    const currentModel = gridAggregationModelSelector(apiRef);
-    if (currentModel !== model) {
-      apiRef.current.setState(mergeStateWithAggregationModel(model));
-    }
-  }, [apiRef]);
-  const applyAggregation = React.useCallback(() => {
-    const aggregationLookup = createAggregationLookup({
-      apiRef,
-      getAggregationPosition: props.getAggregationPosition,
-      aggregationFunctions: props.aggregationFunctions,
-      aggregationRowsScope: props.aggregationRowsScope,
-      isDataSource: !!props.dataSource
-    });
-    apiRef.current.setState(state => _extends({}, state, {
-      aggregation: _extends({}, state.aggregation, {
-        lookup: aggregationLookup
-      })
-    }));
-  }, [apiRef, props.getAggregationPosition, props.aggregationFunctions, props.aggregationRowsScope, props.dataSource]);
-  const aggregationApi = {
-    setAggregationModel
-  };
-  const aggregationPrivateApi = {
-    applyAggregation
-  };
-  useGridApiMethod(apiRef, aggregationApi, 'public');
-  useGridApiMethod(apiRef, aggregationPrivateApi, 'private');
-  const addGetRowsParams = React.useCallback(params => {
-    return _extends({}, params, {
-      aggregationModel: gridAggregationModelSelector(apiRef)
-    });
-  }, [apiRef]);
-  useGridRegisterPipeProcessor(apiRef, 'getRowsParams', addGetRowsParams);
-
-  /**
-   * EVENTS
-   */
-  const checkAggregationRulesDiff = React.useCallback(() => {
-    const {
-      rulesOnLastRowHydration,
-      rulesOnLastColumnHydration
-    } = apiRef.current.caches.aggregation;
-    const aggregationRules = props.disableAggregation ? {} : getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), props.aggregationFunctions, !!props.dataSource);
-
-    // Re-apply the row hydration to add / remove the aggregation footers
-    if (!areAggregationRulesEqual(rulesOnLastRowHydration, aggregationRules)) {
-      if (props.dataSource) {
-        apiRef.current.dataSource.fetchRows();
-      } else {
-        apiRef.current.requestPipeProcessorsApplication('hydrateRows');
-        applyAggregation();
-      }
-    }
-
-    // Re-apply the column hydration to wrap / unwrap the aggregated columns
-    if (!areAggregationRulesEqual(rulesOnLastColumnHydration, aggregationRules)) {
-      apiRef.current.requestPipeProcessorsApplication('hydrateColumns');
-    }
-  }, [apiRef, applyAggregation, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
-  useGridEvent(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
-  useGridEvent(apiRef, 'columnsChange', checkAggregationRulesDiff);
-  useGridEvent(apiRef, 'filteredRowsSet', applyAggregation);
-
-  /**
-   * EFFECTS
-   */
-  React.useEffect(() => {
-    if (props.aggregationModel !== undefined) {
-      apiRef.current.setAggregationModel(props.aggregationModel);
-    }
-  }, [apiRef, props.aggregationModel]);
-};

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

@@ -1,4 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-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/modern/hooks/features/aggregation/useGridAggregationPreProcessors.js

@@ -1,96 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { gridColumnLookupSelector } from '@mui/x-data-grid-pro';
-import { useGridRegisterPipeProcessor } from '@mui/x-data-grid-pro/internals';
-import { getAvailableAggregationFunctions, addFooterRows, getAggregationRules, mergeStateWithAggregationModel } from "./gridAggregationUtils.js";
-import { wrapColumnWithAggregationValue, unwrapColumnFromAggregation } from "./wrapColumnWithAggregation.js";
-import { gridAggregationModelSelector } from "./gridAggregationSelectors.js";
-export const useGridAggregationPreProcessors = (apiRef, props) => {
-  // apiRef.current.caches.aggregation.rulesOnLastColumnHydration is not used because by the time
-  // 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.dataSource);
-    columnsState.orderedFields.forEach(field => {
-      const shouldHaveAggregationValue = !!aggregationRules[field];
-      const haveAggregationColumnValue = !!rulesOnLastColumnHydration.current[field];
-      let column = columnsState.lookup[field];
-      if (haveAggregationColumnValue) {
-        column = unwrapColumnFromAggregation({
-          column
-        });
-      }
-      if (shouldHaveAggregationValue) {
-        column = wrapColumnWithAggregationValue({
-          column,
-          aggregationRule: aggregationRules[field],
-          apiRef
-        });
-      }
-      columnsState.lookup[field] = column;
-    });
-    rulesOnLastColumnHydration.current = aggregationRules;
-    apiRef.current.caches.aggregation.rulesOnLastColumnHydration = aggregationRules;
-    return columnsState;
-  }, [apiRef, props.aggregationFunctions, props.disableAggregation, props.dataSource]);
-  const addGroupFooterRows = React.useCallback(value => {
-    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,
-    // Then we can skip this step
-    if (Object.keys(apiRef.current.caches.aggregation.rulesOnLastRowHydration).length === 0 && !hasAggregationRule) {
-      return value;
-    }
-    apiRef.current.caches.aggregation.rulesOnLastRowHydration = aggregationRules;
-    return addFooterRows({
-      apiRef,
-      groupingParams: value,
-      getAggregationPosition: props.getAggregationPosition,
-      hasAggregationRule
-    });
-  }, [apiRef, props.disableAggregation, props.getAggregationPosition, props.aggregationFunctions, props.dataSource]);
-  const addColumnMenuButtons = React.useCallback((columnMenuItems, colDef) => {
-    if (props.disableAggregation || !colDef.aggregable) {
-      return columnMenuItems;
-    }
-    const availableAggregationFunctions = getAvailableAggregationFunctions({
-      aggregationFunctions: props.aggregationFunctions,
-      colDef,
-      isDataSource: !!props.dataSource
-    });
-    if (availableAggregationFunctions.length === 0) {
-      return columnMenuItems;
-    }
-    return [...columnMenuItems, 'columnMenuAggregationItem'];
-  }, [props.aggregationFunctions, props.disableAggregation, props.dataSource]);
-  const stateExportPreProcessing = React.useCallback(prevState => {
-    if (props.disableAggregation) {
-      return prevState;
-    }
-    const aggregationModelToExport = gridAggregationModelSelector(apiRef);
-    if (Object.values(aggregationModelToExport).length === 0) {
-      return prevState;
-    }
-    return _extends({}, prevState, {
-      aggregation: {
-        model: aggregationModelToExport
-      }
-    });
-  }, [apiRef, props.disableAggregation]);
-  const stateRestorePreProcessing = React.useCallback((params, context) => {
-    if (props.disableAggregation) {
-      return params;
-    }
-    const aggregationModel = context.stateToRestore.aggregation?.model;
-    if (aggregationModel != null) {
-      apiRef.current.setState(mergeStateWithAggregationModel(aggregationModel));
-    }
-    return params;
-  }, [apiRef, props.disableAggregation]);
-  useGridRegisterPipeProcessor(apiRef, 'hydrateColumns', updateAggregatedColumns);
-  useGridRegisterPipeProcessor(apiRef, 'hydrateRows', addGroupFooterRows);
-  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButtons);
-  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
-  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
-};