@mui/x-data-grid 6.9.0 → 6.9.2

package/legacy/components/cell/GridEditInputCell.js

@@ -100,12 +100,12 @@ var GridEditInputCell = /*#__PURE__*/React.forwardRef(function (props, ref) {
       return _ref2.apply(this, arguments);
     };
   }(), [apiRef, debounceMs, field, id, onValueChange]);
-  var meta = apiRef.current.unstable_getEditCellMeta ? apiRef.current.unstable_getEditCellMeta(id, field) : {};
+  var meta = apiRef.current.unstable_getEditCellMeta(id, field);
   React.useEffect(function () {
-    if (meta.changeReason !== 'debouncedSetEditCellValue') {
+    if ((meta == null ? void 0 : meta.changeReason) !== 'debouncedSetEditCellValue') {
       setValueState(value);
     }
-  }, [meta.changeReason, value]);
+  }, [meta, value]);
   useEnhancedEffect(function () {
     if (hasFocus) {
       inputRef.current.focus();

package/legacy/hooks/features/columns/gridColumnsUtils.js

@@ -17,6 +17,9 @@ export function computeFlexColumnsWidth(_ref) {
   var initialFreeSpace = _ref.initialFreeSpace,
     totalFlexUnits = _ref.totalFlexUnits,
     flexColumns = _ref.flexColumns;
+  var uniqueFlexColumns = new Set(flexColumns.map(function (col) {
+    return col.field;
+  }));
   var flexColumnsLookup = {
     all: {},
     frozenFields: [],
@@ -32,7 +35,7 @@ export function computeFlexColumnsWidth(_ref) {
   // Step 5 of https://drafts.csswg.org/css-flexbox-1/#resolve-flexible-lengths
   function loopOverFlexItems() {
     // 5a: If all the flex items on the line are frozen, free space has been distributed.
-    if (flexColumnsLookup.frozenFields.length === flexColumns.length) {
+    if (flexColumnsLookup.frozenFields.length === uniqueFlexColumns.size) {
       return;
     }
     var violationsLookup = {

package/legacy/hooks/features/dimensions/useGridDimensions.js

@@ -73,7 +73,7 @@ export function useGridDimensions(apiRef, props) {
     var hasScrollY;
     if (props.autoHeight) {
       hasScrollY = false;
-      hasScrollX = Math.round(columnsTotalWidth) > rootDimensionsRef.current.width;
+      hasScrollX = Math.round(columnsTotalWidth) > Math.round(rootDimensionsRef.current.width);
       viewportOuterSize = {
         width: rootDimensionsRef.current.width,
         height: rowsMeta.currentPageTotalHeight + (hasScrollX ? scrollBarSize : 0)
@@ -89,7 +89,7 @@ export function useGridDimensions(apiRef, props) {
           height: rowsMeta.currentPageTotalHeight
         },
         container: {
-          width: viewportOuterSize.width,
+          width: Math.round(viewportOuterSize.width),
           height: viewportOuterSize.height - pinnedRowsHeight.top - pinnedRowsHeight.bottom
         },
         scrollBarSize: scrollBarSize

package/legacy/hooks/features/editing/useGridEditing.js

@@ -127,8 +127,9 @@ export var useGridEditing = function useGridEditing(apiRef, props) {
     return props.editMode === GridEditModes.Cell ? apiRef.current.getRowWithUpdatedValuesFromCellEditing(id, field) : apiRef.current.getRowWithUpdatedValuesFromRowEditing(id);
   }, [apiRef, props.editMode]);
   var getEditCellMeta = React.useCallback(function (id, field) {
+    var _editingState$id$fiel, _editingState$id;
     var editingState = gridEditRowsStateSelector(apiRef.current.state);
-    return editingState[id][field];
+    return (_editingState$id$fiel = (_editingState$id = editingState[id]) == null ? void 0 : _editingState$id[field]) != null ? _editingState$id$fiel : null;
   }, [apiRef]);
   var editingSharedApi = {
     isCellEditable: isCellEditable,

package/legacy/hooks/features/editing/useGridRowEditing.js

@@ -12,7 +12,7 @@ import { GridEditModes, GridRowModes } from '../../../models/gridEditRowModel';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { gridEditRowsStateSelector } from './gridEditingSelectors';
 import { isPrintableKey } from '../../../utils/keyboardUtils';
-import { gridColumnFieldsSelector } from '../columns/gridColumnsSelector';
+import { gridColumnFieldsSelector, gridVisibleColumnFieldsSelector } from '../columns/gridColumnsSelector';
 import { buildWarning } from '../../../utils/warning';
 import { gridRowsDataRowIdToIdLookupSelector } from '../rows/gridRowsSelector';
 import { deepClone } from '../../../utils/utils';
@@ -120,7 +120,7 @@ export var useGridRowEditing = function useGridRowEditing(apiRef, props) {
       } else if (event.key === 'Enter') {
         reason = GridRowEditStopReasons.enterKeyDown;
       } else if (event.key === 'Tab') {
-        var columnFields = gridColumnFieldsSelector(apiRef).filter(function (field) {
+        var columnFields = gridVisibleColumnFieldsSelector(apiRef).filter(function (field) {
           var column = apiRef.current.getColumn(field);
           if (column.type === GRID_ACTIONS_COLUMN_TYPE) {
             return true;

package/legacy/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';
@@ -99,27 +100,47 @@ var getFilterCallbackFromItem = function getFilterCallbackFromItem(filterItem, a
   if (!filterOperator) {
     throw new Error("MUI: No filter operator found for column '".concat(column.field, "' and operator value '").concat(newFilterItem.operator, "'."));
   }
+  var hasUserFunctionLegacy = !isInternalFilter(filterOperator.getApplyFilterFn);
+  var hasUserFunctionV7 = !isInternalFilter(filterOperator.getApplyFilterFnV7);
+  if (filterOperator.getApplyFilterFnV7 && !(hasUserFunctionLegacy && !hasUserFunctionV7)) {
+    var _applyFilterOnRow = filterOperator.getApplyFilterFnV7(newFilterItem, column);
+    if (typeof _applyFilterOnRow !== 'function') {
+      return null;
+    }
+    return {
+      v7: true,
+      item: newFilterItem,
+      fn: function fn(row) {
+        var value = apiRef.current.getRowValue(row, column);
+        return _applyFilterOnRow(value, row, column, apiRef);
+      }
+    };
+  }
   var applyFilterOnRow = filterOperator.getApplyFilterFn(newFilterItem, column);
   if (typeof applyFilterOnRow !== 'function') {
     return null;
   }
-  var fn = function fn(rowId) {
-    var cellParams = apiRef.current.getCellParams(rowId, newFilterItem.field);
-    return applyFilterOnRow(cellParams);
-  };
   return {
-    fn: fn,
-    item: newFilterItem
+    v7: false,
+    item: newFilterItem,
+    fn: function fn(rowId) {
+      var params = apiRef.current.getCellParams(rowId, newFilterItem.field);
+      GLOBAL_API_REF.current = apiRef;
+      var 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 var buildAggregatedFilterItemsApplier = function buildAggregatedFilterItemsApplier(filterModel, apiRef) {
+export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterItemsApplier(getRowId, filterModel, apiRef) {
   var items = filterModel.items;
   var appliers = items.map(function (item) {
     return getFilterCallbackFromItem(item, apiRef);
@@ -129,83 +150,112 @@ export var buildAggregatedFilterItemsApplier = function buildAggregatedFilterIte
   if (appliers.length === 0) {
     return null;
   }
-  return function (rowId, shouldApplyFilter) {
+  return function (row, shouldApplyFilter) {
     var resultPerItemId = {};
-    var filteredAppliers = shouldApplyFilter ? appliers.filter(function (applier) {
-      return shouldApplyFilter(applier.item.field);
-    }) : appliers;
-    filteredAppliers.forEach(function (applier) {
-      resultPerItemId[applier.item.id] = applier.fn(rowId);
-    });
+    for (var i = 0; i < appliers.length; i += 1) {
+      var 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 var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilterApplier(filterModel, apiRef) {
-  var _filterModel$quickFil = filterModel.quickFilterValues,
-    quickFilterValues = _filterModel$quickFil === void 0 ? [] : _filterModel$quickFil;
+export var buildAggregatedQuickFilterApplier = function buildAggregatedQuickFilterApplier(getRowId, filterModel, apiRef) {
+  var _filterModel$quickFil, _filterModel$quickFil2;
+  var quickFilterValues = (_filterModel$quickFil = (_filterModel$quickFil2 = filterModel.quickFilterValues) == null ? void 0 : _filterModel$quickFil2.filter(Boolean)) != null ? _filterModel$quickFil : [];
   if (quickFilterValues.length === 0) {
     return null;
   }
-  var columnsFields = gridColumnFieldsSelector(apiRef);
-  var appliersPerField = {};
-  columnsFields.forEach(function (field) {
+  var columnFields = gridColumnFieldsSelector(apiRef);
+  var appliersPerField = [];
+  columnFields.forEach(function (field) {
     var column = apiRef.current.getColumn(field);
     var getApplyQuickFilterFn = column == null ? void 0 : column.getApplyQuickFilterFn;
-    if (!getApplyQuickFilterFn) {
-      return;
+    var getApplyQuickFilterFnV7 = column == null ? void 0 : column.getApplyQuickFilterFnV7;
+    var hasUserFunctionLegacy = !isInternalFilter(getApplyQuickFilterFn);
+    var hasUserFunctionV7 = !isInternalFilter(getApplyQuickFilterFnV7);
+    if (getApplyQuickFilterFnV7 && !(hasUserFunctionLegacy && !hasUserFunctionV7)) {
+      appliersPerField.push({
+        column: column,
+        appliers: quickFilterValues.map(function (value) {
+          return {
+            v7: true,
+            fn: getApplyQuickFilterFnV7(value, column, apiRef)
+          };
+        })
+      });
+    } else if (getApplyQuickFilterFn) {
+      appliersPerField.push({
+        column: column,
+        appliers: quickFilterValues.map(function (value) {
+          return {
+            v7: false,
+            fn: getApplyQuickFilterFn(value, column, apiRef)
+          };
+        })
+      });
     }
-    appliersPerField[field] = quickFilterValues.map(function (value) {
-      return getApplyQuickFilterFn(value, column, apiRef);
-    });
-  });
-
-  // If some value does not have an applier we ignore them
-  var sanitizedQuickFilterValues = quickFilterValues.filter(function (value, index) {
-    return Object.keys(appliersPerField).some(function (field) {
-      return appliersPerField[field][index] != null;
-    });
   });
-  if (sanitizedQuickFilterValues.length === 0) {
-    return null;
-  }
-  return function (rowId, shouldApplyFilter) {
+  return function isRowMatchingQuickFilter(row, shouldApplyFilter) {
+    var result = {};
     var usedCellParams = {};
-    var fieldsToFilter = [];
-    Object.keys(appliersPerField).forEach(function (field) {
-      if (!shouldApplyFilter || shouldApplyFilter(field)) {
-        usedCellParams[field] = apiRef.current.getCellParams(rowId, field);
-        fieldsToFilter.push(field);
-      }
-    });
-    var quickFilterValueResult = {};
-    sanitizedQuickFilterValues.forEach(function (value, index) {
-      var isPassing = fieldsToFilter.some(function (field) {
-        var _appliersPerField$fie, _appliersPerField$fie2;
-        if (appliersPerField[field][index] == null) {
-          return false;
+
+    /* eslint-disable no-restricted-syntax, no-labels, no-continue */
+    outer: for (var v = 0; v < quickFilterValues.length; v += 1) {
+      var filterValue = quickFilterValues[v];
+      for (var i = 0; i < appliersPerField.length; i += 1) {
+        var _appliersPerField$i = appliersPerField[i],
+          column = _appliersPerField$i.column,
+          appliers = _appliersPerField$i.appliers;
+        var _field = column.field;
+        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;
+        var applier = appliers[v];
+        var value = apiRef.current.getRowValue(row, column);
+        if (applier.fn === null) {
+          continue;
+        }
+        if (applier.v7) {
+          var isMatching = applier.fn(value, row, column, apiRef);
+          if (isMatching) {
+            result[filterValue] = true;
+            continue outer;
+          }
+        } else {
+          var _usedCellParams$_fiel;
+          var cellParams = (_usedCellParams$_fiel = usedCellParams[_field]) != null ? _usedCellParams$_fiel : apiRef.current.getCellParams(getRowId ? getRowId(row) : row.id, _field);
+          usedCellParams[_field] = cellParams;
+          var _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 var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(filterModel, apiRef) {
-  var isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(filterModel, apiRef);
-  var isRowMatchingQuickFilter = buildAggregatedQuickFilterApplier(filterModel, apiRef);
-  return function (rowId, shouldApplyFilter) {
-    return {
-      passingFilterItems: isRowMatchingFilterItems && isRowMatchingFilterItems(rowId, shouldApplyFilter),
-      passingQuickFilterValues: isRowMatchingQuickFilter && isRowMatchingQuickFilter(rowId, shouldApplyFilter)
-    };
+export var buildAggregatedFilterApplier = function buildAggregatedFilterApplier(getRowId, filterModel, apiRef) {
+  var isRowMatchingFilterItems = buildAggregatedFilterItemsApplier(getRowId, filterModel, apiRef);
+  var 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;
   };
 };
 var isNotNull = function isNotNull(result) {
@@ -249,14 +299,14 @@ export var passFilterLogic = function passFilterLogic(allFilterItemResults, allQ
 
   // get result for quick filter model
   if (cleanedQuickFilterResults.length > 0 && filterModel.quickFilterValues != null) {
-    var _filterModel$quickFil2;
+    var _filterModel$quickFil3;
     // Return true if the item pass with one of the rows
     var quickFilterValuePredicate = function quickFilterValuePredicate(value) {
       return cleanedQuickFilterResults.some(function (quickFilterValueResult) {
         return quickFilterValueResult[value];
       });
     };
-    var quickFilterLogicOperator = (_filterModel$quickFil2 = filterModel.quickFilterLogicOperator) != null ? _filterModel$quickFil2 : getDefaultGridFilterModel().quickFilterLogicOperator;
+    var quickFilterLogicOperator = (_filterModel$quickFil3 = filterModel.quickFilterLogicOperator) != null ? _filterModel$quickFil3 : getDefaultGridFilterModel().quickFilterLogicOperator;
     if (quickFilterLogicOperator === GridLogicOperator.And) {
       var passesAllQuickFilterValues = filterModel.quickFilterValues.every(quickFilterValuePredicate);
       if (!passesAllQuickFilterValues) {

package/legacy/hooks/features/filter/useGridFilter.js

@@ -10,7 +10,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';
@@ -56,7 +56,7 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
   var updateFilteredRows = React.useCallback(function () {
     apiRef.current.setState(function (state) {
       var filterModel = gridFilterModelSelector(state, apiRef.current.instanceId);
-      var isRowMatchingFilters = props.filterMode === 'client' ? buildAggregatedFilterApplier(filterModel, apiRef) : null;
+      var isRowMatchingFilters = props.filterMode === 'client' ? buildAggregatedFilterApplier(props.getRowId, filterModel, apiRef) : null;
       var filteringResult = apiRef.current.applyStrategyProcessor('filtering', {
         isRowMatchingFilters: isRowMatchingFilters,
         filterModel: filterModel != null ? filterModel : getDefaultGridFilterModel()
@@ -70,7 +70,7 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
       });
     });
     apiRef.current.publishEvent('filteredRowsSet');
-  }, [props.filterMode, apiRef]);
+  }, [apiRef, props.filterMode, props.getRowId]);
   var addColumnMenuItem = React.useCallback(function (columnMenuItems, colDef) {
     if (colDef == null || colDef.filterable === false || props.disableColumnFilter) {
       return columnMenuItems;
@@ -267,35 +267,43 @@ export var useGridFilter = function useGridFilter(apiRef, props) {
     }
     return initialValue;
   }, [props.slots.filterPanel, (_props$slotProps2 = props.slotProps) == null ? void 0 : _props$slotProps2.filterPanel]);
+  var dataRowIdToIdLookup = apiRef.current.state.rows.dataRowIdToModelLookup;
+  var rows = React.useMemo(function () {
+    return Object.values(dataRowIdToIdLookup);
+  }, [dataRowIdToIdLookup]);
+  var getRowId = props.getRowId;
   var flatFilteringMethod = React.useCallback(function (params) {
-    if (props.filterMode === 'client' && params.isRowMatchingFilters) {
-      var tree = gridRowTreeSelector(apiRef);
-      var rowIds = tree[GRID_ROOT_GROUP_ID].children;
-      var filteredRowsLookup = {};
-      var filterCache = {};
-      for (var i = 0; i < rowIds.length; i += 1) {
-        var rowId = rowIds[i];
-        var isRowPassing = void 0;
-        if (typeof rowId === 'string' && rowId.startsWith('auto-generated-group-footer')) {
-          isRowPassing = true;
-        } else {
-          var _params$isRowMatching = params.isRowMatchingFilters(rowId),
-            passingFilterItems = _params$isRowMatching.passingFilterItems,
-            passingQuickFilterValues = _params$isRowMatching.passingQuickFilterValues;
-          isRowPassing = passFilterLogic([passingFilterItems], [passingQuickFilterValues], params.filterModel, apiRef, filterCache);
-        }
-        filteredRowsLookup[rowId] = isRowPassing;
-      }
+    if (props.filterMode !== 'client' || !params.isRowMatchingFilters) {
       return {
-        filteredRowsLookup: filteredRowsLookup,
+        filteredRowsLookup: {},
         filteredDescendantCountLookup: {}
       };
     }
+    var dataRowIdToModelLookup = gridRowsLookupSelector(apiRef);
+    var filteredRowsLookup = {};
+    var isRowMatchingFilters = params.isRowMatchingFilters;
+    var filterCache = {};
+    var result = {
+      passingFilterItems: null,
+      passingQuickFilterValues: null
+    };
+    for (var i = 0; i < rows.length; i += 1) {
+      var row = rows[i];
+      var id = getRowId ? getRowId(row) : row.id;
+      isRowMatchingFilters(row, undefined, result);
+      var isRowPassing = passFilterLogic([result.passingFilterItems], [result.passingQuickFilterValues], params.filterModel, apiRef, filterCache);
+      filteredRowsLookup[id] = isRowPassing;
+    }
+    var footerId = 'auto-generated-group-footer-root';
+    var footer = dataRowIdToModelLookup[footerId];
+    if (footer) {
+      filteredRowsLookup[footerId] = true;
+    }
     return {
-      filteredRowsLookup: {},
+      filteredRowsLookup: filteredRowsLookup,
       filteredDescendantCountLookup: {}
     };
-  }, [apiRef, props.filterMode]);
+  }, [apiRef, rows, props.filterMode, getRowId]);
   useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItem);
   useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
   useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);

package/legacy/hooks/features/pagination/gridPaginationSelector.js

@@ -72,13 +72,18 @@ export var gridPaginationRowRangeSelector = createSelectorMemoized(gridPaginatio
   var lastRowIndex = firstRowIndex;
   var topLevelRowAdded = 0;
   while (lastRowIndex < visibleSortedRowEntries.length && topLevelRowAdded <= topLevelRowsInCurrentPageCount) {
+    var _rowTree$row$id;
     var row = visibleSortedRowEntries[lastRowIndex];
-    var depth = rowTree[row.id].depth;
-    if (topLevelRowAdded < topLevelRowsInCurrentPageCount || depth > 0) {
+    var 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/legacy/hooks/features/rows/gridRowsUtils.js

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

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

@@ -8,6 +8,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 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 var MissingRowIdError = /*#__PURE__*/function (_Error) {
@@ -28,7 +29,8 @@ export var MissingRowIdError = /*#__PURE__*/function (_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) {
+  var getRowId = props.getRowId;
   var getColumnHeaderParams = React.useCallback(function (field) {
     return {
       field: field,
@@ -114,6 +116,30 @@ export function useGridParamsApi(apiRef) {
     }
     return colDef.valueGetter(getBaseCellParams(id, field));
   }, [apiRef, getBaseCellParams]);
+  var getRowValue = React.useCallback(function (row, colDef) {
+    var _getRowId;
+    var id = GRID_ID_AUTOGENERATED in row ? row[GRID_ID_AUTOGENERATED] : (_getRowId = getRowId == null ? void 0 : getRowId(row)) != null ? _getRowId : row.id;
+    var field = colDef.field;
+    if (!colDef || !colDef.valueGetter) {
+      return row[field];
+    }
+    return colDef.valueGetter(getBaseCellParams(id, field));
+  }, [getBaseCellParams, getRowId]);
+  var getRowFormattedValue = React.useCallback(function (row, colDef) {
+    var _ref;
+    var value = getRowValue(row, colDef);
+    if (!colDef || !colDef.valueFormatter) {
+      return value;
+    }
+    var id = (_ref = getRowId ? getRowId(row) : row.id) != null ? _ref : row[GRID_ID_AUTOGENERATED];
+    var field = colDef.field;
+    return colDef.valueFormatter({
+      id: id,
+      field: field,
+      value: value,
+      api: apiRef.current
+    });
+  }, [apiRef, getRowId, getRowValue]);
   var getColumnHeaderElement = React.useCallback(function (field) {
     if (!apiRef.current.rootElementRef.current) {
       return null;
@@ -139,6 +165,8 @@ export function useGridParamsApi(apiRef) {
     getCellValue: getCellValue,
     getCellParams: getCellParams,
     getCellElement: getCellElement,
+    getRowValue: getRowValue,
+    getRowFormattedValue: getRowFormattedValue,
     getRowParams: getRowParams,
     getRowElement: getRowElement,
     getColumnHeaderParams: getColumnHeaderParams,

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

@@ -10,7 +10,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 var rowsStateInitializer = function rowsStateInitializer(state, props, apiRef) {
   apiRef.current.caches.rows = createRowsInternalCache({
@@ -49,21 +49,20 @@ export var useGridRows = function useGridRows(apiRef, props) {
     }
     var node = apiRef.current.getRowNode(id);
     if (node && isAutoGeneratedRow(node)) {
-      // TODO rows v6: Is it the best approach ?
-      return {};
+      return _defineProperty({}, GRID_ID_AUTOGENERATED, id);
     }
     return null;
   }, [apiRef]);
   var lookup = React.useMemo(function () {
-    return currentPage.rows.reduce(function (acc, _ref, index) {
-      var id = _ref.id;
+    return currentPage.rows.reduce(function (acc, _ref2, index) {
+      var id = _ref2.id;
       acc[id] = index;
       return acc;
     }, {});
   }, [currentPage.rows]);
-  var throttledRowsChange = React.useCallback(function (_ref2) {
-    var cache = _ref2.cache,
-      throttle = _ref2.throttle;
+  var throttledRowsChange = React.useCallback(function (_ref3) {
+    var cache = _ref3.cache,
+      throttle = _ref3.throttle;
     var run = function run() {
       timeout.current = null;
       lastUpdateMs.current = Date.now();
@@ -184,15 +183,15 @@ export var useGridRows = function useGridRows(apiRef, props) {
     apiRef.current.publishEvent('rowExpansionChange', newNode);
   }, [apiRef]);
   var getRowNode = React.useCallback(function (id) {
-    var _ref3;
-    return (_ref3 = gridRowTreeSelector(apiRef)[id]) != null ? _ref3 : null;
+    var _ref4;
+    return (_ref4 = gridRowTreeSelector(apiRef)[id]) != null ? _ref4 : null;
   }, [apiRef]);
-  var getRowGroupChildren = React.useCallback(function (_ref4) {
-    var _ref4$skipAutoGenerat = _ref4.skipAutoGeneratedRows,
-      skipAutoGeneratedRows = _ref4$skipAutoGenerat === void 0 ? true : _ref4$skipAutoGenerat,
-      groupId = _ref4.groupId,
-      applySorting = _ref4.applySorting,
-      applyFiltering = _ref4.applyFiltering;
+  var getRowGroupChildren = React.useCallback(function (_ref5) {
+    var _ref5$skipAutoGenerat = _ref5.skipAutoGeneratedRows,
+      skipAutoGeneratedRows = _ref5$skipAutoGenerat === void 0 ? true : _ref5$skipAutoGenerat,
+      groupId = _ref5.groupId,
+      applySorting = _ref5.applySorting,
+      applyFiltering = _ref5.applyFiltering;
     var tree = gridRowTreeSelector(apiRef);
     var children;
     if (applySorting) {

package/legacy/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/legacy/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';