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

package/modern/hooks/features/rows/useGridRowsPreProcessors.d.ts

@@ -1,3 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
-export declare const useGridRowsPreProcessors: (apiRef: RefObject<GridPrivateApiCommunity>) => void;

package/modern/hooks/features/rows/useGridRowsPreProcessors.js

@@ -1,81 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { GRID_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from "../../core/strategyProcessing/index.js";
-import { buildRootGroup, GRID_ROOT_GROUP_ID } from "./gridRowsUtils.js";
-const createFlatRowTree = rows => {
-  const tree = {
-    [GRID_ROOT_GROUP_ID]: _extends({}, buildRootGroup(), {
-      children: rows
-    })
-  };
-  for (let i = 0; i < rows.length; i += 1) {
-    const rowId = rows[i];
-    tree[rowId] = {
-      id: rowId,
-      depth: 0,
-      parent: GRID_ROOT_GROUP_ID,
-      type: 'leaf',
-      groupingKey: null
-    };
-  }
-  return {
-    groupingName: GRID_DEFAULT_STRATEGY,
-    tree,
-    treeDepths: {
-      0: rows.length
-    },
-    dataRowIds: rows
-  };
-};
-const updateFlatRowTree = ({
-  previousTree,
-  actions
-}) => {
-  const tree = _extends({}, previousTree);
-  const idsToRemoveFromRootGroup = {};
-  for (let i = 0; i < actions.remove.length; i += 1) {
-    const idToDelete = actions.remove[i];
-    idsToRemoveFromRootGroup[idToDelete] = true;
-    delete tree[idToDelete];
-  }
-  for (let i = 0; i < actions.insert.length; i += 1) {
-    const idToInsert = actions.insert[i];
-    tree[idToInsert] = {
-      id: idToInsert,
-      depth: 0,
-      parent: GRID_ROOT_GROUP_ID,
-      type: 'leaf',
-      groupingKey: null
-    };
-  }
-
-  // TODO rows v6: Support row unpinning
-
-  const rootGroup = tree[GRID_ROOT_GROUP_ID];
-  let rootGroupChildren = [...rootGroup.children, ...actions.insert];
-  if (Object.values(idsToRemoveFromRootGroup).length) {
-    rootGroupChildren = rootGroupChildren.filter(id => !idsToRemoveFromRootGroup[id]);
-  }
-  tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
-    children: rootGroupChildren
-  });
-  return {
-    groupingName: GRID_DEFAULT_STRATEGY,
-    tree,
-    treeDepths: {
-      0: rootGroupChildren.length
-    },
-    dataRowIds: rootGroupChildren
-  };
-};
-const flatRowTreeCreationMethod = params => {
-  if (params.updates.type === 'full') {
-    return createFlatRowTree(params.updates.rows);
-  }
-  return updateFlatRowTree({
-    previousTree: params.previousTree,
-    actions: params.updates.actions
-  });
-};
-export const useGridRowsPreProcessors = apiRef => {
-  useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'rowTreeCreation', flatRowTreeCreationMethod);
-};

package/modern/hooks/features/scroll/useGridScroll.d.ts

@@ -1,12 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
-import { DataGridProcessedProps } from "../../../models/props/DataGridProps.js";
-/**
- * @requires useGridPagination (state) - can be after, async only
- * @requires useGridColumns (state) - can be after, async only
- * @requires useGridRows (state) - can be after, async only
- * @requires useGridRowsMeta (state) - can be after, async only
- * @requires useGridFilter (state)
- * @requires useGridColumnSpanning (method)
- */
-export declare const useGridScroll: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "pagination" | "listView">) => void;

package/modern/hooks/features/scroll/useGridScroll.js

