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

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

@@ -1,111 +0,0 @@
-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) => {
-  const groupAggregationLookup = {};
-  const aggregatedValues = [];
-  const rowIds = apiRef.current.getRowGroupChildren({
-    groupId
-  });
-  const filteredRowsLookup = gridFilteredRowsLookupSelector(apiRef);
-  rowIds.forEach(rowId => {
-    if (aggregationRowsScope === 'filtered' && filteredRowsLookup[rowId] === false) {
-      return;
-    }
-
-    // If the row is a group, we want to aggregate based on its children
-    // For instance in the following tree, we want the aggregated values of A to be based on A.A, A.B.A and A.B.B but not A.B
-    // A
-    //   A.A
-    //   A.B
-    //     A.B.A
-    //     A.B.B
-    const rowNode = gridRowNodeSelector(apiRef, rowId);
-    if (rowNode.type === 'group') {
-      return;
-    }
-    const row = apiRef.current.getRow(rowId);
-    for (let j = 0; j < aggregatedFields.length; j += 1) {
-      const aggregatedField = aggregatedFields[j];
-      const columnAggregationRules = aggregationRules[aggregatedField];
-      const aggregationFunction = columnAggregationRules.aggregationFunction;
-      const field = aggregatedField;
-      if (aggregatedValues[j] === undefined) {
-        aggregatedValues[j] = {
-          aggregatedField,
-          values: []
-        };
-      }
-      if (typeof aggregationFunction.getCellValue === 'function') {
-        aggregatedValues[j].values.push(aggregationFunction.getCellValue({
-          row
-        }));
-      } else {
-        const colDef = apiRef.current.getColumn(field);
-        aggregatedValues[j].values.push(apiRef.current.getRowValue(row, colDef));
-      }
-    }
-  });
-  for (let i = 0; i < aggregatedValues.length; i += 1) {
-    const {
-      aggregatedField,
-      values
-    } = aggregatedValues[i];
-    const aggregationFunction = aggregationRules[aggregatedField].aggregationFunction;
-    const value = aggregationFunction.apply({
-      values,
-      groupId,
-      field: aggregatedField // Added per user request in https://github.com/mui/mui-x/issues/6995#issuecomment-1327423455
-    });
-    groupAggregationLookup[aggregatedField] = {
-      position,
-      value
-    };
-  }
-  return groupAggregationLookup;
-};
-const getGroupAggregatedValueDataSource = (groupId, apiRef, aggregatedFields, position) => {
-  const groupAggregationLookup = {};
-  for (let j = 0; j < aggregatedFields.length; j += 1) {
-    const aggregatedField = aggregatedFields[j];
-    groupAggregationLookup[aggregatedField] = {
-      position,
-      value: apiRef.current.resolveGroupAggregation?.(groupId, aggregatedField) ?? ''
-    };
-  }
-  return groupAggregationLookup;
-};
-export const createAggregationLookup = ({
-  apiRef,
-  aggregationFunctions,
-  aggregationRowsScope,
-  getAggregationPosition,
-  isDataSource
-}) => {
-  const aggregationRules = getAggregationRules(gridColumnLookupSelector(apiRef), gridAggregationModelSelector(apiRef), aggregationFunctions, isDataSource);
-  const aggregatedFields = Object.keys(aggregationRules);
-  if (aggregatedFields.length === 0) {
-    return {};
-  }
-  const aggregationLookup = {};
-  const rowTree = gridRowTreeSelector(apiRef);
-  const createGroupAggregationLookup = groupNode => {
-    for (let i = 0; i < groupNode.children.length; i += 1) {
-      const childId = groupNode.children[i];
-      const childNode = rowTree[childId];
-      if (childNode.type === 'group') {
-        createGroupAggregationLookup(childNode);
-      }
-    }
-    const position = getAggregationPosition(groupNode);
-    if (position !== null) {
-      if (isDataSource) {
-        aggregationLookup[groupNode.id] = getGroupAggregatedValueDataSource(groupNode.id, apiRef, aggregatedFields, position);
-      } else if (groupNode.children.length) {
-        aggregationLookup[groupNode.id] = getGroupAggregatedValue(groupNode.id, apiRef, aggregationRowsScope, aggregatedFields, aggregationRules, position);
-      }
-    }
-  };
-  createGroupAggregationLookup(rowTree[GRID_ROOT_GROUP_ID]);
-  return aggregationLookup;
-};

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

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

@@ -1,93 +0,0 @@
-import { isNumber } from '@mui/x-data-grid-pro/internals';
-const sumAgg = {
-  apply: ({
-    values
-  }) => {
-    let sum = 0;
-    for (let i = 0; i < values.length; i += 1) {
-      const value = values[i];
-      if (isNumber(value)) {
-        sum += value;
-      }
-    }
-    return sum;
-  },
-  columnTypes: ['number']
-};
-const avgAgg = {
-  apply: ({
-    values
-  }) => {
-    if (values.length === 0) {
-      return null;
-    }
-    let sum = 0;
-    let valuesCount = 0;
-    for (let i = 0; i < values.length; i += 1) {
-      const value = values[i];
-      if (isNumber(value)) {
-        valuesCount += 1;
-        sum += value;
-      }
-    }
-    return sum / valuesCount;
-  },
-  columnTypes: ['number']
-};
-const minAgg = {
-  apply: ({
-    values
-  }) => {
-    if (values.length === 0) {
-      return null;
-    }
-    let min = +Infinity;
-    for (let i = 0; i < values.length; i += 1) {
-      const value = values[i];
-      if (value != null && value < min) {
-        min = value;
-      }
-    }
-    return min;
-  },
-  columnTypes: ['number', 'date', 'dateTime']
-};
-const maxAgg = {
-  apply: ({
-    values
-  }) => {
-    if (values.length === 0) {
-      return null;
-    }
-    let max = -Infinity;
-    for (let i = 0; i < values.length; i += 1) {
-      const value = values[i];
-      if (value != null && value > max) {
-        max = value;
-      }
-    }
-    return max;
-  },
-  columnTypes: ['number', 'date', 'dateTime']
-};
-const sizeAgg = {
-  apply: ({
-    values
-  }) => {
-    return values.filter(value => typeof value !== 'undefined').length;
-  },
-  valueFormatter: value => {
-    if (value == null || !isNumber(value)) {
-      return value;
-    }
-    return value.toLocaleString();
-  },
-  hasCellUnit: false
-};
-export const GRID_AGGREGATION_FUNCTIONS = {
-  sum: sumAgg,
-  avg: avgAgg,
-  min: minAgg,
-  max: maxAgg,
-  size: sizeAgg
-};

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;