@mui/x-data-grid 7.0.0-beta.2 → 7.0.0-beta.4

package/legacy/hooks/features/rows/useGridRowsMeta.js

@@ -1,236 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { unstable_debounce as debounce } from '@mui/utils';
-import { useGridVisibleRows } from '../../utils/useGridVisibleRows';
-import { useGridApiMethod } from '../../utils/useGridApiMethod';
-import { useGridSelector } from '../../utils/useGridSelector';
-import { gridDensityFactorSelector } from '../density/densitySelector';
-import { gridFilterModelSelector } from '../filter/gridFilterSelector';
-import { gridPaginationSelector } from '../pagination/gridPaginationSelector';
-import { gridSortModelSelector } from '../sorting/gridSortingSelector';
-import { useGridRegisterPipeApplier } from '../../core/pipeProcessing';
-import { gridPinnedRowsSelector } from './gridRowsSelector';
-import { DATA_GRID_PROPS_DEFAULT_VALUES } from '../../../DataGrid/useDataGridProps';
-
-// TODO: I think the row heights can now be encoded as a single `size` instead of `sizes.baseXxxx`
-
-export var rowsMetaStateInitializer = function rowsMetaStateInitializer(state) {
-  return _extends({}, state, {
-    rowsMeta: {
-      currentPageTotalHeight: 0,
-      positions: []
-    }
-  });
-};
-var warnedOnceInvalidRowHeight = false;
-var getValidRowHeight = function getValidRowHeight(rowHeightProp, defaultRowHeight, warningMessage) {
-  if (typeof rowHeightProp === 'number' && rowHeightProp > 0) {
-    return rowHeightProp;
-  }
-  if (process.env.NODE_ENV !== 'production' && !warnedOnceInvalidRowHeight && typeof rowHeightProp !== 'undefined' && rowHeightProp !== null) {
-    console.warn(warningMessage);
-    warnedOnceInvalidRowHeight = true;
-  }
-  return defaultRowHeight;
-};
-var rowHeightWarning = ["MUI X: The `rowHeight` prop should be a number greater than 0.", "The default value will be used instead."].join('\n');
-var getRowHeightWarning = ["MUI X: The `getRowHeight` prop should return a number greater than 0 or 'auto'.", "The default value will be used instead."].join('\n');
-
-/**
- * @requires useGridPageSize (method)
- * @requires useGridPage (method)
- */
-export var useGridRowsMeta = function useGridRowsMeta(apiRef, props) {
-  var getRowHeightProp = props.getRowHeight,
-    getRowSpacing = props.getRowSpacing,
-    getEstimatedRowHeight = props.getEstimatedRowHeight;
-  var rowsHeightLookup = React.useRef(Object.create(null));
-
-  // Inspired by https://github.com/bvaughn/react-virtualized/blob/master/source/Grid/utils/CellSizeAndPositionManager.js
-  var lastMeasuredRowIndex = React.useRef(-1);
-  var hasRowWithAutoHeight = React.useRef(false);
-  var densityFactor = useGridSelector(apiRef, gridDensityFactorSelector);
-  var filterModel = useGridSelector(apiRef, gridFilterModelSelector);
-  var paginationState = useGridSelector(apiRef, gridPaginationSelector);
-  var sortModel = useGridSelector(apiRef, gridSortModelSelector);
-  var currentPage = useGridVisibleRows(apiRef, props);
-  var pinnedRows = useGridSelector(apiRef, gridPinnedRowsSelector);
-  var validRowHeight = getValidRowHeight(props.rowHeight, DATA_GRID_PROPS_DEFAULT_VALUES.rowHeight, rowHeightWarning);
-  var rowHeight = Math.floor(validRowHeight * densityFactor);
-  var hydrateRowsMeta = React.useCallback(function () {
-    var _pinnedRows$top, _pinnedRows$bottom;
-    hasRowWithAutoHeight.current = false;
-    var calculateRowProcessedSizes = function calculateRowProcessedSizes(row) {
-      if (!rowsHeightLookup.current[row.id]) {
-        rowsHeightLookup.current[row.id] = {
-          sizes: {
-            baseCenter: rowHeight
-          },
-          isResized: false,
-          autoHeight: false,
-          needsFirstMeasurement: true // Assume all rows will need to be measured by default
-        };
-      }
-      var _rowsHeightLookup$cur = rowsHeightLookup.current[row.id],
-        isResized = _rowsHeightLookup$cur.isResized,
-        needsFirstMeasurement = _rowsHeightLookup$cur.needsFirstMeasurement,
-        sizes = _rowsHeightLookup$cur.sizes;
-      var baseRowHeight = typeof rowHeight === 'number' && rowHeight > 0 ? rowHeight : 52;
-      var existingBaseRowHeight = sizes.baseCenter;
-      if (isResized) {
-        // Do not recalculate resized row height and use the value from the lookup
-        baseRowHeight = existingBaseRowHeight;
-      } else if (getRowHeightProp) {
-        var rowHeightFromUser = getRowHeightProp(_extends({}, row, {
-          densityFactor: densityFactor
-        }));
-        if (rowHeightFromUser === 'auto') {
-          if (needsFirstMeasurement) {
-            var estimatedRowHeight = getEstimatedRowHeight ? getEstimatedRowHeight(_extends({}, row, {
-              densityFactor: densityFactor
-            })) : rowHeight;
-
-            // If the row was not measured yet use the estimated row height
-            baseRowHeight = estimatedRowHeight != null ? estimatedRowHeight : rowHeight;
-          } else {
-            baseRowHeight = existingBaseRowHeight;
-          }
-          hasRowWithAutoHeight.current = true;
-          rowsHeightLookup.current[row.id].autoHeight = true;
-        } else {
-          // Default back to base rowHeight if getRowHeight returns invalid value.
-          baseRowHeight = getValidRowHeight(rowHeightFromUser, rowHeight, getRowHeightWarning);
-          rowsHeightLookup.current[row.id].needsFirstMeasurement = false;
-          rowsHeightLookup.current[row.id].autoHeight = false;
-        }
-      } else {
-        rowsHeightLookup.current[row.id].needsFirstMeasurement = false;
-      }
-      var initialHeights = {};
-      /* eslint-disable-next-line no-restricted-syntax */
-      for (var _key in sizes) {
-        if (/^base[A-Z]/.test(_key)) {
-          initialHeights[_key] = sizes[_key];
-        }
-      }
-      initialHeights.baseCenter = baseRowHeight;
-      if (getRowSpacing) {
-        var _spacing$top, _spacing$bottom;
-        var indexRelativeToCurrentPage = apiRef.current.getRowIndexRelativeToVisibleRows(row.id);
-        var spacing = getRowSpacing(_extends({}, row, {
-          isFirstVisible: indexRelativeToCurrentPage === 0,
-          isLastVisible: indexRelativeToCurrentPage === currentPage.rows.length - 1,
-          indexRelativeToCurrentPage: indexRelativeToCurrentPage
-        }));
-        initialHeights.spacingTop = (_spacing$top = spacing.top) != null ? _spacing$top : 0;
-        initialHeights.spacingBottom = (_spacing$bottom = spacing.bottom) != null ? _spacing$bottom : 0;
-      }
-      var processedSizes = apiRef.current.unstable_applyPipeProcessors('rowHeight', initialHeights, row);
-      rowsHeightLookup.current[row.id].sizes = processedSizes;
-      return processedSizes;
-    };
-    var positions = [];
-    var currentPageTotalHeight = currentPage.rows.reduce(function (acc, row) {
-      positions.push(acc);
-      var maximumBaseSize = 0;
-      var otherSizes = 0;
-      var processedSizes = calculateRowProcessedSizes(row);
-      /* eslint-disable-next-line no-restricted-syntax, guard-for-in */
-      for (var _key2 in processedSizes) {
-        var value = processedSizes[_key2];
-        if (/^base[A-Z]/.test(_key2)) {
-          maximumBaseSize = value > maximumBaseSize ? value : maximumBaseSize;
-        } else {
-          otherSizes += value;
-        }
-      }
-      return acc + maximumBaseSize + otherSizes;
-    }, 0);
-    pinnedRows == null || (_pinnedRows$top = pinnedRows.top) == null || _pinnedRows$top.forEach(function (row) {
-      calculateRowProcessedSizes(row);
-    });
-    pinnedRows == null || (_pinnedRows$bottom = pinnedRows.bottom) == null || _pinnedRows$bottom.forEach(function (row) {
-      calculateRowProcessedSizes(row);
-    });
-    apiRef.current.setState(function (state) {
-      return _extends({}, state, {
-        rowsMeta: {
-          currentPageTotalHeight: currentPageTotalHeight,
-          positions: positions
-        }
-      });
-    });
-    if (!hasRowWithAutoHeight.current) {
-      // No row has height=auto, so all rows are already measured
-      lastMeasuredRowIndex.current = Infinity;
-    }
-    apiRef.current.forceUpdate();
-  }, [apiRef, currentPage.rows, rowHeight, getRowHeightProp, getRowSpacing, getEstimatedRowHeight, pinnedRows, densityFactor]);
-  var getRowHeight = React.useCallback(function (rowId) {
-    var height = rowsHeightLookup.current[rowId];
-    return height ? height.sizes.baseCenter : rowHeight;
-  }, [rowHeight]);
-  var getRowInternalSizes = function getRowInternalSizes(rowId) {
-    var _rowsHeightLookup$cur2;
-    return (_rowsHeightLookup$cur2 = rowsHeightLookup.current[rowId]) == null ? void 0 : _rowsHeightLookup$cur2.sizes;
-  };
-  var setRowHeight = React.useCallback(function (id, height) {
-    rowsHeightLookup.current[id].sizes.baseCenter = height;
-    rowsHeightLookup.current[id].isResized = true;
-    rowsHeightLookup.current[id].needsFirstMeasurement = false;
-    hydrateRowsMeta();
-  }, [hydrateRowsMeta]);
-  var debouncedHydrateRowsMeta = React.useMemo(function () {
-    return debounce(hydrateRowsMeta, props.rowPositionsDebounceMs);
-  }, [hydrateRowsMeta, props.rowPositionsDebounceMs]);
-  var storeMeasuredRowHeight = React.useCallback(function (id, height) {
-    if (!rowsHeightLookup.current[id] || !rowsHeightLookup.current[id].autoHeight) {
-      return;
-    }
-
-    // Only trigger hydration if the value is different, otherwise we trigger a loop
-    var needsHydration = rowsHeightLookup.current[id].sizes.baseCenter !== height;
-    rowsHeightLookup.current[id].needsFirstMeasurement = false;
-    rowsHeightLookup.current[id].sizes.baseCenter = height;
-    if (needsHydration) {
-      debouncedHydrateRowsMeta();
-    }
-  }, [debouncedHydrateRowsMeta]);
-  var rowHasAutoHeight = React.useCallback(function (id) {
-    var _rowsHeightLookup$cur3;
-    return ((_rowsHeightLookup$cur3 = rowsHeightLookup.current[id]) == null ? void 0 : _rowsHeightLookup$cur3.autoHeight) || false;
-  }, []);
-  var getLastMeasuredRowIndex = React.useCallback(function () {
-    return lastMeasuredRowIndex.current;
-  }, []);
-  var setLastMeasuredRowIndex = React.useCallback(function (index) {
-    if (hasRowWithAutoHeight.current && index > lastMeasuredRowIndex.current) {
-      lastMeasuredRowIndex.current = index;
-    }
-  }, []);
-  var resetRowHeights = React.useCallback(function () {
-    rowsHeightLookup.current = {};
-    hydrateRowsMeta();
-  }, [hydrateRowsMeta]);
-
-  // The effect is used to build the rows meta data - currentPageTotalHeight and positions.
-  // Because of variable row height this is needed for the virtualization
-  React.useEffect(function () {
-    hydrateRowsMeta();
-  }, [rowHeight, filterModel, paginationState, sortModel, hydrateRowsMeta]);
-  useGridRegisterPipeApplier(apiRef, 'rowHeight', hydrateRowsMeta);
-  var rowsMetaApi = {
-    unstable_setLastMeasuredRowIndex: setLastMeasuredRowIndex,
-    unstable_getRowHeight: getRowHeight,
-    unstable_getRowInternalSizes: getRowInternalSizes,
-    unstable_setRowHeight: setRowHeight,
-    unstable_storeRowHeightMeasurement: storeMeasuredRowHeight,
-    resetRowHeights: resetRowHeights
-  };
-  var rowsMetaPrivateApi = {
-    getLastMeasuredRowIndex: getLastMeasuredRowIndex,
-    rowHasAutoHeight: rowHasAutoHeight
-  };
-  useGridApiMethod(apiRef, rowsMetaApi, 'public');
-  useGridApiMethod(apiRef, rowsMetaPrivateApi, 'private');
-};

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