@@ -1,134 +0,0 @@
-import * as React from 'react';
-import { useRtl } from '@mui/system/RtlProvider';
-import { useGridLogger } from "../../utils/useGridLogger.js";
-import { gridColumnPositionsSelector, gridVisibleColumnDefinitionsSelector } from "../columns/gridColumnsSelector.js";
-import { useGridSelector } from "../../utils/useGridSelector.js";
-import { gridPageSelector, gridPageSizeSelector } from "../pagination/gridPaginationSelector.js";
-import { gridRowCountSelector } from "../rows/gridRowsSelector.js";
-import { gridRowsMetaSelector } from "../rows/gridRowsMetaSelector.js";
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-import { gridExpandedSortedRowEntriesSelector } from "../filter/gridFilterSelector.js";
-import { gridDimensionsSelector } from "../dimensions/index.js";
-import { gridListColumnSelector } from "../listView/gridListViewSelectors.js";
-
-// Logic copied from https://www.w3.org/TR/wai-aria-practices/examples/listbox/js/listbox.js
-// Similar to https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView
-function scrollIntoView(dimensions) {
-  const {
-    containerSize,
-    scrollPosition,
-    elementSize,
-    elementOffset
-  } = dimensions;
-  const elementEnd = elementOffset + elementSize;
-  // Always scroll to top when cell is higher than viewport to avoid scroll jump
-  // See https://github.com/mui/mui-x/issues/4513 and https://github.com/mui/mui-x/issues/4514
-  if (elementSize > containerSize) {
-    return elementOffset;
-  }
-  if (elementEnd - containerSize > scrollPosition) {
-    return elementEnd - containerSize;
-  }
-  if (elementOffset < scrollPosition) {
-    return elementOffset;
-  }
-  return undefined;
-}
-
-/**
- * @requires useGridPagination (state) - can be after, async only
- * @requires useGridColumns (state) - can be after, async only
- * @requires useGridRows (state) - can be after, async only
- * @requires useGridRowsMeta (state) - can be after, async only
- * @requires useGridFilter (state)
- * @requires useGridColumnSpanning (method)
- */
-export const useGridScroll = (apiRef, props) => {
-  const isRtl = useRtl();
-  const logger = useGridLogger(apiRef, 'useGridScroll');
-  const colRef = apiRef.current.columnHeadersContainerRef;
-  const virtualScrollerRef = apiRef.current.virtualScrollerRef;
-  const visibleSortedRows = useGridSelector(apiRef, gridExpandedSortedRowEntriesSelector);
-  const scrollToIndexes = React.useCallback(params => {
-    const dimensions = gridDimensionsSelector(apiRef);
-    const totalRowCount = gridRowCountSelector(apiRef);
-    const visibleColumns = props.listView ? [gridListColumnSelector(apiRef)] : gridVisibleColumnDefinitionsSelector(apiRef);
-    const scrollToHeader = params.rowIndex == null;
-    if (!scrollToHeader && totalRowCount === 0 || visibleColumns.length === 0) {
-      return false;
-    }
-    logger.debug(`Scrolling to cell at row ${params.rowIndex}, col: ${params.colIndex} `);
-    let scrollCoordinates = {};
-    if (params.colIndex !== undefined) {
-      const columnPositions = gridColumnPositionsSelector(apiRef);
-      let cellWidth;
-      if (typeof params.rowIndex !== 'undefined') {
-        const rowId = visibleSortedRows[params.rowIndex]?.id;
-        const cellColSpanInfo = apiRef.current.unstable_getCellColSpanInfo(rowId, params.colIndex);
-        if (cellColSpanInfo && !cellColSpanInfo.spannedByColSpan) {
-          cellWidth = cellColSpanInfo.cellProps.width;
-        }
-      }
-      if (typeof cellWidth === 'undefined') {
-        cellWidth = visibleColumns[params.colIndex].computedWidth;
-      }
-      // When using RTL, `scrollLeft` becomes negative, so we must ensure that we only compare values.
-      scrollCoordinates.left = scrollIntoView({
-        containerSize: dimensions.viewportOuterSize.width,
-        scrollPosition: Math.abs(virtualScrollerRef.current.scrollLeft),
-        elementSize: cellWidth,
-        elementOffset: columnPositions[params.colIndex]
-      });
-    }
-    if (params.rowIndex !== undefined) {
-      const rowsMeta = gridRowsMetaSelector(apiRef);
-      const page = gridPageSelector(apiRef);
-      const pageSize = gridPageSizeSelector(apiRef);
-      const elementIndex = !props.pagination ? params.rowIndex : params.rowIndex - page * pageSize;
-      const targetOffsetHeight = rowsMeta.positions[elementIndex + 1] ? rowsMeta.positions[elementIndex + 1] - rowsMeta.positions[elementIndex] : rowsMeta.currentPageTotalHeight - rowsMeta.positions[elementIndex];
-      scrollCoordinates.top = scrollIntoView({
-        containerSize: dimensions.viewportInnerSize.height,
-        scrollPosition: virtualScrollerRef.current.scrollTop,
-        elementSize: targetOffsetHeight,
-        elementOffset: rowsMeta.positions[elementIndex]
-      });
-    }
-    scrollCoordinates = apiRef.current.unstable_applyPipeProcessors('scrollToIndexes', scrollCoordinates, params);
-    if (typeof scrollCoordinates.left !== undefined || typeof scrollCoordinates.top !== undefined) {
-      apiRef.current.scroll(scrollCoordinates);
-      return true;
-    }
-    return false;
-  }, [logger, apiRef, virtualScrollerRef, props.pagination, visibleSortedRows, props.listView]);
-  const scroll = React.useCallback(params => {
-    if (virtualScrollerRef.current && params.left !== undefined && colRef.current) {
-      const direction = isRtl ? -1 : 1;
-      colRef.current.scrollLeft = params.left;
-      virtualScrollerRef.current.scrollLeft = direction * params.left;
-      logger.debug(`Scrolling left: ${params.left}`);
-    }
-    if (virtualScrollerRef.current && params.top !== undefined) {
-      virtualScrollerRef.current.scrollTop = params.top;
-      logger.debug(`Scrolling top: ${params.top}`);
-    }
-    logger.debug(`Scrolling, updating container, and viewport`);
-  }, [virtualScrollerRef, isRtl, colRef, logger]);
-  const getScrollPosition = React.useCallback(() => {
-    if (!virtualScrollerRef?.current) {
-      return {
-        top: 0,
-        left: 0
-      };
-    }
-    return {
-      top: virtualScrollerRef.current.scrollTop,
-      left: virtualScrollerRef.current.scrollLeft
-    };
-  }, [virtualScrollerRef]);
-  const scrollApi = {
-    scroll,
-    scrollToIndexes,
-    getScrollPosition
-  };
-  useGridApiMethod(apiRef, scrollApi, 'public');
-};

