@mui/x-data-grid 6.9.0 → 6.9.2

package/hooks/features/filter/gridFilterUtils.js

@@ -1,5 +1,6 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
 import { GridLogicOperator } from '../../../models';
+import { GLOBAL_API_REF, isInternalFilter } from '../../../colDef/utils';
 import { getDefaultGridFilterModel } from './gridFilterState';
 import { buildWarning } from '../../../utils/warning';
 import { gridColumnFieldsSelector, gridColumnLookupSelector } from '../columns';
@@ -85,27 +86,47 @@ const getFilterCallbackFromItem = (filterItem, apiRef) => {
   if (!filterOperator) {
     throw new Error(`MUI: No filter operator found for column '${column.field}' and operator value '${newFilterItem.operator}'.`);
   }
+  const hasUserFunctionLegacy = !isInternalFilter(filterOperator.getApplyFilterFn);
+  const hasUserFunctionV7 = !isInternalFilter(filterOperator.getApplyFilterFnV7);
+  if (filterOperator.getApplyFilterFnV7 && !(hasUserFunctionLegacy && !hasUserFunctionV7)) {
+    const applyFilterOnRow = filterOperator.getApplyFilterFnV7(newFilterItem, column);
+    if (typeof applyFilterOnRow !== 'function') {
+      return null;
+    }
+    return {
+      v7: true,
+      item: newFilterItem,
+      fn: row => {
+        const value = apiRef.current.getRowValue(row, column);
+        return applyFilterOnRow(value, row, column, apiRef);
+      }
+    };
+  }
   const applyFilterOnRow = filterOperator.getApplyFilterFn(newFilterItem, column);
   if (typeof applyFilterOnRow !== 'function') {
     return null;
   }
-  const fn = rowId => {
-    const cellParams = apiRef.current.getCellParams(rowId, newFilterItem.field);
-    return applyFilterOnRow(cellParams);
-  };
   return {
-    fn,
-    item: newFilterItem
+    v7: false,
+    item: newFilterItem,
+    fn: rowId => {
+      const params = apiRef.current.getCellParams(rowId, newFilterItem.field);
+      GLOBAL_API_REF.current = apiRef;
+      const result = applyFilterOnRow(params);
+      GLOBAL_API_REF.current = null;
+      return result;
+    }
   };
 };
 
 /**
  * Generates a method to easily check if a row is matching the current filter model.
+ * @param {GridRowIdGetter | undefined} getRowId The getter for row's id.
  * @param {GridFilterModel} filterModel The model with which we want to filter the rows.
  * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
  * @returns {GridAggregatedFilterItemApplier | null} A method that checks if a row is matching the current filter model. If `null`, we consider that all the rows are matching the filters.
  */
