@mui/x-data-grid 8.17.0 → 8.19.0

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

@@ -40,18 +40,8 @@ export function useGridParamsApi(apiRef, props, configuration) {
     value: forcedValue,
     formattedValue: forcedFormattedValue
   }) => {
-    let value = row[field];
-    if (forcedValue !== undefined) {
-      value = forcedValue;
-    } else if (colDef?.valueGetter) {
-      value = colDef.valueGetter(value, row, colDef, apiRef);
-    }
-    let formattedValue = value;
-    if (forcedFormattedValue !== undefined) {
-      formattedValue = forcedFormattedValue;
-    } else if (colDef?.valueFormatter) {
-      formattedValue = colDef.valueFormatter(value, row, colDef, apiRef);
-    }
+    const value = forcedValue !== undefined ? forcedValue : apiRef.current.getRowValue(row, colDef);
+    const formattedValue = forcedFormattedValue !== undefined ? forcedFormattedValue : apiRef.current.getRowFormattedValue(row, colDef);
     const params = {
       id,
       field,

package/esm/hooks/features/rows/useGridRowSpanning.js

@@ -9,8 +9,7 @@ import { gridRenderContextSelector } from "../virtualization/gridVirtualizationS
 import { getUnprocessedRange, isRowContextInitialized, getCellValue } from "./gridRowSpanningUtils.js";
 import { useGridEvent } from "../../utils/useGridEvent.js";
 import { runIf } from "../../../utils/utils.js";
-import { gridPageSizeSelector } from "../pagination/index.js";
-import { gridDataRowIdsSelector } from "./gridRowsSelector.js";
+import { useRunOncePerLoop } from "../../utils/useRunOncePerLoop.js";
 const EMPTY_CACHES = {
   spannedCells: {},
   hiddenCells: {},
@@ -24,13 +23,6 @@ const EMPTY_STATE = {
   caches: EMPTY_CACHES,
   processedRange: EMPTY_RANGE
 };
-
-/**
- * Default number of rows to process during state initialization to avoid flickering.
- * Number `20` is arbitrarily chosen to be large enough to cover most of the cases without
- * compromising performance.
- */
-const DEFAULT_ROWS_TO_PROCESS = 20;
 const computeRowSpanningState = (apiRef, colDefs, visibleRows, range, rangeToProcess, resetState) => {
   const virtualizer = apiRef.current.virtualizer;
   const previousState = resetState ? EMPTY_STATE : Rowspan.selectors.state(virtualizer.store.state);
@@ -128,65 +120,25 @@ const computeRowSpanningState = (apiRef, colDefs, visibleRows, range, rangeToPro
     processedRange
   };
 };
-const getInitialRangeToProcess = (props, apiRef) => {
-  const rowCount = gridDataRowIdsSelector(apiRef).length;
-  if (props.pagination) {
-    const pageSize = gridPageSizeSelector(apiRef);
-    let paginationLastRowIndex = DEFAULT_ROWS_TO_PROCESS;
-    if (pageSize > 0) {
-      paginationLastRowIndex = pageSize - 1;
-    }
-    return {
-      firstRowIndex: 0,
-      lastRowIndex: Math.min(paginationLastRowIndex, rowCount)
-    };
-  }
-  return {
-    firstRowIndex: 0,
-    lastRowIndex: Math.min(DEFAULT_ROWS_TO_PROCESS, rowCount)
-  };
-};
 
 /**
  * @requires columnsStateInitializer (method) - should be initialized before
  * @requires rowsStateInitializer (method) - should be initialized before
  * @requires filterStateInitializer (method) - should be initialized before
  */
-export const rowSpanningStateInitializer = (state, props, apiRef) => {
-  if (!props.rowSpanning) {
-    return _extends({}, state, {
-      rowSpanning: EMPTY_STATE
-    });
-  }
-  const rowIds = state.rows.dataRowIds || [];
-  const orderedFields = state.columns.orderedFields || [];
-  const dataRowIdToModelLookup = state.rows.dataRowIdToModelLookup;
-  const columnsLookup = state.columns.lookup;
-  const isFilteringPending = Boolean(state.filter.filterModel.items.length) || Boolean(state.filter.filterModel.quickFilterValues?.length);
-  if (!rowIds.length || !orderedFields.length || !dataRowIdToModelLookup || !columnsLookup || isFilteringPending) {
-    return _extends({}, state, {
-      rowSpanning: EMPTY_STATE
-    });
-  }
-  const rangeToProcess = getInitialRangeToProcess(props, apiRef);
-  const rows = rowIds.map(id => ({
-    id,
-    model: dataRowIdToModelLookup[id]
-  }));
-  const colDefs = orderedFields.map(field => columnsLookup[field]);
-  const rowSpanning = computeRowSpanningState(apiRef, colDefs, rows, rangeToProcess, rangeToProcess, true);
+export const rowSpanningStateInitializer = state => {
   return _extends({}, state, {
-    rowSpanning
+    rowSpanning: EMPTY_STATE
   });
 };
 export const useGridRowSpanning = (apiRef, props) => {
-  const store = apiRef.current.virtualizer.store;
   const updateRowSpanningState = React.useCallback((renderContext, resetState = false) => {
+    const store = apiRef.current.virtualizer.store;
     const {
       range,
       rows: visibleRows
     } = getVisibleRows(apiRef);
-    if (resetState && store.getSnapshot().rowSpanning !== EMPTY_STATE) {
+    if (resetState) {
       store.set('rowSpanning', EMPTY_STATE);
     }
     if (range === null || !isRowContextInitialized(renderContext)) {
@@ -212,7 +164,7 @@ export const useGridRowSpanning = (apiRef, props) => {
       return;
     }
     store.set('rowSpanning', newState);
-  }, [apiRef, store]);
+  }, [apiRef]);
 
   // Reset events trigger a full re-computation of the row spanning state:
   // - The `rowSpanning` prop is updated (feature flag)
@@ -220,25 +172,36 @@ export const useGridRowSpanning = (apiRef, props) => {
   // - The sorting is applied
   // - The `paginationModel` is updated
   // - The rows are updated
+  const {
+    schedule: deferredUpdateRowSpanningState,
+    cancel
+  } = useRunOncePerLoop(updateRowSpanningState);
   const resetRowSpanningState = React.useCallback(() => {
     const renderContext = gridRenderContextSelector(apiRef);
     if (!isRowContextInitialized(renderContext)) {
       return;
     }
-    updateRowSpanningState(renderContext, true);
-  }, [apiRef, updateRowSpanningState]);
-  useGridEvent(apiRef, 'renderedRowsIntervalChange', runIf(props.rowSpanning, updateRowSpanningState));
+    deferredUpdateRowSpanningState(renderContext, true);
+  }, [apiRef, deferredUpdateRowSpanningState]);
+  useGridEvent(apiRef, 'renderedRowsIntervalChange', runIf(props.rowSpanning, renderContext => {
+    const didHavePendingReset = cancel();
+    updateRowSpanningState(renderContext, didHavePendingReset);
+  }));
   useGridEvent(apiRef, 'sortedRowsSet', runIf(props.rowSpanning, resetRowSpanningState));
   useGridEvent(apiRef, 'paginationModelChange', runIf(props.rowSpanning, resetRowSpanningState));
   useGridEvent(apiRef, 'filteredRowsSet', runIf(props.rowSpanning, resetRowSpanningState));
   useGridEvent(apiRef, 'columnsChange', runIf(props.rowSpanning, resetRowSpanningState));
   React.useEffect(() => {
+    const store = apiRef.current.virtualizer?.store;
+    if (!store) {
+      return;
+    }
     if (!props.rowSpanning) {
       if (store.state.rowSpanning !== EMPTY_STATE) {
         store.set('rowSpanning', EMPTY_STATE);
       }
-    } else if (store.state.rowSpanning.caches === EMPTY_CACHES) {
-      resetRowSpanningState();
+    } else if (store.state.rowSpanning === EMPTY_STATE) {
+      updateRowSpanningState(gridRenderContextSelector(apiRef));
     }
-  }, [apiRef, store, resetRowSpanningState, props.rowSpanning]);
+  }, [apiRef, props.rowSpanning, updateRowSpanningState]);
 };

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

@@ -2,7 +2,6 @@ import * as React from 'react';
 import { useRtl } from '@mui/system/RtlProvider';
 import { useGridLogger } from "../../utils/useGridLogger.js";
 import { gridColumnPositionsSelector, gridVisibleColumnDefinitionsSelector } from "../columns/gridColumnsSelector.js";
-import { useGridSelector } from "../../utils/useGridSelector.js";
 import { gridPageSelector, gridPageSizeSelector } from "../pagination/gridPaginationSelector.js";
 import { gridRowCountSelector } from "../rows/gridRowsSelector.js";
 import { gridRowsMetaSelector } from "../rows/gridRowsMetaSelector.js";
@@ -47,7 +46,6 @@ export const useGridScroll = (apiRef, props) => {
   const logger = useGridLogger(apiRef, 'useGridScroll');
   const colRef = apiRef.current.columnHeadersContainerRef;
   const virtualScrollerRef = apiRef.current.virtualScrollerRef;
-  const visibleSortedRows = useGridSelector(apiRef, gridExpandedSortedRowEntriesSelector);
   const scrollToIndexes = React.useCallback(params => {
     const dimensions = gridDimensionsSelector(apiRef);
     const totalRowCount = gridRowCountSelector(apiRef);
@@ -62,6 +60,7 @@ export const useGridScroll = (apiRef, props) => {
       const columnPositions = gridColumnPositionsSelector(apiRef);
       let cellWidth;
       if (typeof params.rowIndex !== 'undefined') {
+        const visibleSortedRows = gridExpandedSortedRowEntriesSelector(apiRef);
         const rowId = visibleSortedRows[params.rowIndex]?.id;
         const cellColSpanInfo = apiRef.current.unstable_getCellColSpanInfo(rowId, params.colIndex);
         if (cellColSpanInfo && !cellColSpanInfo.spannedByColSpan) {
@@ -98,7 +97,7 @@ export const useGridScroll = (apiRef, props) => {
       return true;
     }
     return false;
-  }, [logger, apiRef, virtualScrollerRef, props.pagination, visibleSortedRows]);
+  }, [logger, apiRef, virtualScrollerRef, props.pagination]);
   const scroll = React.useCallback(params => {
     if (virtualScrollerRef.current && params.left !== undefined && colRef.current) {
       const direction = isRtl ? -1 : 1;

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

@@ -7,4 +7,4 @@ export declare const sortingStateInitializer: GridStateInitializer<Pick<DataGrid
  * @requires useGridRows (event)
  * @requires useGridColumns (event)
  */
-export declare const useGridSorting: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "initialState" | "sortModel" | "onSortModelChange" | "sortingOrder" | "sortingMode" | "disableColumnSorting" | "disableMultipleColumnsSorting" | "multipleColumnsSortingMode">) => void;
+export declare const useGridSorting: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "initialState" | "sortModel" | "onSortModelChange" | "sortingOrder" | "sortingMode" | "disableColumnSorting" | "disableMultipleColumnsSorting" | "multipleColumnsSortingMode" | "signature">) => void;

package/esm/hooks/features/sorting/useGridSorting.js

@@ -236,7 +236,9 @@ export const useGridSorting = (apiRef, props) => {
    * 1ST RENDER
    */
   useFirstRender(() => {
-    apiRef.current.applySorting();
+    if (props.signature === 'DataGrid') {
+      apiRef.current.applySorting();
+    }
   });
 
   /**

package/esm/hooks/features/virtualization/useGridVirtualization.js

@@ -30,9 +30,6 @@ export const virtualizationStateInitializer = (state, props) => {
   });
 };
 export function useGridVirtualization(apiRef, rootProps) {
-  const {
-    virtualizer
-  } = apiRef.current;
   const {
     autoHeight,
     disableVirtualization
@@ -43,7 +40,14 @@ export function useGridVirtualization(apiRef, rootProps) {
    */
 
   const setVirtualization = enabled => {
+    const {
+      virtualizer
+    } = apiRef.current;
     enabled &&= HAS_LAYOUT;
+    const snapshot = virtualizer.store.getSnapshot();
+    if (snapshot.virtualization.enabled === enabled && snapshot.virtualization.enabledForRows === enabled && snapshot.virtualization.enabledForColumns === enabled) {
+      return;
+    }
     virtualizer.store.set('virtualization', _extends({}, virtualizer.store.state.virtualization, {
       enabled,
       enabledForColumns: enabled,
@@ -51,7 +55,14 @@ export function useGridVirtualization(apiRef, rootProps) {
     }));
   };
   const setColumnVirtualization = enabled => {
+    const {
+      virtualizer
+    } = apiRef.current;
     enabled &&= HAS_LAYOUT;
+    const snapshot = virtualizer.store.getSnapshot();
+    if (snapshot.virtualization.enabledForColumns === enabled) {
+      return;
+    }
     virtualizer.store.set('virtualization', _extends({}, virtualizer.store.state.virtualization, {
       enabledForColumns: enabled
     }));
@@ -61,7 +72,12 @@ export function useGridVirtualization(apiRef, rootProps) {
     unstable_setColumnVirtualization: setColumnVirtualization
   };
   useGridApiMethod(apiRef, api, 'public');
-  const forceUpdateRenderContext = virtualizer.api.forceUpdateRenderContext;
+  const forceUpdateRenderContext = () => {
+    const {
+      virtualizer
+    } = apiRef.current;
+    virtualizer?.api.scheduleUpdateRenderContext();
+  };
   apiRef.current.register('private', {
     updateRenderContext: forceUpdateRenderContext
   });
@@ -76,7 +92,10 @@ export function useGridVirtualization(apiRef, rootProps) {
 
   /* eslint-disable react-hooks/exhaustive-deps */
   React.useEffect(() => {
+    if (!apiRef.current.virtualizer) {
+      return;
+    }
     setVirtualization(!rootProps.disableVirtualization);
-  }, [disableVirtualization, autoHeight]);
+  }, [apiRef, disableVirtualization, autoHeight]);
   /* eslint-enable react-hooks/exhaustive-deps */
 }

package/esm/hooks/utils/useGridApiRef.d.ts

@@ -1,7 +1,6 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridApiCommon } from "../../models/index.js";
 import { GridApiCommunity } from "../../models/api/gridApiCommunity.js";
 /**
  * Hook that instantiate a [[GridApiRef]].
  */
-export declare const useGridApiRef: <Api extends GridApiCommon = GridApiCommunity>() => RefObject<Api | null>;
+export declare const useGridApiRef: () => RefObject<GridApiCommunity | null>;

package/esm/hooks/utils/useGridEvent.js

@@ -24,7 +24,9 @@ export function useGridEvent(apiRef, eventName, handler, options) {
   const cleanupTokenRef = React.useRef(null);
   if (!subscription.current && handlerRef.current) {
     const enhancedHandler = (params, event, details) => {
-      if (!event.defaultMuiPrevented) {
+      // Check for the existence of the event once more to avoid Safari 26 issue
+      // https://github.com/mui/mui-x/issues/20159
+      if (event && !event.defaultMuiPrevented) {
         handlerRef.current?.(params, event, details);
       }
     };
@@ -51,7 +53,9 @@ export function useGridEvent(apiRef, eventName, handler, options) {
   React.useEffect(() => {
     if (!subscription.current && handlerRef.current) {
       const enhancedHandler = (params, event, details) => {
-        if (!event.defaultMuiPrevented) {
+        // Check for the existence of the event once more to avoid Safari 26 issue
+        // https://github.com/mui/mui-x/issues/20159
+        if (event && !event.defaultMuiPrevented) {
           handlerRef.current?.(params, event, details);
         }
       };

package/esm/hooks/utils/useRunOncePerLoop.d.ts

@@ -1 +1,4 @@
-export declare function useRunOncePerLoop<T extends (...args: any[]) => void>(callback: T, nextFrame?: boolean): (...args: Parameters<T>) => void;
+export declare function useRunOncePerLoop<T extends (...args: any[]) => void>(callback: T): {
+  schedule: (...args: Parameters<T>) => void;
+  cancel: () => boolean;
+};

package/esm/hooks/utils/useRunOncePerLoop.js

@@ -1,26 +1,36 @@
+'use client';
+
 import * as React from 'react';
-export function useRunOncePerLoop(callback, nextFrame = false) {
-  const scheduledRef = React.useRef(false);
+export function useRunOncePerLoop(callback) {
+  const scheduledCallbackRef = React.useRef(null);
   const schedule = React.useCallback((...args) => {
-    if (scheduledRef.current) {
-      return;
+    // for robustness, a fallback in case we don't react to state updates and layoutEffect is not run
+    // if we react to state updates, layoutEffect will run before microtasks
+    if (!scheduledCallbackRef.current) {
+      queueMicrotask(() => {
+        if (scheduledCallbackRef.current) {
+          scheduledCallbackRef.current();
+        }
+      });
     }
-    scheduledRef.current = true;
-    const runner = () => {
-      scheduledRef.current = false;
+    scheduledCallbackRef.current = () => {
+      scheduledCallbackRef.current = null;
       callback(...args);
     };
-    if (nextFrame) {
-      if (typeof requestAnimationFrame === 'function') {
-        requestAnimationFrame(runner);
-      }
-      return;
+  }, [callback]);
+  React.useLayoutEffect(() => {
+    if (scheduledCallbackRef.current) {
+      scheduledCallbackRef.current();
     }
-    if (typeof queueMicrotask === 'function') {
-      queueMicrotask(runner);
-    } else {
-      Promise.resolve().then(runner);
+  });
+  return {
+    schedule,
+    cancel: () => {
+      if (scheduledCallbackRef.current) {
+        scheduledCallbackRef.current = null;
+        return true;
+      }
+      return false;
     }
-  }, [callback, nextFrame]);
-  return schedule;
+  };
 }

package/esm/index.js

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

package/esm/models/colDef/gridColDef.d.ts

@@ -257,6 +257,20 @@ export interface GridActionsColDef<R extends GridValidRowModel = any, V = any, F
    * Function that returns the actions to be shown.
    * @param {GridRowParams} params The params for each row.
    * @returns {readonly React.ReactElement<GridActionsCellItemProps>[]} An array of [[GridActionsCell]] elements.
+   * @deprecated Use `renderCell` instead
+   * @example
+   * // Before
+   * getActions: (params) => [
+   *   <GridActionsCellItem icon={...} onClick={...} label="Delete" />,
+   *   <GridActionsCellItem icon={...} onClick={...} label="Print" showInMenu />,
+   * ],
+   * // After
+   * renderCell: (params) => (
+   *   <GridActionsCell {...params}>
+   *     <GridActionsCellItem icon={...} onClick={...} label="Delete" />
+   *     <GridActionsCellItem icon={...} onClick={...} label="Print" showInMenu />
+   *   </GridActionsCell>
+   * ),
    */
   getActions: (params: GridRowParams<R>) => readonly React.ReactElement<GridActionsCellItemProps>[];
 }

package/esm/models/events/gridEventLookup.d.ts

@@ -516,6 +516,11 @@ export interface GridEventLookup extends GridRowEventLookup, GridColumnHeaderEve
    * @ignore - do not document
    */
   sortedRowsSet: {};
+  /**
+   * Fired when the aggregations are done
+   * @ignore - do not document
+   */
+  aggregationLookupSet: {};
   /**
    * Fired when the expansion of a row is changed. Called with a [[GridGroupNode]] object.
    */

package/esm/models/gridStateCommunity.d.ts

@@ -13,7 +13,7 @@ import type { GridRowReorderState } from "../hooks/features/rowReorder/gridRowRe
  * Some props are passed on the state to enable grid selectors to select
  * and react to them.
  */
-export type GridStateProps = Pick<DataGridProcessedProps, 'getRowId' | 'listView' | 'isCellEditable'>;
+export type GridStateProps = Pick<DataGridProcessedProps, 'getRowId' | 'listView' | 'isCellEditable' | 'isRowSelectable'>;
 /**
  * The state of Data Grid.
  */

package/esm/models/params/gridCellParams.d.ts

@@ -1,4 +1,3 @@
-import * as React from 'react';
 import { GridCellMode } from "../gridCell.js";
 import { GridRowId, GridRowModel, GridTreeNode, GridTreeNodeWithRender, GridValidRowModel } from "../gridRows.js";
 import type { GridStateColDef } from "../colDef/gridColDef.js";
@@ -58,9 +57,6 @@ export interface GridCellParams<R extends GridValidRowModel = any, V = unknown,
    */
   api: GridApiCommunity;
 }
-export interface FocusElement {
-  focus(): void;
-}
 /**
  * GridCellParams containing api.
  */
@@ -69,12 +65,6 @@ export interface GridRenderCellParams<R extends GridValidRowModel = any, V = any
    * GridApi that let you manipulate the grid.
    */
   api: GridApiCommunity;
-  /**
-   * A ref allowing to set imperative focus.
-   * It can be passed to the element that should receive focus.
-   * @ignore - do not document.
-   */
-  focusElementRef?: React.Ref<FocusElement>;
 }
 /**
  * GridEditCellProps containing api.

package/esm/models/props/DataGridProps.d.ts

@@ -79,13 +79,11 @@ export interface DataGridPropsWithComplexDefaultValueBeforeProcessing {
  */
 export interface DataGridPropsWithDefaultValues<R extends GridValidRowModel = any> {
   /**
-   * If `true`, the Data Grid height is dynamic and follows the number of rows in the Data Grid.
+   * If `true`, the Data Grid height is dynamic and takes as much space as it needs to display all rows.
+   * Use it instead of a flex parent container approach, if:
+   * - you don't need to set a minimum or maximum height for the Data Grid
+   * - you want to avoid the scrollbar flickering when the content changes
    * @default false
-   * @deprecated Use flex parent container instead: https://mui.com/x/react-data-grid/layout/#flex-parent-container
-   * @example
-   * <div style={{ display: 'flex', flexDirection: 'column' }}>
-   *   <DataGrid />
-   * </div>
    */
   autoHeight: boolean;
   /**
@@ -381,6 +379,15 @@ export interface DataGridPropsWithDefaultValues<R extends GridValidRowModel = an
    * @default false
    */
   virtualizeColumnsWithAutoRowHeight: boolean;
+  /**
+   * Sets the tab navigation behavior for the Data Grid.
+   * - "none": No Data Grid specific tab navigation. Pressing the tab key will move the focus to the next element in the tab sequence.
+   * - "content": Pressing the tab key will move the focus to the next cell in the same row or the first cell in the next row. Shift+Tab will move the focus to the previous cell in the same row or the last cell in the previous row. Tab navigation is not enabled for the header.
+   * - "header": Pressing the tab key will move the focus to the next column group, column header or header filter. Shift+Tab will move the focus to the previous column group, column header or header filter. Tab navigation is not enabled for the content.
+   * - "all": Combines the "content" and "header" behavior.
+   * @default "none"
+   */
+  tabNavigation: 'none' | 'content' | 'header' | 'all';
 }
 /**
  * The Data Grid props with no default value.

package/esm/utils/keyboardUtils.d.ts

@@ -1,14 +1,7 @@
 import * as React from 'react';
 export declare function isPrintableKey(event: React.KeyboardEvent<HTMLElement>): boolean;
-export declare const GRID_MULTIPLE_SELECTION_KEYS: string[];
-export declare const GRID_CELL_EXIT_EDIT_MODE_KEYS: string[];
-export declare const GRID_CELL_EDIT_COMMIT_KEYS: string[];
-export declare const isMultipleKey: (key: string) => boolean;
-export declare const isCellEnterEditModeKeys: (event: React.KeyboardEvent<HTMLElement>) => boolean;
-export declare const isCellExitEditModeKeys: (key: string) => boolean;
-export declare const isCellEditCommitKeys: (key: string) => boolean;
 export declare const isNavigationKey: (key: string) => boolean;
 export declare const isKeyboardEvent: (event: any) => event is React.KeyboardEvent<HTMLElement>;
-export declare const isHideMenuKey: (key: React.KeyboardEvent["key"]) => key is "Escape" | "Tab";
+export declare const isHideMenuKey: (key: React.KeyboardEvent["key"]) => key is "Tab" | "Escape";
 export declare function isPasteShortcut(event: React.KeyboardEvent): boolean;
 export declare function isCopyShortcut(event: KeyboardEvent): boolean;

package/esm/utils/keyboardUtils.js

@@ -8,13 +8,6 @@
 export function isPrintableKey(event) {
   return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
 }
-export const GRID_MULTIPLE_SELECTION_KEYS = ['Meta', 'Control', 'Shift'];
-export const GRID_CELL_EXIT_EDIT_MODE_KEYS = ['Enter', 'Escape', 'Tab'];
-export const GRID_CELL_EDIT_COMMIT_KEYS = ['Enter', 'Tab'];
-export const isMultipleKey = key => GRID_MULTIPLE_SELECTION_KEYS.indexOf(key) > -1;
-export const isCellEnterEditModeKeys = event => isPrintableKey(event) || event.key === 'Enter' || event.key === 'Backspace' || event.key === 'Delete';
-export const isCellExitEditModeKeys = key => GRID_CELL_EXIT_EDIT_MODE_KEYS.indexOf(key) > -1;
-export const isCellEditCommitKeys = key => GRID_CELL_EDIT_COMMIT_KEYS.indexOf(key) > -1;
 export const isNavigationKey = key => key.indexOf('Arrow') === 0 || key.indexOf('Page') === 0 || key === ' ' || key === 'Home' || key === 'End';
 export const isKeyboardEvent = event => !!event.key;
 export const isHideMenuKey = key => key === 'Tab' || key === 'Escape';

package/hooks/core/gridPropsSelectors.d.ts

@@ -6,4 +6,5 @@ import type { GridRowId } from "../../models/gridRows.js";
  * @param {GridRowModel} row - The row to get the id for
  * @returns {GridRowId} The row id
  */
-export declare const gridRowIdSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, import("@mui/x-data-grid").GridValidRowModel, GridRowId>;
+export declare const gridRowIdSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, import("@mui/x-data-grid").GridValidRowModel, GridRowId>;
+export declare const gridRowSelectableSelector: import("@mui/x-data-grid").OutputSelector<GridStateCommunity, unknown, ((params: import("@mui/x-data-grid").GridRowParams<any>) => boolean) | undefined>;

package/hooks/core/gridPropsSelectors.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.gridRowIdSelector = void 0;
+exports.gridRowSelectableSelector = exports.gridRowIdSelector = void 0;
 var _gridRowsUtils = require("../features/rows/gridRowsUtils");
 var _createSelector = require("../../utils/createSelector");
 /**
@@ -17,4 +17,7 @@ const gridRowIdSelector = exports.gridRowIdSelector = (0, _createSelector.create
     return row[_gridRowsUtils.GRID_ID_AUTOGENERATED];
   }
   return state.props.getRowId ? state.props.getRowId(row) : row.id;
+});
+const gridRowSelectableSelector = exports.gridRowSelectableSelector = (0, _createSelector.createRootSelector)(state => {
+  return state.props.isRowSelectable;
 });

package/hooks/core/useGridProps.js

@@ -20,14 +20,20 @@ const propsStateInitializer = (state, props) => {
 };
 exports.propsStateInitializer = propsStateInitializer;
 const useGridProps = (apiRef, props) => {
+  const isFirstRender = React.useRef(true);
   React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+      return;
+    }
     apiRef.current.setState(state => (0, _extends2.default)({}, state, {
       props: {
         listView: props.listView,
         getRowId: props.getRowId,
-        isCellEditable: props.isCellEditable
+        isCellEditable: props.isCellEditable,
+        isRowSelectable: props.isRowSelectable
       }
     }));
-  }, [apiRef, props.listView, props.getRowId, props.isCellEditable]);
+  }, [apiRef, props.listView, props.getRowId, props.isCellEditable, props.isRowSelectable]);
 };
 exports.useGridProps = useGridProps;