package/modern/hooks/features/sorting/gridSortingSelector.d.ts

@@ -1,32 +0,0 @@
-import { GridSortDirection, GridSortModel } from "../../../models/gridSortModel.js";
-import type { GridValidRowModel, GridRowEntry, GridRowId } from '../../../models/gridRows';
-import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
-/**
- * Get the id of the rows after the sorting process.
- * @category Sorting
- */
-export declare const gridSortedRowIdsSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, import("@mui/x-data-grid").GridSortingState, GridRowId[]>;
-/**
- * Get the id and the model of the rows after the sorting process.
- * @category Sorting
- */
-export declare const gridSortedRowEntriesSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, import("@mui/x-data-grid").GridRowTreeConfig, GridRowEntry<GridValidRowModel>[]>;
-/**
- * Get the current sorting model.
- * @category Sorting
- */
-export declare const gridSortModelSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, import("@mui/x-data-grid").GridSortingState, GridSortModel>;
-export type GridSortColumnLookup = Record<string, {
-  sortDirection: GridSortDirection;
-  sortIndex?: number;
-}>;
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-export declare const gridSortColumnLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, GridSortModel, GridSortColumnLookup>;
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-export declare const gridSortedRowIndexLookupSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, GridRowId[], Record<GridRowId, number>>;