-export const buildAggregatedFilterItemsApplier = (filterModel, apiRef) => {
+export const buildAggregatedFilterItemsApplier = (getRowId, filterModel, apiRef) => {
   const {
     items
   } = filterModel;
@@ -113,75 +134,112 @@ export const buildAggregatedFilterItemsApplier = (filterModel, apiRef) => {
   if (appliers.length === 0) {
     return null;
   }
-  return (rowId, shouldApplyFilter) => {
+  return (row, shouldApplyFilter) => {
     const resultPerItemId = {};
-    const filteredAppliers = shouldApplyFilter ? appliers.filter(applier => shouldApplyFilter(applier.item.field)) : appliers;
-    filteredAppliers.forEach(applier => {
-      resultPerItemId[applier.item.id] = applier.fn(rowId);
-    });
+    for (let i = 0; i < appliers.length; i += 1) {
+      const applier = appliers[i];
+      if (!shouldApplyFilter || shouldApplyFilter(applier.item.field)) {
+        resultPerItemId[applier.item.id] = applier.v7 ? applier.fn(row) : applier.fn(getRowId ? getRowId(row) : row.id);
+      }
+    }
     return resultPerItemId;
   };
 };
 
 /**
  * Generates a method to easily check if a row is matching the current quick filter.
- * @param {any[]} values The model with which we want to filter the rows.
+ * @param {GridRowIdGetter | undefined} getRowId The getter for row's id.
+ * @param {any[]} filterModel The model with which we want to filter the rows.
  * @param {React.MutableRefObject<GridApiCommunity>} apiRef The API of the grid.
  * @returns {GridAggregatedFilterItemApplier | null} A method that checks if a row is matching the current filter model. If `null`, we consider that all the rows are matching the filters.
  */
-export const buildAggregatedQuickFilterApplier = (filterModel, apiRef) => {
-  const {
-    quickFilterValues = []
-  } = filterModel;
+export const buildAggregatedQuickFilterApplier = (getRowId, filterModel, apiRef) => {
+  var _filterModel$quickFil, _filterModel$quickFil2;
+  const quickFilterValues = (_filterModel$quickFil = (_filterModel$quickFil2 = filterModel.quickFilterValues) == null ? void 0 : _filterModel$quickFil2.filter(Boolean)) != null ? _filterModel$quickFil : [];
   if (quickFilterValues.length === 0) {
     return null;
   }
-  const columnsFields = gridColumnFieldsSelector(apiRef);
-  const appliersPerField = {};
-  columnsFields.forEach(field => {
+  const columnFields = gridColumnFieldsSelector(apiRef);
+  const appliersPerField = [];
+  columnFields.forEach(field => {
     const column = apiRef.current.getColumn(field);
     const getApplyQuickFilterFn = column == null ? void 0 : column.getApplyQuickFilterFn;
-    if (!getApplyQuickFilterFn) {
-      return;
+    const getApplyQuickFilterFnV7 = column == null ? void 0 : column.getApplyQuickFilterFnV7;
+    const hasUserFunctionLegacy = !isInternalFilter(getApplyQuickFilterFn);
+    const hasUserFunctionV7 = !isInternalFilter(getApplyQuickFilterFnV7);
+    if (getApplyQuickFilterFnV7 && !(hasUserFunctionLegacy && !hasUserFunctionV7)) {
+      appliersPerField.push({
+        column,
+        appliers: quickFilterValues.map(value => ({
+          v7: true,
+          fn: getApplyQuickFilterFnV7(value, column, apiRef)
+        }))
+      });
+    } else if (getApplyQuickFilterFn) {
+      appliersPerField.push({
+        column,
+        appliers: quickFilterValues.map(value => ({
+          v7: false,
+          fn: getApplyQuickFilterFn(value, column, apiRef)
+        }))
+      });
     }
-    appliersPerField[field] = quickFilterValues.map(value => getApplyQuickFilterFn(value, column, apiRef));
   });
-
-  // If some value does not have an applier we ignore them
-  const sanitizedQuickFilterValues = quickFilterValues.filter((value, index) => Object.keys(appliersPerField).some(field => appliersPerField[field][index] != null));
-  if (sanitizedQuickFilterValues.length === 0) {
-    return null;
-  }
-  return (rowId, shouldApplyFilter) => {
+  return function isRowMatchingQuickFilter(row, shouldApplyFilter) {
+    const result = {};
     const usedCellParams = {};
-    const fieldsToFilter = [];
-    Object.keys(appliersPerField).forEach(field => {
-      if (!shouldApplyFilter || shouldApplyFilter(field)) {
-        usedCellParams[field] = apiRef.current.getCellParams(rowId, field);
-        fieldsToFilter.push(field);
-      }
-    });
-    const quickFilterValueResult = {};
-    sanitizedQuickFilterValues.forEach((value, index) => {
-      const isPassing = fieldsToFilter.some(field => {
-        var _appliersPerField$fie, _appliersPerField$fie2;
-        if (appliersPerField[field][index] == null) {
-          return false;
+
+    /* eslint-disable no-restricted-syntax, no-labels, no-continue */
+    outer: for (let v = 0; v < quickFilterValues.length; v += 1) {
+      const filterValue = quickFilterValues[v];
+      for (let i = 0; i < appliersPerField.length; i += 1) {
+        const {
+          column,
+          appliers
+        } = appliersPerField[i];
+        const {
+          field
+        } = column;
+        if (shouldApplyFilter && !shouldApplyFilter(field)) {
+          continue;
         }
-        return (_appliersPerField$fie = (_appliersPerField$fie2 = appliersPerField[field])[index]) == null ? void 0 : _appliersPerField$fie.call(_appliersPerField$fie2, usedCellParams[field]);
-      });
-      quickFilterValueResult[value] = isPassing;
-    });
-    return quickFilterValueResult;
+        const applier = appliers[v];
+        const value = apiRef.current.getRowValue(row, column);
+        if (applier.fn === null) {
+          continue;
+        }
+        if (applier.v7) {
+          const isMatching = applier.fn(value, row, column, apiRef);
+          if (isMatching) {
+            result[filterValue] = true;
+            continue outer;
+          }
+        } else {
+          var _usedCellParams$field;
+          const cellParams = (_usedCellParams$field = usedCellParams[field]) != null ? _usedCellParams$field : apiRef.current.getCellParams(getRowId ? getRowId(row) : row.id, field);
+          usedCellParams[field] = cellParams;
+          const isMatching = applier.fn(cellParams);
+          if (isMatching) {
+            result[filterValue] = true;
+            continue outer;
+          }
+        }
+      }
+      result[filterValue] = false;
+    }
+    /* eslint-enable no-restricted-syntax, no-labels, no-continue */
+
+    return result;
   };
 };
-export const buildAggregatedFilterApplier = (filterModel, apiRef) => {
-  const isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(filterModel, apiRef);
-  const isRowMatchingQuickFilter = buildAggregatedQuickFilterApplier(filterModel, apiRef);
-  return (rowId, shouldApplyFilter) => ({
-    passingFilterItems: isRowMatchingFilterItems && isRowMatchingFilterItems(rowId, shouldApplyFilter),
-    passingQuickFilterValues: isRowMatchingQuickFilter && isRowMatchingQuickFilter(rowId, shouldApplyFilter)
-  });
+export const buildAggregatedFilterApplier = (getRowId, filterModel, apiRef) => {
+  const isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(getRowId, filterModel, apiRef);
+  const isRowMatchingQuickFilter = buildAggregatedQuickFilterApplier(getRowId, filterModel, apiRef);
+  return function isRowMatchingFilters(row, shouldApplyFilter, result) {
+    var _isRowMatchingFilterI, _isRowMatchingQuickFi;
+    result.passingFilterItems = (_isRowMatchingFilterI = isRowMatchingFilterItems == null ? void 0 : isRowMatchingFilterItems(row, shouldApplyFilter)) != null ? _isRowMatchingFilterI : null;
+    result.passingQuickFilterValues = (_isRowMatchingQuickFi = isRowMatchingQuickFilter == null ? void 0 : isRowMatchingQuickFilter(row, shouldApplyFilter)) != null ? _isRowMatchingQuickFi : null;
+  };
 };
 const isNotNull = result => result != null;
 const filterModelItems = (cache, apiRef, items) => {
@@ -218,12 +276,12 @@ export const passFilterLogic = (allFilterItemResults, allQuickFilterResults, fil
 
   // get result for quick filter model
   if (cleanedQuickFilterResults.length > 0 && filterModel.quickFilterValues != null) {
-    var _filterModel$quickFil;
+    var _filterModel$quickFil3;
     // Return true if the item pass with one of the rows
     const quickFilterValuePredicate = value => {
       return cleanedQuickFilterResults.some(quickFilterValueResult => quickFilterValueResult[value]);
     };
-    const quickFilterLogicOperator = (_filterModel$quickFil = filterModel.quickFilterLogicOperator) != null ? _filterModel$quickFil : getDefaultGridFilterModel().quickFilterLogicOperator;
+    const quickFilterLogicOperator = (_filterModel$quickFil3 = filterModel.quickFilterLogicOperator) != null ? _filterModel$quickFil3 : getDefaultGridFilterModel().quickFilterLogicOperator;
     if (quickFilterLogicOperator === GridLogicOperator.And) {
       const passesAllQuickFilterValues = filterModel.quickFilterValues.every(quickFilterValuePredicate);
       if (!passesAllQuickFilterValues) {

package/hooks/features/filter/useGridFilter.d.ts

@@ -8,4 +8,4 @@ export declare const filterStateInitializer: GridStateInitializer<Pick<DataGridP
  * @requires useGridParamsApi (method)
  * @requires useGridRows (event)
  */
-export declare const useGridFilter: (apiRef: React.MutableRefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, 'initialState' | 'filterModel' | 'onFilterModelChange' | 'filterMode' | 'disableMultipleColumnsFiltering' | 'slots' | 'slotProps' | 'disableColumnFilter'>) => void;
+export declare const useGridFilter: (apiRef: React.MutableRefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, 'rows' | 'initialState' | 'filterModel' | 'getRowId' | 'onFilterModelChange' | 'filterMode' | 'disableMultipleColumnsFiltering' | 'slots' | 'slotProps' | 'disableColumnFilter'>) => void;

package/hooks/features/filter/useGridFilter.js

@@ -9,7 +9,7 @@ import { GridPreferencePanelsValue } from '../preferencesPanel/gridPreferencePan
 import { getDefaultGridFilterModel } from './gridFilterState';
 import { gridFilterModelSelector } from './gridFilterSelector';
 import { useFirstRender } from '../../utils/useFirstRender';
-import { GRID_ROOT_GROUP_ID, gridRowTreeSelector } from '../rows';
+import { gridRowsLookupSelector } from '../rows';
 import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
 import { GRID_DEFAULT_STRATEGY, useGridRegisterStrategyProcessor } from '../../core/strategyProcessing';
 import { buildAggregatedFilterApplier, sanitizeFilterModel, mergeStateWithFilterModel, cleanFilterItem, passFilterLogic } from './gridFilterUtils';
@@ -55,7 +55,7 @@ export const useGridFilter = (apiRef, props) => {
   const updateFilteredRows = React.useCallback(() => {
     apiRef.current.setState(state => {
       const filterModel = gridFilterModelSelector(state, apiRef.current.instanceId);
-      const isRowMatchingFilters = props.filterMode === 'client' ? buildAggregatedFilterApplier(filterModel, apiRef) : null;
+      const isRowMatchingFilters = props.filterMode === 'client' ? buildAggregatedFilterApplier(props.getRowId, filterModel, apiRef) : null;
       const filteringResult = apiRef.current.applyStrategyProcessor('filtering', {
         isRowMatchingFilters,
         filterModel: filterModel != null ? filterModel : getDefaultGridFilterModel()
@@ -69,7 +69,7 @@ export const useGridFilter = (apiRef, props) => {
       });
     });
     apiRef.current.publishEvent('filteredRowsSet');
-  }, [props.filterMode, apiRef]);
+  }, [apiRef, props.filterMode, props.getRowId]);
   const addColumnMenuItem = React.useCallback((columnMenuItems, colDef) => {
     if (colDef == null || colDef.filterable === false || props.disableColumnFilter) {
       return columnMenuItems;
@@ -256,36 +256,45 @@ export const useGridFilter = (apiRef, props) => {
     }
     return initialValue;
   }, [props.slots.filterPanel, (_props$slotProps2 = props.slotProps) == null ? void 0 : _props$slotProps2.filterPanel]);
+  const dataRowIdToIdLookup = apiRef.current.state.rows.dataRowIdToModelLookup;
+  const rows = React.useMemo(() => Object.values(dataRowIdToIdLookup), [dataRowIdToIdLookup]);
+  const {
+    getRowId
+  } = props;
   const flatFilteringMethod = React.useCallback(params => {
-    if (props.filterMode === 'client' && params.isRowMatchingFilters) {
-      const tree = gridRowTreeSelector(apiRef);
-      const rowIds = tree[GRID_ROOT_GROUP_ID].children;
-      const filteredRowsLookup = {};
-      const filterCache = {};
-      for (let i = 0; i < rowIds.length; i += 1) {
-        const rowId = rowIds[i];
-        let isRowPassing;
-        if (typeof rowId === 'string' && rowId.startsWith('auto-generated-group-footer')) {
-          isRowPassing = true;
-        } else {
-          const {
-            passingFilterItems,
-            passingQuickFilterValues
-          } = params.isRowMatchingFilters(rowId);
-          isRowPassing = passFilterLogic([passingFilterItems], [passingQuickFilterValues], params.filterModel, apiRef, filterCache);
-        }
-        filteredRowsLookup[rowId] = isRowPassing;
-      }
+    if (props.filterMode !== 'client' || !params.isRowMatchingFilters) {
       return {
-        filteredRowsLookup,
+        filteredRowsLookup: {},
         filteredDescendantCountLookup: {}
       };
     }
+    const dataRowIdToModelLookup = gridRowsLookupSelector(apiRef);
+    const filteredRowsLookup = {};
+    const {
+      isRowMatchingFilters
+    } = params;
+    const filterCache = {};
+    const result = {
+      passingFilterItems: null,
+      passingQuickFilterValues: null
+    };
+    for (let i = 0; i < rows.length; i += 1) {
+      const row = rows[i];
+      const id = getRowId ? getRowId(row) : row.id;
+      isRowMatchingFilters(row, undefined, result);
+      const isRowPassing = passFilterLogic([result.passingFilterItems], [result.passingQuickFilterValues], params.filterModel, apiRef, filterCache);
+      filteredRowsLookup[id] = isRowPassing;
+    }
+    const footerId = 'auto-generated-group-footer-root';
+    const footer = dataRowIdToModelLookup[footerId];
+    if (footer) {
+      filteredRowsLookup[footerId] = true;
+    }
     return {
-      filteredRowsLookup: {},
+      filteredRowsLookup,
       filteredDescendantCountLookup: {}
     };
-  }, [apiRef, props.filterMode]);
+  }, [apiRef, rows, props.filterMode, getRowId]);
   useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItem);
   useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
   useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);

package/hooks/features/pagination/gridPaginationSelector.js

@@ -60,13 +60,18 @@ export const gridPaginationRowRangeSelector = createSelectorMemoized(gridPaginat
   let lastRowIndex = firstRowIndex;
   let topLevelRowAdded = 0;
   while (lastRowIndex < visibleSortedRowEntries.length && topLevelRowAdded <= topLevelRowsInCurrentPageCount) {
+    var _rowTree$row$id;
     const row = visibleSortedRowEntries[lastRowIndex];
-    const depth = rowTree[row.id].depth;
-    if (topLevelRowAdded < topLevelRowsInCurrentPageCount || depth > 0) {
+    const depth = (_rowTree$row$id = rowTree[row.id]) == null ? void 0 : _rowTree$row$id.depth;
+    if (depth === undefined) {
       lastRowIndex += 1;
-    }
-    if (depth === 0) {
-      topLevelRowAdded += 1;
+    } else {
+      if (topLevelRowAdded < topLevelRowsInCurrentPageCount || depth > 0) {
+        lastRowIndex += 1;
+      }
+      if (depth === 0) {
+        topLevelRowAdded += 1;
+      }
     }
   }
   return {

package/hooks/features/rows/gridRowsUtils.d.ts

@@ -4,6 +4,7 @@ import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
 import { GridApiCommunity, GridPrivateApiCommunity } from '../../../models/api/gridApiCommunity';
 import { GridRowsInternalCache, GridRowsState, GridRowTreeCreationParams } from './gridRowsInterfaces';
 export declare const GRID_ROOT_GROUP_ID: GridRowId;
+export declare const GRID_ID_AUTOGENERATED: unique symbol;
 export declare const buildRootGroup: () => GridGroupNode;
 /**
  * A helper function to check if the id provided is valid.

package/hooks/features/rows/gridRowsUtils.js

@@ -2,6 +2,7 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import { gridPinnedRowsSelector } from './gridRowsSelector';
 import { gridDensityFactorSelector } from '../density/densitySelector';
 export const GRID_ROOT_GROUP_ID = `auto-generated-group-node-root`;
+export const GRID_ID_AUTOGENERATED = Symbol('mui-autogenerated-id');
 export const buildRootGroup = () => ({
   type: 'group',
   id: GRID_ROOT_GROUP_ID,

package/hooks/features/rows/useGridParamsApi.d.ts

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { GridPrivateApiCommunity } from '../../../models/api/gridApiCommunity';
+import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
 export declare class MissingRowIdError extends Error {
 }
 /**
@@ -10,4 +11,4 @@ export declare class MissingRowIdError extends Error {
  * TODO: Impossible priority - useGridEditing also needs to be after useGridParamsApi
  * TODO: Impossible priority - useGridFocus also needs to be after useGridParamsApi
  */
-export declare function useGridParamsApi(apiRef: React.MutableRefObject<GridPrivateApiCommunity>): void;
+export declare function useGridParamsApi(apiRef: React.MutableRefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, 'getRowId'>): void;

package/hooks/features/rows/useGridParamsApi.js

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { getGridCellElement, getGridColumnHeaderElement, getGridRowElement } from '../../../utils/domUtils';
+import { GRID_ID_AUTOGENERATED } from './gridRowsUtils';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { gridFocusCellSelector, gridTabIndexCellSelector } from '../focus/gridFocusStateSelector';
 export class MissingRowIdError extends Error {}
@@ -12,7 +13,10 @@ export class MissingRowIdError extends Error {}
  * TODO: Impossible priority - useGridEditing also needs to be after useGridParamsApi
  * TODO: Impossible priority - useGridFocus also needs to be after useGridParamsApi
  */
-export function useGridParamsApi(apiRef) {
+export function useGridParamsApi(apiRef, props) {
+  const {
+    getRowId
+  } = props;
   const getColumnHeaderParams = React.useCallback(field => ({
     field,
     colDef: apiRef.current.getColumn(field)
@@ -96,6 +100,30 @@ export function useGridParamsApi(apiRef) {
     }
     return colDef.valueGetter(getBaseCellParams(id, field));
   }, [apiRef, getBaseCellParams]);
+  const getRowValue = React.useCallback((row, colDef) => {
+    var _getRowId;
+    const id = GRID_ID_AUTOGENERATED in row ? row[GRID_ID_AUTOGENERATED] : (_getRowId = getRowId == null ? void 0 : getRowId(row)) != null ? _getRowId : row.id;
+    const field = colDef.field;
+    if (!colDef || !colDef.valueGetter) {
+      return row[field];
+    }
+    return colDef.valueGetter(getBaseCellParams(id, field));
+  }, [getBaseCellParams, getRowId]);
+  const getRowFormattedValue = React.useCallback((row, colDef) => {
+    var _ref;
+    const value = getRowValue(row, colDef);
+    if (!colDef || !colDef.valueFormatter) {
+      return value;
+    }
+    const id = (_ref = getRowId ? getRowId(row) : row.id) != null ? _ref : row[GRID_ID_AUTOGENERATED];
+    const field = colDef.field;
+    return colDef.valueFormatter({
+      id,
+      field,
+      value,
+      api: apiRef.current
+    });
+  }, [apiRef, getRowId, getRowValue]);
   const getColumnHeaderElement = React.useCallback(field => {
     if (!apiRef.current.rootElementRef.current) {
       return null;
@@ -121,6 +149,8 @@ export function useGridParamsApi(apiRef) {
     getCellValue,
     getCellParams,
     getCellElement,
+    getRowValue,
+    getRowFormattedValue,
     getRowParams,
     getRowElement,
     getColumnHeaderParams,

package/hooks/features/rows/useGridRows.js

@@ -7,7 +7,7 @@ import { GridSignature, useGridApiEventHandler } from '../../utils/useGridApiEve
 import { useGridVisibleRows } from '../../utils/useGridVisibleRows';
 import { gridSortedRowIdsSelector } from '../sorting/gridSortingSelector';
 import { gridFilteredRowsLookupSelector } from '../filter/gridFilterSelector';
-import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, isAutoGeneratedRow, GRID_ROOT_GROUP_ID, updateCacheWithNewRows, getTopLevelRowCount, getRowIdFromRowModel } from './gridRowsUtils';
+import { getTreeNodeDescendants, createRowsInternalCache, getRowsStateFromCache, isAutoGeneratedRow, GRID_ROOT_GROUP_ID, GRID_ID_AUTOGENERATED, updateCacheWithNewRows, getTopLevelRowCount, getRowIdFromRowModel } from './gridRowsUtils';
 import { useGridRegisterPipeApplier } from '../../core/pipeProcessing';
 export const rowsStateInitializer = (state, props, apiRef) => {
   apiRef.current.caches.rows = createRowsInternalCache({
@@ -46,8 +46,9 @@ export const useGridRows = (apiRef, props) => {
     }
     const node = apiRef.current.getRowNode(id);
     if (node && isAutoGeneratedRow(node)) {
-      // TODO rows v6: Is it the best approach ?
-      return {};
+      return {
+        [GRID_ID_AUTOGENERATED]: id
+      };
     }
     return null;
   }, [apiRef]);

package/index.js

@@ -1,5 +1,5 @@
 /**
- * @mui/x-data-grid v6.9.0
+ * @mui/x-data-grid v6.9.2
  *
  * @license MIT
  * This source code is licensed under the MIT license found in the

package/internals/index.d.ts

@@ -29,7 +29,7 @@ export { useGridPrintExport } from '../hooks/features/export/useGridPrintExport'
 export { useGridFilter, filterStateInitializer } from '../hooks/features/filter/useGridFilter';
 export { passFilterLogic } from '../hooks/features/filter/gridFilterUtils';
 export { isSingleSelectColDef } from '../components/panel/filterPanel/filterPanelUtils';
-export type { GridAggregatedFilterItemApplier } from '../hooks/features/filter/gridFilterState';
+export type { GridAggregatedFilterItemApplier, GridAggregatedFilterItemApplierResult, } from '../hooks/features/filter/gridFilterState';
 export { useGridFocus, focusStateInitializer } from '../hooks/features/focus/useGridFocus';
 export { useGridKeyboardNavigation } from '../hooks/features/keyboardNavigation/useGridKeyboardNavigation';
 export { useGridPagination, paginationStateInitializer, } from '../hooks/features/pagination/useGridPagination';
@@ -72,4 +72,5 @@ export { useGridPrivateApiContext } from '../hooks/utils/useGridPrivateApiContex
 export type { GridApiCommunity } from '../models/api/gridApiCommunity';
 export type { GridApiCaches } from '../models/gridApiCaches';
 export { serializeCellValue } from '../hooks/features/export/serializers/csvSerializer';
+export * from '../colDef/utils';
 export * from './utils';

package/internals/index.js

@@ -56,4 +56,5 @@ export { buildWarning } from '../utils/warning';
 export { exportAs } from '../utils/exportAs';
 export { useGridPrivateApiContext } from '../hooks/utils/useGridPrivateApiContext';
 export { serializeCellValue } from '../hooks/features/export/serializers/csvSerializer';
+export * from '../colDef/utils';
 export * from './utils';

package/joy/joySlots.js

@@ -20,11 +20,14 @@ import JoySelect from '@mui/joy/Select';
 import JoyOption from '@mui/joy/Option';
 import JoyBox from '@mui/joy/Box';
 import JoyTypography from '@mui/joy/Typography';
+import JoyCircularProgress from '@mui/joy/CircularProgress';
+import JoyTooltip from '@mui/joy/Tooltip';
 import { unstable_useForkRef as useForkRef } from '@mui/utils';
 import joyIconSlots, { GridKeyboardArrowRight, GridKeyboardArrowLeft } from './icons';
 import { useGridApiContext } from '../hooks/utils/useGridApiContext';
 import { useGridRootProps } from '../hooks/utils/useGridRootProps';
 import { gridFilteredTopLevelRowCountSelector, gridPaginationModelSelector } from '../hooks';
+import { GridOverlay } from '../components/containers/GridOverlay';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { jsxs as _jsxs } from "react/jsx-runtime";
 function convertColor(color) {
@@ -288,7 +291,6 @@ const getLabelDisplayedRowsTo = ({
   return pageSize === -1 ? rowCount : Math.min(rowCount, (page + 1) * pageSize);
 };
 const Pagination = /*#__PURE__*/React.forwardRef((props, ref) => {
-  var _rootProps$pageSizeOp;
   const apiRef = useGridApiContext();
   const rootProps = useGridRootProps();
   const paginationModel = gridPaginationModelSelector(apiRef);
@@ -303,7 +305,20 @@ const Pagination = /*#__PURE__*/React.forwardRef((props, ref) => {
   }, [apiRef]);
   const page = paginationModel.page <= lastPage ? paginationModel.page : lastPage;
   const pageSize = paginationModel.pageSize;
-  const pageSizeOptions = (_rootProps$pageSizeOp = rootProps.pageSizeOptions) != null && _rootProps$pageSizeOp.includes(pageSize) ? rootProps.pageSizeOptions : [];
+  const isPageSizeIncludedInPageSizeOptions = () => {
+    for (let i = 0; i < rootProps.pageSizeOptions.length; i += 1) {
+      const option = rootProps.pageSizeOptions[i];
+      if (typeof option === 'number') {
+        if (option === pageSize) {
+          return true;
+        }
+      } else if (option.value === pageSize) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const pageSizeOptions = isPageSizeIncludedInPageSizeOptions() ? rootProps.pageSizeOptions : [];
   const handleChangeRowsPerPage = (event, newValue) => {
     const newPageSize = Number(newValue);
     apiRef.current.setPageSize(newPageSize);
@@ -327,9 +342,9 @@ const Pagination = /*#__PURE__*/React.forwardRef((props, ref) => {
         value: pageSize,
         children: pageSizeOptions.map(option => {
           return /*#__PURE__*/_jsx(Option, {
-            value: option,
-            children: option
-          }, option);
+            value: typeof option !== 'number' && option.value ? option.value : option,
+            children: typeof option !== 'number' && option.label ? option.label : `${option}`
+          }, typeof option !== 'number' && option.label ? option.label : `${option}`);
         })
       })]
     }), /*#__PURE__*/_jsx(JoyTypography, {
@@ -374,6 +389,12 @@ const Pagination = /*#__PURE__*/React.forwardRef((props, ref) => {
     })]
   });
 });
+const LoadingOverlay = /*#__PURE__*/React.forwardRef((props, ref) => {
+  return /*#__PURE__*/_jsx(GridOverlay, _extends({}, props, {
+    ref: ref,
+    children: /*#__PURE__*/_jsx(JoyCircularProgress, {})
+  }));
+});
 const joySlots = _extends({}, joyIconSlots, {
   baseCheckbox: Checkbox,
   baseTextField: TextField,
@@ -384,8 +405,8 @@ const joySlots = _extends({}, joyIconSlots, {
   baseSelectOption: Option,
   baseInputLabel: InputLabel,
   baseFormControl: JoyFormControl,
-  // BaseTooltip: MUITooltip,
-  // BasePopper: MUIPopper,
-  pagination: Pagination
+  baseTooltip: JoyTooltip,
+  pagination: Pagination,
+  loadingOverlay: LoadingOverlay
 });
 export default joySlots;

package/legacy/DataGrid/DataGrid.js

@@ -515,7 +515,10 @@ DataGridRaw.propTypes = {
    * Select the pageSize dynamically using the component UI.
    * @default [25, 50, 100]
    */
-  pageSizeOptions: PropTypes.arrayOf(PropTypes.number),
+  pageSizeOptions: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
+    label: PropTypes.string.isRequired,
+    value: PropTypes.number.isRequired
+  })]).isRequired),
   pagination: function pagination(props) {
     if (props.pagination === false) {
       return new Error(['MUI: `<DataGrid pagination={false} />` is not a valid prop.', 'Infinite scrolling is not available in the MIT version.', '', 'You need to upgrade to DataGridPro or DataGridPremium component to disable the pagination.'].join('\n'));

package/legacy/DataGrid/useDataGridComponent.js

@@ -54,7 +54,7 @@ export var useDataGridComponent = function useDataGridComponent(inputApiRef, pro
   useGridRowSelection(privateApiRef, props);
   useGridColumns(privateApiRef, props);
   useGridRows(privateApiRef, props);
-  useGridParamsApi(privateApiRef);
+  useGridParamsApi(privateApiRef, props);
   useGridColumnSpanning(privateApiRef);
   useGridColumnGrouping(privateApiRef, props);
   useGridEditing(privateApiRef, props);

package/legacy/colDef/gridActionsColDef.js

@@ -14,5 +14,6 @@ export var GRID_ACTIONS_COL_DEF = _extends({}, GRID_STRING_COL_DEF, {
   disableColumnMenu: true,
   disableExport: true,
   renderCell: renderActionsCell,
-  getApplyQuickFilterFn: undefined
+  getApplyQuickFilterFn: undefined,
+  getApplyQuickFilterFnV7: undefined
 });

package/legacy/colDef/gridBooleanColDef.js

@@ -35,6 +35,7 @@ export var GRID_BOOLEAN_COL_DEF = _extends({}, GRID_STRING_COL_DEF, {
   valueFormatter: gridBooleanFormatter,
   filterOperators: getGridBooleanOperators(),
   getApplyQuickFilterFn: undefined,
+  getApplyQuickFilterFnV7: undefined,
   // @ts-ignore
   aggregable: false,
   // @ts-ignore