@@ -1,82 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { GRID_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from '../../core/strategyProcessing';
-import { buildRootGroup, GRID_ROOT_GROUP_ID } from './gridRowsUtils';
-var createFlatRowTree = function createFlatRowTree(rows) {
-  var tree = _defineProperty({}, GRID_ROOT_GROUP_ID, _extends({}, buildRootGroup(), {
-    children: rows
-  }));
-  for (var i = 0; i < rows.length; i += 1) {
-    var rowId = rows[i];
-    tree[rowId] = {
-      id: rowId,
-      depth: 0,
-      parent: GRID_ROOT_GROUP_ID,
-      type: 'leaf',
-      groupingKey: null
-    };
-  }
-  return {
-    groupingName: GRID_DEFAULT_STRATEGY,
-    tree: tree,
-    treeDepths: {
-      0: rows.length
-    },
-    dataRowIds: rows
-  };
-};
-var updateFlatRowTree = function updateFlatRowTree(_ref) {
-  var previousTree = _ref.previousTree,
-    actions = _ref.actions;
-  var tree = _extends({}, previousTree);
-  var idsToRemoveFromRootGroup = {};
-  for (var i = 0; i < actions.remove.length; i += 1) {
-    var idToDelete = actions.remove[i];
-    idsToRemoveFromRootGroup[idToDelete] = true;
-    delete tree[idToDelete];
-  }
-  for (var _i = 0; _i < actions.insert.length; _i += 1) {
-    var 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
-
-  var rootGroup = tree[GRID_ROOT_GROUP_ID];
-  var rootGroupChildren = [].concat(_toConsumableArray(rootGroup.children), _toConsumableArray(actions.insert));
-  if (Object.values(idsToRemoveFromRootGroup).length) {
-    rootGroupChildren = rootGroupChildren.filter(function (id) {
-      return !idsToRemoveFromRootGroup[id];
-    });
-  }
-  tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
-    children: rootGroupChildren
-  });
-  return {
-    groupingName: GRID_DEFAULT_STRATEGY,
-    tree: tree,
-    treeDepths: {
-      0: rootGroupChildren.length
-    },
-    dataRowIds: rootGroupChildren
-  };
-};
-var flatRowTreeCreationMethod = function flatRowTreeCreationMethod(params) {
-  if (params.updates.type === 'full') {
-    return createFlatRowTree(params.updates.rows);
-  }
-  return updateFlatRowTree({
-    previousTree: params.previousTree,
-    actions: params.updates.actions
-  });
-};
-export var useGridRowsPreProcessors = function useGridRowsPreProcessors(apiRef) {
-  useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'rowTreeCreation', flatRowTreeCreationMethod);
-};

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