package/modern/hooks/features/sorting/gridSortingSelector.js

@@ -1,70 +0,0 @@
-import { createRootSelector, createSelector, createSelectorMemoized } from "../../../utils/createSelector.js";
-import { gridRowTreeSelector, gridRowsLookupSelector } from "../rows/gridRowsSelector.js";
-import { GRID_ID_AUTOGENERATED, isAutogeneratedRowNode } from "../rows/gridRowsUtils.js";
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-const gridSortingStateSelector = createRootSelector(state => state.sorting);
-
-/**
- * Get the id of the rows after the sorting process.
- * @category Sorting
- */
-export const gridSortedRowIdsSelector = createSelector(gridSortingStateSelector, sortingState => sortingState.sortedRows);
-
-/**
- * Get the id and the model of the rows after the sorting process.
- * @category Sorting
- */
-export const gridSortedRowEntriesSelector = createSelectorMemoized(gridSortedRowIdsSelector, gridRowsLookupSelector, gridRowTreeSelector, (sortedIds, idRowsLookup, rowTree) => sortedIds.reduce((acc, id) => {
-  const model = idRowsLookup[id];
-  if (model) {
-    acc.push({
-      id,
-      model
-    });
-  } else {
-    const rowNode = rowTree[id];
-    if (rowNode && isAutogeneratedRowNode(rowNode)) {
-      acc.push({
-        id,
-        model: {
-          [GRID_ID_AUTOGENERATED]: id
-        }
-      });
-    }
-  }
-  return acc;
-}, []));
-
-/**
- * Get the current sorting model.
- * @category Sorting
- */
-export const gridSortModelSelector = createSelector(gridSortingStateSelector, sorting => sorting.sortModel);
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-export const gridSortColumnLookupSelector = createSelectorMemoized(gridSortModelSelector, sortModel => {
-  const result = sortModel.reduce((res, sortItem, index) => {
-    res[sortItem.field] = {
-      sortDirection: sortItem.sort,
-      sortIndex: sortModel.length > 1 ? index + 1 : undefined
-    };
-    return res;
-  }, {});
-  return result;
-});
-
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-export const gridSortedRowIndexLookupSelector = createSelectorMemoized(gridSortedRowIdsSelector, sortedIds => {
-  return sortedIds.reduce((acc, id, index) => {
-    acc[id] = index;
-    return acc;
-  }, Object.create(null));
-});

package/modern/hooks/features/sorting/gridSortingState.d.ts

@@ -1,14 +0,0 @@
-import { GridRowId, GridTreeNode } from "../../../models/gridRows.js";
-import { GridSortModel } from "../../../models/gridSortModel.js";
-export interface GridSortingState {
-  sortedRows: GridRowId[];
-  sortModel: GridSortModel;
-}
-export interface GridSortingInitialState {
-  sortModel?: GridSortModel;
-}
-export type GridSortingModelApplier = (rowList: GridTreeNode[]) => GridRowId[];
-export interface GridSortingMethodParams {
-  sortRowList: GridSortingModelApplier | null;
-}
-export type GridSortingMethodValue = GridRowId[];

package/modern/hooks/features/sorting/gridSortingState.js

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

package/modern/hooks/features/sorting/gridSortingUtils.d.ts

