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

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, useGridApiEventHandler, 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]);
-  useGridApiEventHandler(apiRef, 'aggregationModelChange', checkAggregationRulesDiff);
-  useGridApiEventHandler(apiRef, 'columnsChange', checkAggregationRulesDiff);
-  useGridApiEventHandler(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);
-};

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

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

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

@@ -1,215 +0,0 @@
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-import _extends from "@babel/runtime/helpers/esm/extends";
-const _excluded = ["aggregationWrappedProperties"];
-import * as React from 'react';
-import { gridRowIdSelector, gridRowNodeSelector } from '@mui/x-data-grid-pro';
-import { gridAggregationLookupSelector } from "./gridAggregationSelectors.js";
-import { GridFooterCell } from "../../../components/GridFooterCell.js";
-import { GridAggregationHeader } from "../../../components/GridAggregationHeader.js";
-import { jsx as _jsx } from "react/jsx-runtime";
-const getAggregationValueWrappedValueGetter = ({
-  value: valueGetter,
-  getCellAggregationResult
-}) => {
-  const wrappedValueGetter = (value, row, column, apiRef) => {
-    const rowId = gridRowIdSelector(apiRef, row);
-    const cellAggregationResult = rowId ? getCellAggregationResult(rowId, column.field) : null;
-    if (cellAggregationResult != null) {
-      return cellAggregationResult?.value ?? null;
-    }
-    if (valueGetter) {
-      return valueGetter(value, row, column, apiRef);
-    }
-    return row[column.field];
-  };
-  return wrappedValueGetter;
-};
-const getAggregationValueWrappedValueFormatter = ({
-  value: valueFormatter,
-  aggregationRule,
-  getCellAggregationResult
-}) => {
-  // If neither the inline aggregation function nor the footer aggregation function have a custom value formatter,
-  // Then we don't wrap the column value formatter
-  if (!aggregationRule.aggregationFunction.valueFormatter) {
-    return valueFormatter;
-  }
-  const wrappedValueFormatter = (value, row, column, apiRef) => {
-    const rowId = gridRowIdSelector(apiRef, row);
-    if (rowId != null) {
-      const cellAggregationResult = getCellAggregationResult(rowId, column.field);
-      if (cellAggregationResult != null) {
-        return aggregationRule.aggregationFunction.valueFormatter?.(value, row, column, apiRef);
-      }
-    }
-    if (valueFormatter) {
-      return valueFormatter(value, row, column, apiRef);
-    }
-    return value;
-  };
-  return wrappedValueFormatter;
-};
-const getAggregationValueWrappedRenderCell = ({
-  value: renderCell,
-  aggregationRule,
-  getCellAggregationResult
-}) => {
-  const wrappedRenderCell = params => {
-    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
-    if (cellAggregationResult != null) {
-      if (!renderCell) {
-        if (cellAggregationResult.position === 'footer') {
-          return /*#__PURE__*/_jsx(GridFooterCell, _extends({}, params));
-        }
-        return params.formattedValue;
-      }
-      const aggregationMeta = {
-        hasCellUnit: aggregationRule.aggregationFunction.hasCellUnit ?? true,
-        aggregationFunctionName: aggregationRule.aggregationFunctionName
-      };
-      return renderCell(_extends({}, params, {
-        aggregation: aggregationMeta
-      }));
-    }
-    if (!renderCell) {
-      return params.formattedValue;
-    }
-    return renderCell(params);
-  };
-  return wrappedRenderCell;
-};
-
-/**
- * Skips the filtering for aggregated rows
- */
-const getWrappedFilterOperators = ({
-  value: filterOperators,
-  apiRef,
-  getCellAggregationResult
-}) => filterOperators.map(operator => {
-  const baseGetApplyFilterFn = operator.getApplyFilterFn;
-  const getApplyFilterFn = (filterItem, colDef) => {
-    const filterFn = baseGetApplyFilterFn(filterItem, colDef);
-    if (!filterFn) {
-      return null;
-    }
-    return (value, row, column, api) => {
-      const rowId = gridRowIdSelector(apiRef, row);
-      if (getCellAggregationResult(rowId, column.field) != null) {
-        return true;
-      }
-      return filterFn(value, row, column, api);
-    };
-  };
-  return _extends({}, operator, {
-    getApplyFilterFn
-  });
-});
-
-/**
- * Add the aggregation method around the header name
- */
-const getWrappedRenderHeader = ({
-  value: renderHeader,
-  aggregationRule
-}) => {
-  const wrappedRenderHeader = params => {
-    return /*#__PURE__*/_jsx(GridAggregationHeader, _extends({}, params, {
-      aggregation: {
-        aggregationRule
-      },
-      renderHeader: renderHeader
-    }));
-  };
-  return wrappedRenderHeader;
-};
-
-/**
- * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
- */
-export const wrapColumnWithAggregationValue = ({
-  column,
-  apiRef,
-  aggregationRule
-}) => {
-  const getCellAggregationResult = (id, field) => {
-    let cellAggregationPosition = null;
-    const rowNode = gridRowNodeSelector(apiRef, id);
-    if (rowNode.type === 'group') {
-      cellAggregationPosition = 'inline';
-    } else if (id.toString().startsWith('auto-generated-group-footer-')) {
-      cellAggregationPosition = 'footer';
-    }
-    if (cellAggregationPosition == null) {
-      return null;
-    }
-
-    // TODO: Add custom root id
-    const groupId = cellAggregationPosition === 'inline' ? id : rowNode.parent ?? '';
-    const aggregationResult = gridAggregationLookupSelector(apiRef)?.[groupId]?.[field];
-    if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
-      return null;
-    }
-    return aggregationResult;
-  };
-  let didWrapSomeProperty = false;
-  const wrappedColumn = _extends({}, column, {
-    aggregationWrappedProperties: []
-  });
-  const wrapColumnProperty = (property, wrapper) => {
-    const originalValue = column[property];
-    const wrappedProperty = wrapper({
-      apiRef,
-      value: originalValue,
-      colDef: column,
-      aggregationRule,
-      getCellAggregationResult
-    });
-    if (wrappedProperty !== originalValue) {
-      didWrapSomeProperty = true;
-      wrappedColumn[property] = wrappedProperty;
-      wrappedColumn.aggregationWrappedProperties.push({
-        name: property,
-        originalValue,
-        wrappedValue: wrappedProperty
-      });
-    }
-  };
-  wrapColumnProperty('valueGetter', getAggregationValueWrappedValueGetter);
-  wrapColumnProperty('valueFormatter', getAggregationValueWrappedValueFormatter);
-  wrapColumnProperty('renderCell', getAggregationValueWrappedRenderCell);
-  wrapColumnProperty('renderHeader', getWrappedRenderHeader);
-  wrapColumnProperty('filterOperators', getWrappedFilterOperators);
-  if (!didWrapSomeProperty) {
-    return column;
-  }
-  return wrappedColumn;
-};
-
-/**
- * Remove the aggregation wrappers around the wrappable properties of the column.
- */
-export const unwrapColumnFromAggregation = ({
-  column
-}) => {
-  if (!column.aggregationWrappedProperties) {
-    return column;
-  }
-  const _ref = column,
-    {
-      aggregationWrappedProperties
-    } = _ref,
-    unwrappedColumn = _objectWithoutPropertiesLoose(_ref, _excluded);
-  aggregationWrappedProperties.forEach(({
-    name,
-    originalValue,
-    wrappedValue
-  }) => {
-    // The value changed since we wrapped it
-    if (wrappedValue !== unwrappedColumn[name]) {
-      return;
-    }
-    unwrappedColumn[name] = originalValue;
-  });
-  return unwrappedColumn;
-};

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

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

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

@@ -1 +0,0 @@
-export {};

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

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

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

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

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

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

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

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

package/modern/hooks/features/cellSelection/useGridCellSelection.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 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;