@@ -1,133 +0,0 @@
-import _typeof from "@babel/runtime/helpers/esm/typeof";
-import * as React from 'react';
-import { useTheme } from '@mui/material/styles';
-import { useGridLogger } from '../../utils/useGridLogger';
-import { gridColumnPositionsSelector, gridVisibleColumnDefinitionsSelector } from '../columns/gridColumnsSelector';
-import { useGridSelector } from '../../utils/useGridSelector';
-import { gridPageSelector, gridPageSizeSelector } from '../pagination/gridPaginationSelector';
-import { gridRowCountSelector } from '../rows/gridRowsSelector';
-import { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';
-import { useGridApiMethod } from '../../utils/useGridApiMethod';
-import { gridExpandedSortedRowEntriesSelector } from '../filter/gridFilterSelector';
-import { gridDimensionsSelector } from '../dimensions';
-
-// 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) {
-  var clientHeight = dimensions.clientHeight,
-    scrollTop = dimensions.scrollTop,
-    offsetHeight = dimensions.offsetHeight,
-    offsetTop = dimensions.offsetTop;
-  var elementBottom = offsetTop + offsetHeight;
-  // 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 (offsetHeight > clientHeight) {
-    return offsetTop;
-  }
-  if (elementBottom - clientHeight > scrollTop) {
-    return elementBottom - clientHeight;
-  }
-  if (offsetTop < scrollTop) {
-    return offsetTop;
-  }
-  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 var useGridScroll = function useGridScroll(apiRef, props) {
-  var theme = useTheme();
-  var logger = useGridLogger(apiRef, 'useGridScroll');
-  var colRef = apiRef.current.columnHeadersElementRef;
-  var virtualScrollerRef = apiRef.current.virtualScrollerRef;
-  var visibleSortedRows = useGridSelector(apiRef, gridExpandedSortedRowEntriesSelector);
-  var scrollToIndexes = React.useCallback(function (params) {
-    var dimensions = gridDimensionsSelector(apiRef.current.state);
-    var totalRowCount = gridRowCountSelector(apiRef);
-    var visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);
-    var scrollToHeader = params.rowIndex == null;
-    if (!scrollToHeader && totalRowCount === 0 || visibleColumns.length === 0) {
-      return false;
-    }
-    logger.debug("Scrolling to cell at row ".concat(params.rowIndex, ", col: ").concat(params.colIndex, " "));
-    var scrollCoordinates = {};
-    if (params.colIndex !== undefined) {
-      var columnPositions = gridColumnPositionsSelector(apiRef);
-      var cellWidth;
-      if (typeof params.rowIndex !== 'undefined') {
-        var _visibleSortedRows$pa;
-        var rowId = (_visibleSortedRows$pa = visibleSortedRows[params.rowIndex]) == null ? void 0 : _visibleSortedRows$pa.id;
-        var 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({
-        clientHeight: dimensions.viewportInnerSize.width,
-        scrollTop: Math.abs(virtualScrollerRef.current.scrollLeft),
-        offsetHeight: cellWidth,
-        offsetTop: columnPositions[params.colIndex]
-      });
-    }
-    if (params.rowIndex !== undefined) {
-      var rowsMeta = gridRowsMetaSelector(apiRef.current.state);
-      var page = gridPageSelector(apiRef);
-      var pageSize = gridPageSizeSelector(apiRef);
-      var elementIndex = !props.pagination ? params.rowIndex : params.rowIndex - page * pageSize;
-      var targetOffsetHeight = rowsMeta.positions[elementIndex + 1] ? rowsMeta.positions[elementIndex + 1] - rowsMeta.positions[elementIndex] : rowsMeta.currentPageTotalHeight - rowsMeta.positions[elementIndex];
-      scrollCoordinates.top = scrollIntoView({
-        clientHeight: dimensions.viewportInnerSize.height,
-        scrollTop: virtualScrollerRef.current.scrollTop,
-        offsetHeight: targetOffsetHeight,
-        offsetTop: 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]);
-  var scroll = React.useCallback(function (params) {
-    if (virtualScrollerRef.current && params.left !== undefined && colRef.current) {
-      var direction = theme.direction === 'rtl' ? -1 : 1;
-      colRef.current.scrollLeft = params.left;
-      virtualScrollerRef.current.scrollLeft = direction * params.left;
-      logger.debug("Scrolling left: ".concat(params.left));
-    }
-    if (virtualScrollerRef.current && params.top !== undefined) {
-      virtualScrollerRef.current.scrollTop = params.top;
-      logger.debug("Scrolling top: ".concat(params.top));
-    }
-    logger.debug("Scrolling, updating container, and viewport");
-  }, [virtualScrollerRef, theme.direction, colRef, logger]);
-  var getScrollPosition = React.useCallback(function () {
-    if (!(virtualScrollerRef != null && virtualScrollerRef.current)) {
-      return {
-        top: 0,
-        left: 0
-      };
-    }
-    return {
-      top: virtualScrollerRef.current.scrollTop,
-      left: virtualScrollerRef.current.scrollLeft
-    };
-  }, [virtualScrollerRef]);
-  var scrollApi = {
-    scroll: scroll,
-    scrollToIndexes: scrollToIndexes,
-    getScrollPosition: getScrollPosition
-  };
-  useGridApiMethod(apiRef, scrollApi, 'public');
-};

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

@@ -1,56 +0,0 @@
-import { createSelector, createSelectorMemoized } from '../../../utils/createSelector';
-import { gridRowsLookupSelector } from '../rows/gridRowsSelector';
-
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-var gridSortingStateSelector = function gridSortingStateSelector(state) {
-  return state.sorting;
-};
-
-/**
- * Get the id of the rows after the sorting process.
- * @category Sorting
- */
-export var gridSortedRowIdsSelector = createSelector(gridSortingStateSelector, function (sortingState) {
-  return sortingState.sortedRows;
-});
-
-/**
- * Get the id and the model of the rows after the sorting process.
- * @category Sorting
- */
-export var gridSortedRowEntriesSelector = createSelectorMemoized(gridSortedRowIdsSelector, gridRowsLookupSelector,
-// TODO rows v6: Is this the best approach ?
-function (sortedIds, idRowsLookup) {
-  return sortedIds.map(function (id) {
-    var _idRowsLookup$id;
-    return {
-      id: id,
-      model: (_idRowsLookup$id = idRowsLookup[id]) != null ? _idRowsLookup$id : {}
-    };
-  });
-});
-
-/**
- * Get the current sorting model.
- * @category Sorting
- */
-export var gridSortModelSelector = createSelector(gridSortingStateSelector, function (sorting) {
-  return sorting.sortModel;
-});
-/**
- * @category Sorting
- * @ignore - do not document.
- */
-export var gridSortColumnLookupSelector = createSelectorMemoized(gridSortModelSelector, function (sortModel) {
-  var result = sortModel.reduce(function (res, sortItem, index) {
-    res[sortItem.field] = {
-      sortDirection: sortItem.sort,
-      sortIndex: sortModel.length > 1 ? index + 1 : undefined
-    };
-    return res;
-  }, {});
-  return result;
-});

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

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

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

@@ -1,154 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { buildWarning } from '../../../utils/warning';
-var sortModelDisableMultiColumnsSortingWarning = buildWarning(['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 `DataGrid`, this prop is always `true`.'], 'error');
-export var sanitizeSortModel = function sanitizeSortModel(model, disableMultipleColumnsSorting) {
-  if (disableMultipleColumnsSorting && model.length > 1) {
-    if (process.env.NODE_ENV !== 'production') {
-      sortModelDisableMultiColumnsSortingWarning();
-    }
-    return [model[0]];
-  }
-  return model;
-};
-export var mergeStateWithSortModel = function mergeStateWithSortModel(sortModel, disableMultipleColumnsSorting) {
-  return function (state) {
-    return _extends({}, state, {
-      sorting: _extends({}, state.sorting, {
-        sortModel: sanitizeSortModel(sortModel, disableMultipleColumnsSorting)
-      })
-    });
-  };
-};
-var isDesc = function isDesc(direction) {
-  return 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 {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
- * @returns {GridParsedSortItem | null} The parsed sort item. Returns `null` is the sort item is not valid.
- */
-var parseSortItem = function parseSortItem(sortItem, apiRef) {
-  var column = apiRef.current.getColumn(sortItem.field);
-  if (!column || sortItem.sort === null) {
-    return null;
-  }
-  var comparator = isDesc(sortItem.sort) ? function () {
-    return -1 * column.sortComparator.apply(column, arguments);
-  } : column.sortComparator;
-  var getSortCellParams = function getSortCellParams(id) {
-    return {
-      id: id,
-      field: column.field,
-      rowNode: apiRef.current.getRowNode(id),
-      value: apiRef.current.getCellValue(id, column.field),
-      api: apiRef.current
-    };
-  };
-  return {
-    getSortCellParams: getSortCellParams,
-    comparator: 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.
- */
-var compareRows = function compareRows(parsedSortItems, row1, row2) {
-  return parsedSortItems.reduce(function (res, item, index) {
-    if (res !== 0) {
-      // return the results of the first comparator which distinguish the two rows
-      return res;
-    }
-    var sortCellParams1 = row1.params[index];
-    var 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 {React.MutableRefObject<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 var buildAggregatedSortingApplier = function buildAggregatedSortingApplier(sortModel, apiRef) {
-  var comparatorList = sortModel.map(function (item) {
-    return parseSortItem(item, apiRef);
-  }).filter(function (comparator) {
-    return !!comparator;
-  });
-  if (comparatorList.length === 0) {
-    return null;
-  }
-  return function (rowList) {
-    return rowList.map(function (node) {
-      return {
-        node: node,
-        params: comparatorList.map(function (el) {
-          return el.getSortCellParams(node.id);
-        })
-      };
-    }).sort(function (a, b) {
-      return compareRows(comparatorList, a, b);
-    }).map(function (row) {
-      return row.node.id;
-    });
-  };
-};
-export var getNextGridSortDirection = function getNextGridSortDirection(sortingOrder, current) {
-  var currentIdx = sortingOrder.indexOf(current);
-  if (!current || currentIdx === -1 || currentIdx + 1 === sortingOrder.length) {
-    return sortingOrder[0];
-  }
-  return sortingOrder[currentIdx + 1];
-};
-var gridNillComparator = function 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;
-};
-var collator = new Intl.Collator();
-export var gridStringOrNumberComparator = function gridStringOrNumberComparator(value1, value2) {
-  var nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  if (typeof value1 === 'string') {
-    return collator.compare(value1.toString(), value2.toString());
-  }
-  return value1 - value2;
-};
-export var gridNumberComparator = function gridNumberComparator(value1, value2) {
-  var nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  return Number(value1) - Number(value2);
-};
-export var gridDateComparator = function gridDateComparator(value1, value2) {
-  var nillResult = gridNillComparator(value1, value2);
-  if (nillResult !== null) {
-    return nillResult;
-  }
-  if (value1 > value2) {
-    return 1;
-  }
-  if (value1 < value2) {
-    return -1;
-  }
-  return 0;
-};

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

@@ -1,2 +0,0 @@
-export * from './gridSortingSelector';
-export { gridDateComparator, gridNumberComparator, gridStringOrNumberComparator } from './gridSortingUtils';