@@ -1,18 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { GridSortingModelApplier } from "./gridSortingState.js";
-import { GridApiCommunity } from "../../../models/api/gridApiCommunity.js";
-import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
-import { GridComparatorFn, GridSortDirection, GridSortModel } from "../../../models/gridSortModel.js";
-export declare const sanitizeSortModel: (model: GridSortModel, disableMultipleColumnsSorting: boolean) => GridSortModel;
-export declare const mergeStateWithSortModel: (sortModel: GridSortModel, disableMultipleColumnsSorting: boolean) => (state: GridStateCommunity) => GridStateCommunity;
-/**
- * Generates a method to easily sort a list of rows according to the current sort model.
- * @param {GridSortModel} sortModel The model with which we want to sort the rows.
- * @param {RefObject<GridApiCommunity>} apiRef The API of the grid.
- * @returns {GridSortingModelApplier | null} A method that generates a list of sorted row ids from a list of rows according to the current sort model. If `null`, we consider that the rows should remain in the order there were provided.
- */
-export declare const buildAggregatedSortingApplier: (sortModel: GridSortModel, apiRef: RefObject<GridApiCommunity>) => GridSortingModelApplier | null;
-export declare const getNextGridSortDirection: (sortingOrder: readonly GridSortDirection[], current?: GridSortDirection) => GridSortDirection;
-export declare const gridStringOrNumberComparator: GridComparatorFn;
-export declare const gridNumberComparator: GridComparatorFn;
-export declare const gridDateComparator: GridComparatorFn;

package/modern/hooks/features/sorting/gridSortingUtils.js

@@ -1,138 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { warnOnce } from '@mui/x-internals/warning';
-import { gridRowNodeSelector } from "../rows/gridRowsSelector.js";
-export const sanitizeSortModel = (model, disableMultipleColumnsSorting) => {
-  if (disableMultipleColumnsSorting && model.length > 1) {
-    if (process.env.NODE_ENV !== 'production') {
-      warnOnce(['MUI X: The `sortModel` can only contain a single item when the `disableMultipleColumnsSorting` prop is set to `true`.', 'If you are using the community version of the Data Grid, this prop is always `true`.'], 'error');
-    }
-    return [model[0]];
-  }
-  return model;
-};
-export const mergeStateWithSortModel = (sortModel, disableMultipleColumnsSorting) => state => _extends({}, state, {
-  sorting: _extends({}, state.sorting, {
-    sortModel: sanitizeSortModel(sortModel, disableMultipleColumnsSorting)
-  })
-});
-const isDesc = direction => direction === 'desc';
-
-/**
- * Transform an item of the sorting model into a method comparing two rows.
- * @param {GridSortItem} sortItem The sort item we want to apply.
- * @param {RefObject<GridApiCommunity>} apiRef The API of the grid.
- * @returns {GridParsedSortItem | null} The parsed sort item. Returns `null` is the sort item is not valid.
- */
-const parseSortItem = (sortItem, apiRef) => {
-  const column = apiRef.current.getColumn(sortItem.field);
-  if (!column || sortItem.sort === null) {
-    return null;
-  }
-  let comparator;
-  if (column.getSortComparator) {
-    comparator = column.getSortComparator(sortItem.sort);
-  } else {
-    comparator = isDesc(sortItem.sort) ? (...args) => -1 * column.sortComparator(...args) : column.sortComparator;
-  }
-  if (!comparator) {
-    return null;
-  }
-  const getSortCellParams = id => ({
-    id,
-    field: column.field,
-    rowNode: gridRowNodeSelector(apiRef, id),
-    value: apiRef.current.getCellValue(id, column.field),
-    api: apiRef.current
-  });
-  return {
-    getSortCellParams,
-    comparator
-  };
-};
-/**
- * Compare two rows according to a list of valid sort items.
- * The `row1Params` and `row2Params` must have the same length as `parsedSortItems`,
- * and each of their index must contain the `GridSortCellParams` of the sort item with the same index.
- * @param {GridParsedSortItem[]} parsedSortItems All the sort items with which we want to compare the rows.
- * @param {GridRowAggregatedSortingParams} row1 The node and params of the 1st row for each sort item.
- * @param {GridRowAggregatedSortingParams} row2 The node and params of the 2nd row for each sort item.
- */
-const compareRows = (parsedSortItems, row1, row2) => {
-  return parsedSortItems.reduce((res, item, index) => {
-    if (res !== 0) {
-      // return the results of the first comparator which distinguish the two rows
-      return res;
-    }
-    const sortCellParams1 = row1.params[index];
-    const sortCellParams2 = row2.params[index];
-    res = item.comparator(sortCellParams1.value, sortCellParams2.value, sortCellParams1, sortCellParams2);
-    return res;
-  }, 0);
-};
-
-/**
- * Generates a method to easily sort a list of rows according to the current sort model.
- * @param {GridSortModel} sortModel The model with which we want to sort the rows.
- * @param {RefObject<GridApiCommunity>} apiRef The API of the grid.
- * @returns {GridSortingModelApplier | null} A method that generates a list of sorted row ids from a list of rows according to the current sort model. If `null`, we consider that the rows should remain in the order there were provided.
- */
-export const buildAggregatedSortingApplier = (sortModel, apiRef) => {
-  const comparatorList = sortModel.map(item => parseSortItem(item, apiRef)).filter(comparator => !!comparator);
-  if (comparatorList.length === 0) {
-    return null;
-  }
-  return rowList => rowList.map(node => ({
-    node,
-    params: comparatorList.map(el => el.getSortCellParams(node.id))
-  })).sort((a, b) => compareRows(comparatorList, a, b)).map(row => row.node.id);
-};
-export const getNextGridSortDirection = (sortingOrder, current) => {
-  const currentIdx = sortingOrder.indexOf(current);
-  if (!current || currentIdx === -1 || currentIdx + 1 === sortingOrder.length) {
-    return sortingOrder[0];
-  }
-  return sortingOrder[currentIdx + 1];
-};
-const gridNillComparator = (v1, v2) => {
-  if (v1 == null && v2 != null) {
-    return -1;
-  }
-  if (v2 == null && v1 != null) {
-    return 1;
-  }
-  if (v1 == null && v2 == null) {
-    return 0;
-  }
-  return null;
-};
-const collator = new Intl.Collator();
-export const gridStringOrNumberComparator = (value1, value2) => {
-  const nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  if (typeof value1 === 'string') {
-    return collator.compare(value1.toString(), value2.toString());
-  }
-  return value1 - value2;
-};
-export const gridNumberComparator = (value1, value2) => {
-  const nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  return Number(value1) - Number(value2);
-};
-export const gridDateComparator = (value1, value2) => {
-  const nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  if (value1 > value2) {
-    return 1;
-  }
-  if (value1 < value2) {
-    return -1;
-  }
-  return 0;
-};

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

