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

package/hooks/core/pipeProcessing/useGridPipeProcessing.js

@@ -32,7 +32,7 @@ import { useGridApiMethod } from '../../utils/useGridApiMethod';
  *   * `apiRef.current.requestPipeProcessorsApplication` is called for the given group.
  */
 export const useGridPipeProcessing = apiRef => {
-  const processorsCache = React.useRef({});
+  const cache = React.useRef({});
   const isRunning = React.useRef(false);
   const runAppliers = React.useCallback(groupCache => {
     if (isRunning.current || !groupCache) {
@@ -45,52 +45,54 @@ export const useGridPipeProcessing = apiRef => {
     isRunning.current = false;
   }, []);
   const registerPipeProcessor = React.useCallback((group, id, processor) => {
-    if (!processorsCache.current[group]) {
-      processorsCache.current[group] = {
+    if (!cache.current[group]) {
+      cache.current[group] = {
         processors: new Map(),
+        processorsAsArray: [],
         appliers: {}
       };
     }
-    const groupCache = processorsCache.current[group];
+    const groupCache = cache.current[group];
     const oldProcessor = groupCache.processors.get(id);
     if (oldProcessor !== processor) {
       groupCache.processors.set(id, processor);
+      groupCache.processorsAsArray = Array.from(cache.current[group].processors.values());
       runAppliers(groupCache);
     }
     return () => {
-      processorsCache.current[group].processors.set(id, null);
+      cache.current[group].processors.delete(id);
+      cache.current[group].processorsAsArray = Array.from(cache.current[group].processors.values());
     };
   }, [runAppliers]);
   const registerPipeApplier = React.useCallback((group, id, applier) => {
-    if (!processorsCache.current[group]) {
-      processorsCache.current[group] = {
+    if (!cache.current[group]) {
+      cache.current[group] = {
         processors: new Map(),
+        processorsAsArray: [],
         appliers: {}
       };
     }
-    processorsCache.current[group].appliers[id] = applier;
+    cache.current[group].appliers[id] = applier;
     return () => {
-      const _appliers = processorsCache.current[group].appliers,
+      const _appliers = cache.current[group].appliers,
         otherAppliers = _objectWithoutPropertiesLoose(_appliers, [id].map(_toPropertyKey));
-      processorsCache.current[group].appliers = otherAppliers;
+      cache.current[group].appliers = otherAppliers;
     };
   }, []);
   const requestPipeProcessorsApplication = React.useCallback(group => {
-    const groupCache = processorsCache.current[group];
-    runAppliers(groupCache);
+    runAppliers(cache.current[group]);
   }, [runAppliers]);
   const applyPipeProcessors = React.useCallback((...args) => {
     const [group, value, context] = args;
-    if (!processorsCache.current[group]) {
+    if (!cache.current[group]) {
       return value;
     }
-    const preProcessors = Array.from(processorsCache.current[group].processors.values());
-    return preProcessors.reduce((acc, preProcessor) => {
-      if (!preProcessor) {
-        return acc;
-      }
-      return preProcessor(acc, context);
-    }, value);
+    const processors = cache.current[group].processorsAsArray;
+    let result = value;
+    for (let i = 0; i < processors.length; i += 1) {
+      result = processors[i](result, context);
+    }
+    return result;
   }, []);
   const preProcessingPrivateApi = {
     registerPipeProcessor,

package/hooks/features/columnHeaders/useGridColumnHeaders.js

@@ -1,23 +1,24 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { unstable_useForkRef as useForkRef } from '@mui/utils';
-import { styled } from '@mui/material/styles';
+import { styled, useTheme } from '@mui/material/styles';
 import { useGridSelector } from '../../utils';
 import { useGridRootProps } from '../../utils/useGridRootProps';
 import { useGridPrivateApiContext } from '../../utils/useGridPrivateApiContext';
 import { useGridApiEventHandler } from '../../utils/useGridApiEventHandler';
 import { GridColumnHeaderItem } from '../../../components/columnHeaders/GridColumnHeaderItem';
 import { gridDimensionsSelector } from '../dimensions';
-import { gridOffsetsSelector, gridRenderContextColumnsSelector, gridVirtualizationColumnEnabledSelector } from '../virtualization';
+import { gridRenderContextColumnsSelector, gridVirtualizationColumnEnabledSelector } from '../virtualization';
+import { computeOffsetLeft } from '../virtualization/useGridVirtualScroller';
 import { GridColumnGroupHeader } from '../../../components/columnHeaders/GridColumnGroupHeader';
-import { GridPinnedColumnPosition, gridVisiblePinnedColumnDefinitionsSelector } from '../columns';
+import { GridPinnedColumnPosition, gridColumnPositionsSelector, gridVisiblePinnedColumnDefinitionsSelector } from '../columns';
 import { GridScrollbarFillerCell as ScrollbarFiller } from '../../../components/GridScrollbarFillerCell';
 import { gridClasses } from '../../../constants/gridClasses';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 const SpaceFiller = styled('div')({
   /* GridRootStyles conflict */
-  '&&': {
+  '&&&': {
     padding: 0,
     width: 'calc(var(--DataGrid-width) - var(--DataGrid-columnsTotalWidth))'
   }
@@ -49,14 +50,16 @@ export const useGridColumnHeaders = props => {
   const [dragCol, setDragCol] = React.useState('');
   const [resizeCol, setResizeCol] = React.useState('');
   const apiRef = useGridPrivateApiContext();
+  const theme = useTheme();
   const rootProps = useGridRootProps();
   const hasVirtualization = useGridSelector(apiRef, gridVirtualizationColumnEnabledSelector);
   const innerRef = React.useRef(null);
   const handleInnerRef = useForkRef(innerRefProp, innerRef);
   const dimensions = useGridSelector(apiRef, gridDimensionsSelector);
-  const offsets = useGridSelector(apiRef, gridOffsetsSelector);
+  const columnPositions = useGridSelector(apiRef, gridColumnPositionsSelector);
   const renderContext = useGridSelector(apiRef, gridRenderContextColumnsSelector);
-  const visiblePinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);
+  const pinnedColumns = useGridSelector(apiRef, gridVisiblePinnedColumnDefinitionsSelector);
+  const offsetLeft = computeOffsetLeft(columnPositions, renderContext, theme.direction, pinnedColumns.left.length);
   React.useEffect(() => {
     apiRef.current.columnHeadersContainerElementRef.current.scrollLeft = 0;
   }, [apiRef]);
@@ -88,8 +91,8 @@ export const useGridColumnHeaders = props => {
   const getFillers = (params, children, leftOverflow, borderTop = false) => {
     const isPinnedRight = (params == null ? void 0 : params.position) === GridPinnedColumnPosition.RIGHT;
     const isNotPinned = (params == null ? void 0 : params.position) === undefined;
-    const hasScrollbarFiller = visiblePinnedColumns.right.length > 0 && isPinnedRight || visiblePinnedColumns.right.length === 0 && isNotPinned;
-    const leftOffsetWidth = offsets.left - leftOverflow;
+    const hasScrollbarFiller = pinnedColumns.right.length > 0 && isPinnedRight || pinnedColumns.right.length === 0 && isNotPinned;
+    const leftOffsetWidth = offsetLeft - leftOverflow;
     return /*#__PURE__*/_jsxs(React.Fragment, {
       children: [isNotPinned && /*#__PURE__*/_jsx("div", {
         role: "presentation",

package/hooks/features/columns/gridColumnsSelector.d.ts

@@ -69,3 +69,9 @@ export declare const gridFilterableColumnDefinitionsSelector: import("../../../u
  * @category Columns
  */
 export declare const gridFilterableColumnLookupSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, GridColumnLookup>;
+/**
+ * Checks if some column has a colSpan field.
+ * @category Columns
+ * @ignore - Do not document
+ */
+export declare const gridHasColSpanSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, boolean>;

package/hooks/features/columns/gridColumnsSelector.js

@@ -135,4 +135,11 @@ export const gridFilterableColumnLookupSelector = createSelectorMemoized(gridCol
     acc[col.field] = col;
   }
   return acc;
-}, {}));
+}, {}));
+
+/**
+ * Checks if some column has a colSpan field.
+ * @category Columns
+ * @ignore - Do not document
+ */
+export const gridHasColSpanSelector = createSelectorMemoized(gridColumnDefinitionsSelector, columns => columns.some(column => column.colSpan !== undefined));

package/hooks/features/columns/useGridColumns.js

@@ -43,9 +43,11 @@ export function useGridColumns(apiRef, props) {
     changeEvent: 'columnVisibilityModelChange'
   });
   const setGridColumnsState = React.useCallback(columnsState => {
+    var _apiRef$current$updat, _apiRef$current;
     logger.debug('Updating columns state.');
     apiRef.current.setState(mergeColumnsState(columnsState));
     apiRef.current.publishEvent('columnsChange', columnsState.orderedFields);
+    (_apiRef$current$updat = (_apiRef$current = apiRef.current).updateRenderContext) == null || _apiRef$current$updat.call(_apiRef$current);
     apiRef.current.forceUpdate();
   }, [logger, apiRef]);
 
@@ -66,6 +68,7 @@ export function useGridColumns(apiRef, props) {
   const setColumnVisibilityModel = React.useCallback(model => {
     const currentModel = gridColumnVisibilityModelSelector(apiRef);
     if (currentModel !== model) {
+      var _apiRef$current$updat2, _apiRef$current2;
       apiRef.current.setState(state => _extends({}, state, {
         columns: createColumnsState({
           apiRef,
@@ -75,6 +78,7 @@ export function useGridColumns(apiRef, props) {
           keepOnlyColumnsToUpsert: false
         })
       }));
+      (_apiRef$current$updat2 = (_apiRef$current2 = apiRef.current).updateRenderContext) == null || _apiRef$current$updat2.call(_apiRef$current2);
       apiRef.current.forceUpdate();
     }
   }, [apiRef]);

package/hooks/features/dimensions/useGridDimensions.js

@@ -229,6 +229,7 @@ export function useGridDimensions(apiRef, props) {
     set('--DataGrid-headersTotalHeight', `${dimensions.headersTotalHeight}px`);
     set('--DataGrid-topContainerHeight', `${dimensions.topContainerHeight}px`);
     set('--DataGrid-bottomContainerHeight', `${dimensions.bottomContainerHeight}px`);
+    set('--height', `${dimensions.rowHeight}px`);
   }, [root, dimensions]);
   const isFirstSizing = React.useRef(true);
   const handleResize = React.useCallback(size => {

package/hooks/features/editing/useGridRowEditing.js

@@ -21,7 +21,7 @@ export const useGridRowEditing = (apiRef, props) => {
   const [rowModesModel, setRowModesModel] = React.useState({});
   const rowModesModelRef = React.useRef(rowModesModel);
   const prevRowModesModel = React.useRef({});
-  const focusTimeout = React.useRef(null);
+  const focusTimeout = React.useRef();
   const nextFocusedCell = React.useRef(null);
   const {
     processRowUpdate,
@@ -77,7 +77,6 @@ export const useGridRowEditing = (apiRef, props) => {
     nextFocusedCell.current = null;
     focusTimeout.current = setTimeout(() => {
       var _nextFocusedCell$curr;
-      focusTimeout.current = null;
       if (((_nextFocusedCell$curr = nextFocusedCell.current) == null ? void 0 : _nextFocusedCell$curr.id) !== params.id) {
         // The row might have been deleted during the click
         if (!apiRef.current.getRow(params.id)) {

package/hooks/features/filter/useGridFilter.js

@@ -107,7 +107,7 @@ export const useGridFilter = (apiRef, props) => {
     const filterModel = gridFilterModelSelector(apiRef);
     const existingItems = [...filterModel.items];
     items.forEach(item => {
-      const itemIndex = items.findIndex(filterItem => filterItem.id === item.id);
+      const itemIndex = existingItems.findIndex(filterItem => filterItem.id === item.id);
       if (itemIndex === -1) {
         existingItems.push(item);
       } else {
@@ -115,7 +115,7 @@ export const useGridFilter = (apiRef, props) => {
       }
     });
     apiRef.current.setFilterModel(_extends({}, filterModel, {
-      items
+      items: existingItems
     }), 'upsertFilterItems');
   }, [apiRef]);
   const deleteFilterItem = React.useCallback(itemToDelete => {

package/hooks/features/rows/useGridParamsApi.js

@@ -31,12 +31,13 @@ export function useGridParamsApi(apiRef) {
   }, [apiRef]);
   const getCellParams = React.useCallback((id, field) => {
     const colDef = apiRef.current.getColumn(field);
-    const value = apiRef.current.getCellValue(id, field);
     const row = apiRef.current.getRow(id);
     const rowNode = apiRef.current.getRowNode(id);
     if (!row || !rowNode) {
       throw new MissingRowIdError(`No row with id #${id} found`);
     }
+    const rawValue = row[field];
+    const value = colDef != null && colDef.valueGetter ? colDef.valueGetter(rawValue, row, colDef, apiRef) : rawValue;
     const cellFocus = gridFocusCellSelector(apiRef);
     const cellTabIndex = gridTabIndexCellSelector(apiRef);
     const params = {
@@ -60,19 +61,14 @@ export function useGridParamsApi(apiRef) {
   }, [apiRef]);
   const getCellValue = React.useCallback((id, field) => {
     const colDef = apiRef.current.getColumn(field);
-    if (!colDef || !colDef.valueGetter) {
-      const rowModel = apiRef.current.getRow(id);
-      if (!rowModel) {
-        throw new MissingRowIdError(`No row with id #${id} found`);
-      }
-      return rowModel[field];
-    }
     const row = apiRef.current.getRow(id);
     if (!row) {
       throw new MissingRowIdError(`No row with id #${id} found`);
     }
-    const value = row[colDef.field];
-    return colDef.valueGetter(value, row, colDef, apiRef);
+    if (!colDef || !colDef.valueGetter) {
+      return row[field];
+    }
+    return colDef.valueGetter(row[colDef.field], row, colDef, apiRef);
   }, [apiRef]);
   const getRowValue = React.useCallback((row, colDef) => {
     const field = colDef.field;

package/hooks/features/rows/useGridRows.js

@@ -266,13 +266,16 @@ export const useGridRows = (apiRef, props) => {
     const dataRowIdToIdLookup = _extends({}, gridRowsDataRowIdToIdLookupSelector(apiRef));
     const rootGroup = tree[GRID_ROOT_GROUP_ID];
     const rootGroupChildren = [...rootGroup.children];
+    const seenIds = new Set();
     for (let i = 0; i < newRows.length; i += 1) {
       const rowModel = newRows[i];
       const rowId = getRowIdFromRowModel(rowModel, props.getRowId, 'A row was provided without id when calling replaceRows().');
-      const [replacedRowId] = rootGroupChildren.splice(firstRowToRender + i, 1, rowId);
-      delete dataRowIdToModelLookup[replacedRowId];
-      delete dataRowIdToIdLookup[replacedRowId];
-      delete tree[replacedRowId];
+      const [removedRowId] = rootGroupChildren.splice(firstRowToRender + i, 1, rowId);
+      if (!seenIds.has(removedRowId)) {
+        delete dataRowIdToModelLookup[removedRowId];
+        delete dataRowIdToIdLookup[removedRowId];
+        delete tree[removedRowId];
+      }
       const rowTreeNodeConfig = {
         id: rowId,
         depth: 0,
@@ -283,6 +286,7 @@ export const useGridRows = (apiRef, props) => {
       dataRowIdToModelLookup[rowId] = rowModel;
       dataRowIdToIdLookup[rowId] = rowId;
       tree[rowId] = rowTreeNodeConfig;
+      seenIds.add(rowId);
     }
     tree[GRID_ROOT_GROUP_ID] = _extends({}, rootGroup, {
       children: rootGroupChildren

package/hooks/features/rows/useGridRowsMeta.js

@@ -107,14 +107,9 @@ export const useGridRowsMeta = (apiRef, props) => {
       } else {
         rowsHeightLookup.current[row.id].needsFirstMeasurement = false;
       }
-      const initialHeights = {};
-      /* eslint-disable-next-line no-restricted-syntax */
-      for (const key in sizes) {
-        if (/^base[A-Z]/.test(key)) {
-          initialHeights[key] = sizes[key];
-        }
-      }
-      initialHeights.baseCenter = baseRowHeight;
+      const initialHeights = {
+        baseCenter: baseRowHeight
+      };
       if (getRowSpacing) {
         var _spacing$top, _spacing$bottom;
         const indexRelativeToCurrentPage = apiRef.current.getRowIndexRelativeToVisibleRows(row.id);
@@ -133,19 +128,16 @@ export const useGridRowsMeta = (apiRef, props) => {
     const positions = [];
     const currentPageTotalHeight = currentPage.rows.reduce((acc, row) => {
       positions.push(acc);
-      let maximumBaseSize = 0;
       let otherSizes = 0;
       const processedSizes = calculateRowProcessedSizes(row);
       /* eslint-disable-next-line no-restricted-syntax, guard-for-in */
       for (const key in processedSizes) {
         const value = processedSizes[key];
-        if (/^base[A-Z]/.test(key)) {
-          maximumBaseSize = value > maximumBaseSize ? value : maximumBaseSize;
-        } else {
+        if (key !== 'baseCenter') {
           otherSizes += value;
         }
       }
-      return acc + maximumBaseSize + otherSizes;
+      return acc + processedSizes.baseCenter + otherSizes;
     }, 0);
     pinnedRows == null || (_pinnedRows$top = pinnedRows.top) == null || _pinnedRows$top.forEach(row => {
       calculateRowProcessedSizes(row);

package/hooks/features/sorting/gridSortingUtils.js

@@ -28,7 +28,15 @@ const parseSortItem = (sortItem, apiRef) => {
   if (!column || sortItem.sort === null) {
     return null;
   }
-  const comparator = isDesc(sortItem.sort) ? (...args) => -1 * column.sortComparator(...args) : column.sortComparator;
+  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,

package/hooks/features/sorting/useGridSorting.js

@@ -42,7 +42,7 @@ export const useGridSorting = (apiRef, props) => {
     const existingIdx = sortModel.findIndex(c => c.field === field);
     let newSortModel = [...sortModel];
     if (existingIdx > -1) {
-      if (!sortItem) {
+      if ((sortItem == null ? void 0 : sortItem.sort) == null) {
         newSortModel.splice(existingIdx, 1);
       } else {
         newSortModel.splice(existingIdx, 1, sortItem);
@@ -120,7 +120,7 @@ export const useGridSorting = (apiRef, props) => {
     const sortItem = createSortItem(column, direction);
     let sortModel;
     if (!allowMultipleSorting || props.disableMultipleColumnsSorting) {
-      sortModel = !sortItem ? [] : [sortItem];
+      sortModel = (sortItem == null ? void 0 : sortItem.sort) == null ? [] : [sortItem];
     } else {
       sortModel = upsertSortModel(column.field, sortItem);
     }

package/hooks/features/virtualization/gridVirtualizationSelectors.d.ts

@@ -21,15 +21,6 @@ export declare const gridVirtualizationColumnEnabledSelector: import("../../../u
  * @ignore - do not document.
  */
 export declare const gridRenderContextSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, GridRenderContext>;
-/**
- * Get the offsets
- * @category Virtualization
- * @ignore - do not document.
- */
-export declare const gridOffsetsSelector: import("../../../utils/createSelector").OutputSelector<GridStateCommunity, {
-    top: number;
-    left: number;
-}>;
 /**
  * Get the render context, with only columns filled in.
  * This is cached, so it can be used to only re-render when the column interval changes.

package/hooks/features/virtualization/gridVirtualizationSelectors.js

@@ -24,13 +24,6 @@ export const gridVirtualizationColumnEnabledSelector = createSelector(gridVirtua
  */
 export const gridRenderContextSelector = createSelector(gridVirtualizationSelector, state => state.renderContext);
 
-/**
- * Get the offsets
- * @category Virtualization
- * @ignore - do not document.
- */
-export const gridOffsetsSelector = createSelector(gridVirtualizationSelector, state => state.offsets);
-
 /**
  * Get the render context, with only columns filled in.
  * This is cached, so it can be used to only re-render when the column interval changes.

package/hooks/features/virtualization/useGridVirtualScroller.d.ts

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { Theme } from '@mui/material/styles';
 import { GridPinnedRowsPosition } from '../rows/gridRowsInterfaces';
 import { GridRenderContext, GridRowEntry, GridRowId } from '../../../models';
 export declare const EMPTY_DETAIL_PANELS: Readonly<Map<GridRowId, React.ReactNode>>;
@@ -9,6 +10,7 @@ export declare const useGridVirtualScroller: () => {
     getRows: (params?: {
         rows?: GridRowEntry<import("../../../models").GridValidRowModel>[] | undefined;
         position?: keyof import("../rows/gridRowsInterfaces").GridPinnedRowsState | undefined;
+        renderContext?: GridRenderContext | undefined;
     }) => React.ReactNode[];
     getContainerProps: () => {
         ref: React.RefObject<HTMLDivElement>;
@@ -39,3 +41,4 @@ export declare const useGridVirtualScroller: () => {
     };
 };
 export declare function areRenderContextsEqual(context1: GridRenderContext, context2: GridRenderContext): boolean;
+export declare function computeOffsetLeft(columnPositions: number[], renderContext: GridRenderContext, direction: Theme['direction'], pinnedLeftLength: number): number;