@@ -1,4 +0,0 @@
-export { gridSortedRowIdsSelector, gridSortedRowEntriesSelector, gridSortModelSelector, gridSortColumnLookupSelector } from "./gridSortingSelector.js";
-export type { GridSortColumnLookup } from './gridSortingSelector';
-export type { GridSortingState, GridSortingInitialState } from './gridSortingState';
-export { gridDateComparator, gridNumberComparator, gridStringOrNumberComparator } from "./gridSortingUtils.js";

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

@@ -1,2 +0,0 @@
-export { gridSortedRowIdsSelector, gridSortedRowEntriesSelector, gridSortModelSelector, gridSortColumnLookupSelector } from "./gridSortingSelector.js";
-export { gridDateComparator, gridNumberComparator, gridStringOrNumberComparator } from "./gridSortingUtils.js";

package/modern/hooks/features/sorting/useGridSorting.d.ts

@@ -1,10 +0,0 @@
-import { RefObject } from '@mui/x-internals/types';
-import { DataGridProcessedProps } from "../../../models/props/DataGridProps.js";
-import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
-import { GridStateInitializer } from "../../utils/useGridInitializeState.js";
-export declare const sortingStateInitializer: GridStateInitializer<Pick<DataGridProcessedProps, 'sortModel' | 'initialState' | 'disableMultipleColumnsSorting'>>;
-/**
- * @requires useGridRows (event)
- * @requires useGridColumns (event)
- */
-export declare const useGridSorting: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "initialState" | "sortModel" | "onSortModelChange" | "sortingOrder" | "sortingMode" | "disableColumnSorting" | "disableMultipleColumnsSorting">) => void;