@mui/x-data-grid 8.0.0-alpha.11 → 8.0.0-alpha.13

package/hooks/features/sorting/index.js

@@ -1,2 +1,49 @@
-export { gridSortedRowIdsSelector, gridSortedRowEntriesSelector, gridSortModelSelector, gridSortColumnLookupSelector } from "./gridSortingSelector.js";
-export { gridDateComparator, gridNumberComparator, gridStringOrNumberComparator } from "./gridSortingUtils.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "gridDateComparator", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingUtils.gridDateComparator;
+  }
+});
+Object.defineProperty(exports, "gridNumberComparator", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingUtils.gridNumberComparator;
+  }
+});
+Object.defineProperty(exports, "gridSortColumnLookupSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingSelector.gridSortColumnLookupSelector;
+  }
+});
+Object.defineProperty(exports, "gridSortModelSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingSelector.gridSortModelSelector;
+  }
+});
+Object.defineProperty(exports, "gridSortedRowEntriesSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingSelector.gridSortedRowEntriesSelector;
+  }
+});
+Object.defineProperty(exports, "gridSortedRowIdsSelector", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingSelector.gridSortedRowIdsSelector;
+  }
+});
+Object.defineProperty(exports, "gridStringOrNumberComparator", {
+  enumerable: true,
+  get: function () {
+    return _gridSortingUtils.gridStringOrNumberComparator;
+  }
+});
+var _gridSortingSelector = require("./gridSortingSelector");
+var _gridSortingUtils = require("./gridSortingUtils");

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

@@ -1,10 +1,10 @@
 import { RefObject } from '@mui/x-internals/types';
-import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
-import { GridPrivateApiCommunity } from '../../../models/api/gridApiCommunity';
-import { GridStateInitializer } from '../../utils/useGridInitializeState';
+import { DataGridProcessedProps } from "../../../models/props/DataGridProps.js";
+import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
+import { GridStateInitializer } from "../../utils/useGridInitializeState.js";
 export declare const sortingStateInitializer: GridStateInitializer<Pick<DataGridProcessedProps, 'sortModel' | 'initialState' | 'disableMultipleColumnsSorting'>>;
 /**
  * @requires useGridRows (event)
  * @requires useGridColumns (event)
  */
-export declare const useGridSorting: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "initialState" | "sortModel" | "onSortModelChange" | "sortingOrder" | "sortingMode" | "disableColumnSorting" | "disableMultipleColumnsSorting">) => void;
+export declare const useGridSorting: (apiRef: RefObject<GridPrivateApiCommunity>, props: Pick<DataGridProcessedProps, "initialState" | "sortModel" | "onSortModelChange" | "sortingOrder" | "sortingMode" | "disableColumnSorting" | "disableMultipleColumnsSorting">) => void;

package/hooks/features/sorting/useGridSorting.js

@@ -1,22 +1,30 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { unstable_useEnhancedEffect as useEnhancedEffect } from '@mui/utils';
-import { useGridApiEventHandler } from "../../utils/useGridApiEventHandler.js";
-import { useGridApiMethod } from "../../utils/useGridApiMethod.js";
-import { useGridLogger } from "../../utils/useGridLogger.js";
-import { gridColumnLookupSelector } from "../columns/gridColumnsSelector.js";
-import { gridSortedRowEntriesSelector, gridSortedRowIdsSelector, gridSortModelSelector } from "./gridSortingSelector.js";
-import { GRID_ROOT_GROUP_ID, gridRowTreeSelector } from "../rows/index.js";
-import { useFirstRender } from "../../utils/useFirstRender.js";
-import { useGridRegisterStrategyProcessor, GRID_DEFAULT_STRATEGY } from "../../core/strategyProcessing/index.js";
-import { buildAggregatedSortingApplier, mergeStateWithSortModel, getNextGridSortDirection, sanitizeSortModel } from "./gridSortingUtils.js";
-import { useGridRegisterPipeProcessor } from "../../core/pipeProcessing/index.js";
-import { getTreeNodeDescendants } from "../rows/gridRowsUtils.js";
-export const sortingStateInitializer = (state, props) => {
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridSorting = exports.sortingStateInitializer = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var React = _interopRequireWildcard(require("react"));
+var _utils = require("@mui/utils");
+var _useGridApiEventHandler = require("../../utils/useGridApiEventHandler");
+var _useGridApiMethod = require("../../utils/useGridApiMethod");
+var _useGridLogger = require("../../utils/useGridLogger");
+var _gridColumnsSelector = require("../columns/gridColumnsSelector");
+var _gridSortingSelector = require("./gridSortingSelector");
+var _rows = require("../rows");
+var _useFirstRender = require("../../utils/useFirstRender");
+var _strategyProcessing = require("../../core/strategyProcessing");
+var _gridSortingUtils = require("./gridSortingUtils");
+var _pipeProcessing = require("../../core/pipeProcessing");
+var _gridRowsUtils = require("../rows/gridRowsUtils");
+const sortingStateInitializer = (state, props) => {
   const sortModel = props.sortModel ?? props.initialState?.sorting?.sortModel ?? [];
-  return _extends({}, state, {
+  return (0, _extends2.default)({}, state, {
     sorting: {
-      sortModel: sanitizeSortModel(sortModel, props.disableMultipleColumnsSorting),
+      sortModel: (0, _gridSortingUtils.sanitizeSortModel)(sortModel, props.disableMultipleColumnsSorting),
       sortedRows: []
     }
   });
@@ -26,17 +34,18 @@ export const sortingStateInitializer = (state, props) => {
  * @requires useGridRows (event)
  * @requires useGridColumns (event)
  */
-export const useGridSorting = (apiRef, props) => {
-  const logger = useGridLogger(apiRef, 'useGridSorting');
+exports.sortingStateInitializer = sortingStateInitializer;
+const useGridSorting = (apiRef, props) => {
+  const logger = (0, _useGridLogger.useGridLogger)(apiRef, 'useGridSorting');
   apiRef.current.registerControlState({
     stateId: 'sortModel',
     propModel: props.sortModel,
     propOnChange: props.onSortModelChange,
-    stateSelector: gridSortModelSelector,
+    stateSelector: _gridSortingSelector.gridSortModelSelector,
     changeEvent: 'sortModelChange'
   });
   const upsertSortModel = React.useCallback((field, sortItem) => {
-    const sortModel = gridSortModelSelector(apiRef);
+    const sortModel = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
     const existingIdx = sortModel.findIndex(c => c.field === field);
     let newSortModel = [...sortModel];
     if (existingIdx > -1) {
@@ -51,17 +60,17 @@ export const useGridSorting = (apiRef, props) => {
     return newSortModel;
   }, [apiRef]);
   const createSortItem = React.useCallback((col, directionOverride) => {
-    const sortModel = gridSortModelSelector(apiRef);
+    const sortModel = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
     const existing = sortModel.find(c => c.field === col.field);
     if (existing) {
-      const nextSort = directionOverride === undefined ? getNextGridSortDirection(col.sortingOrder ?? props.sortingOrder, existing.sort) : directionOverride;
-      return nextSort === undefined ? undefined : _extends({}, existing, {
+      const nextSort = directionOverride === undefined ? (0, _gridSortingUtils.getNextGridSortDirection)(col.sortingOrder ?? props.sortingOrder, existing.sort) : directionOverride;
+      return nextSort === undefined ? undefined : (0, _extends2.default)({}, existing, {
         sort: nextSort
       });
     }
     return {
       field: col.field,
-      sort: directionOverride === undefined ? getNextGridSortDirection(col.sortingOrder ?? props.sortingOrder) : directionOverride
+      sort: directionOverride === undefined ? (0, _gridSortingUtils.getNextGridSortDirection)(col.sortingOrder ?? props.sortingOrder) : directionOverride
     };
   }, [apiRef, props.sortingOrder]);
   const addColumnMenuItem = React.useCallback((columnMenuItems, colDef) => {
@@ -82,32 +91,30 @@ export const useGridSorting = (apiRef, props) => {
     apiRef.current.setState(state => {
       if (props.sortingMode === 'server') {
         logger.debug('Skipping sorting rows as sortingMode = server');
-        return _extends({}, state, {
-          sorting: _extends({}, state.sorting, {
-            sortedRows: getTreeNodeDescendants(gridRowTreeSelector(apiRef), GRID_ROOT_GROUP_ID, false)
+        return (0, _extends2.default)({}, state, {
+          sorting: (0, _extends2.default)({}, state.sorting, {
+            sortedRows: (0, _gridRowsUtils.getTreeNodeDescendants)((0, _rows.gridRowTreeSelector)(apiRef), _rows.GRID_ROOT_GROUP_ID, false)
           })
         });
       }
-      const sortModel = gridSortModelSelector(state, undefined, apiRef.current.instanceId);
-      const sortRowList = buildAggregatedSortingApplier(sortModel, apiRef);
+      const sortModel = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
+      const sortRowList = (0, _gridSortingUtils.buildAggregatedSortingApplier)(sortModel, apiRef);
       const sortedRows = apiRef.current.applyStrategyProcessor('sorting', {
         sortRowList
       });
-      return _extends({}, state, {
-        sorting: _extends({}, state.sorting, {
+      return (0, _extends2.default)({}, state, {
+        sorting: (0, _extends2.default)({}, state.sorting, {
           sortedRows
         })
       });
     });
     apiRef.current.publishEvent('sortedRowsSet');
-    apiRef.current.forceUpdate();
   }, [apiRef, logger, props.sortingMode]);
   const setSortModel = React.useCallback(model => {
-    const currentModel = gridSortModelSelector(apiRef);
+    const currentModel = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
     if (currentModel !== model) {
       logger.debug(`Setting sort model`);
-      apiRef.current.setState(mergeStateWithSortModel(model, props.disableMultipleColumnsSorting));
-      apiRef.current.forceUpdate();
+      apiRef.current.setState((0, _gridSortingUtils.mergeStateWithSortModel)(model, props.disableMultipleColumnsSorting));
       apiRef.current.applySorting();
     }
   }, [apiRef, logger, props.disableMultipleColumnsSorting]);
@@ -122,12 +129,12 @@ export const useGridSorting = (apiRef, props) => {
     }
     apiRef.current.setSortModel(sortModel);
   }, [apiRef, upsertSortModel, createSortItem, props.disableMultipleColumnsSorting]);
-  const getSortModel = React.useCallback(() => gridSortModelSelector(apiRef), [apiRef]);
+  const getSortModel = React.useCallback(() => (0, _gridSortingSelector.gridSortModelSelector)(apiRef), [apiRef]);
   const getSortedRows = React.useCallback(() => {
-    const sortedRows = gridSortedRowEntriesSelector(apiRef);
+    const sortedRows = (0, _gridSortingSelector.gridSortedRowEntriesSelector)(apiRef);
     return sortedRows.map(row => row.model);
   }, [apiRef]);
-  const getSortedRowIds = React.useCallback(() => gridSortedRowIdsSelector(apiRef), [apiRef]);
+  const getSortedRowIds = React.useCallback(() => (0, _gridSortingSelector.gridSortedRowIdsSelector)(apiRef), [apiRef]);
   const getRowIdFromRowIndex = React.useCallback(index => apiRef.current.getSortedRowIds()[index], [apiRef]);
   const sortApi = {
     getSortModel,
@@ -138,13 +145,13 @@ export const useGridSorting = (apiRef, props) => {
     sortColumn,
     applySorting
   };
-  useGridApiMethod(apiRef, sortApi, 'public');
+  (0, _useGridApiMethod.useGridApiMethod)(apiRef, sortApi, 'public');
 
   /**
    * PRE-PROCESSING
    */
   const stateExportPreProcessing = React.useCallback((prevState, context) => {
-    const sortModelToExport = gridSortModelSelector(apiRef);
+    const sortModelToExport = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
     const shouldExportSortModel =
     // Always export if the `exportOnlyDirtyModels` property is not activated
     !context.exportOnlyDirtyModels ||
@@ -157,7 +164,7 @@ export const useGridSorting = (apiRef, props) => {
     if (!shouldExportSortModel) {
       return prevState;
     }
-    return _extends({}, prevState, {
+    return (0, _extends2.default)({}, prevState, {
       sorting: {
         sortModel: sortModelToExport
       }
@@ -168,23 +175,23 @@ export const useGridSorting = (apiRef, props) => {
     if (sortModel == null) {
       return params;
     }
-    apiRef.current.setState(mergeStateWithSortModel(sortModel, props.disableMultipleColumnsSorting));
-    return _extends({}, params, {
+    apiRef.current.setState((0, _gridSortingUtils.mergeStateWithSortModel)(sortModel, props.disableMultipleColumnsSorting));
+    return (0, _extends2.default)({}, params, {
       callbacks: [...params.callbacks, apiRef.current.applySorting]
     });
   }, [apiRef, props.disableMultipleColumnsSorting]);
   const flatSortingMethod = React.useCallback(params => {
-    const rowTree = gridRowTreeSelector(apiRef);
-    const rootGroupNode = rowTree[GRID_ROOT_GROUP_ID];
+    const rowTree = (0, _rows.gridRowTreeSelector)(apiRef);
+    const rootGroupNode = rowTree[_rows.GRID_ROOT_GROUP_ID];
     const sortedChildren = params.sortRowList ? params.sortRowList(rootGroupNode.children.map(childId => rowTree[childId])) : [...rootGroupNode.children];
     if (rootGroupNode.footerId != null) {
       sortedChildren.push(rootGroupNode.footerId);
     }
     return sortedChildren;
   }, [apiRef]);
-  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
-  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
-  useGridRegisterStrategyProcessor(apiRef, GRID_DEFAULT_STRATEGY, 'sorting', flatSortingMethod);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'exportState', stateExportPreProcessing);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'restoreState', stateRestorePreProcessing);
+  (0, _strategyProcessing.useGridRegisterStrategyProcessor)(apiRef, _strategyProcessing.GRID_DEFAULT_STRATEGY, 'sorting', flatSortingMethod);
 
   /**
    * EVENTS
@@ -213,8 +220,8 @@ export const useGridSorting = (apiRef, props) => {
   }, [sortColumn, props.disableColumnSorting]);
   const handleColumnsChange = React.useCallback(() => {
     // When the columns change we check that the sorted columns are still part of the dataset
-    const sortModel = gridSortModelSelector(apiRef);
-    const latestColumns = gridColumnLookupSelector(apiRef);
+    const sortModel = (0, _gridSortingSelector.gridSortModelSelector)(apiRef);
+    const latestColumns = (0, _gridColumnsSelector.gridColumnLookupSelector)(apiRef);
     if (sortModel.length > 0) {
       const newModel = sortModel.filter(sortItem => latestColumns[sortItem.field]);
       if (newModel.length < sortModel.length) {
@@ -227,26 +234,27 @@ export const useGridSorting = (apiRef, props) => {
       apiRef.current.applySorting();
     }
   }, [apiRef]);
-  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuItem);
-  useGridApiEventHandler(apiRef, 'columnHeaderClick', handleColumnHeaderClick);
-  useGridApiEventHandler(apiRef, 'columnHeaderKeyDown', handleColumnHeaderKeyDown);
-  useGridApiEventHandler(apiRef, 'rowsSet', apiRef.current.applySorting);
-  useGridApiEventHandler(apiRef, 'columnsChange', handleColumnsChange);
-  useGridApiEventHandler(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
+  (0, _pipeProcessing.useGridRegisterPipeProcessor)(apiRef, 'columnMenu', addColumnMenuItem);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'columnHeaderClick', handleColumnHeaderClick);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'columnHeaderKeyDown', handleColumnHeaderKeyDown);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'rowsSet', apiRef.current.applySorting);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'columnsChange', handleColumnsChange);
+  (0, _useGridApiEventHandler.useGridApiEventHandler)(apiRef, 'activeStrategyProcessorChange', handleStrategyProcessorChange);
 
   /**
    * 1ST RENDER
    */
-  useFirstRender(() => {
+  (0, _useFirstRender.useFirstRender)(() => {
     apiRef.current.applySorting();
   });
 
   /**
    * EFFECTS
    */
-  useEnhancedEffect(() => {
+  (0, _utils.unstable_useEnhancedEffect)(() => {
     if (props.sortModel !== undefined) {
       apiRef.current.setSortModel(props.sortModel);
     }
   }, [apiRef, props.sortModel]);
-};
+};
+exports.useGridSorting = useGridSorting;

package/hooks/features/statePersistence/gridStatePersistenceInterface.d.ts

@@ -1,24 +1,24 @@
-import { GridInitialStateCommunity } from '../../../models/gridStateCommunity';
+import { GridInitialStateCommunity } from "../../../models/gridStateCommunity.js";
 export interface GridStatePersistenceApi<InitialState extends GridInitialStateCommunity> {
-    /**
-     * Generates a serializable object containing the exportable parts of the DataGrid state.
-     * These values can then be passed to the `initialState` prop or injected using the `restoreState` method.
-     * @param {GridExportStateParams} params With all properties from [[GridExportStateParams]]
-     * @returns {GridInitialState} The exported state.
-     */
-    exportState: (params?: GridExportStateParams) => InitialState;
-    /**
-     * Inject the given values into the state of the DataGrid.
-     * @param {GridInitialState} stateToRestore The exported state to restore.
-     */
-    restoreState: (stateToRestore: InitialState) => void;
+  /**
+   * Generates a serializable object containing the exportable parts of the DataGrid state.
+   * These values can then be passed to the `initialState` prop or injected using the `restoreState` method.
+   * @param {GridExportStateParams} params With all properties from [[GridExportStateParams]]
+   * @returns {GridInitialState} The exported state.
+   */
+  exportState: (params?: GridExportStateParams) => InitialState;
+  /**
+   * Inject the given values into the state of the DataGrid.
+   * @param {GridInitialState} stateToRestore The exported state to restore.
+   */
+  restoreState: (stateToRestore: InitialState) => void;
 }
 export interface GridRestoreStatePreProcessingValue {
-    /**
-     * Functions to run after the state has been updated but before re-rendering.
-     * This is usually used to apply derived states like `applyFilters` or `applySorting`
-     */
-    callbacks: (() => void)[];
+  /**
+   * Functions to run after the state has been updated but before re-rendering.
+   * This is usually used to apply derived states like `applyFilters` or `applySorting`
+   */
+  callbacks: (() => void)[];
 }
 /**
  * Object passed as parameter in the `exportState()` grid API method.
@@ -26,15 +26,15 @@ export interface GridRestoreStatePreProcessingValue {
  *   - [Restore state with `apiRef`](/x/react-data-grid/state/#restore-the-state-with-apiref)
  */
 export interface GridExportStateParams {
-    /**
-     * By default, the grid exports all the models.
-     * You can switch this property to `true` to only exports models that are either controlled, initialized or modified.
-     * For instance, with this property, if you don't control or initialize the `filterModel` and you did not apply any filter, the model won't be exported.
-     * Note that the column dimensions are not a model. The grid only exports the dimensions of the modified columns even when `exportOnlyDirtyModels` is false.
-     * @default false
-     */
-    exportOnlyDirtyModels?: boolean;
+  /**
+   * By default, the grid exports all the models.
+   * You can switch this property to `true` to only exports models that are either controlled, initialized or modified.
+   * For instance, with this property, if you don't control or initialize the `filterModel` and you did not apply any filter, the model won't be exported.
+   * Note that the column dimensions are not a model. The grid only exports the dimensions of the modified columns even when `exportOnlyDirtyModels` is false.
+   * @default false
+   */
+  exportOnlyDirtyModels?: boolean;
 }
 export interface GridRestoreStatePreProcessingContext<I extends GridInitialStateCommunity> {
-    stateToRestore: I;
-}
+  stateToRestore: I;
+}

package/hooks/features/statePersistence/gridStatePersistenceInterface.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/hooks/features/statePersistence/index.d.ts

@@ -1 +1 @@
-export type { GridStatePersistenceApi, GridExportStateParams, } from './gridStatePersistenceInterface';
+export type { GridStatePersistenceApi, GridExportStateParams } from './gridStatePersistenceInterface';

package/hooks/features/statePersistence/index.js

@@ -1 +1,5 @@
-export {};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/hooks/features/statePersistence/useGridStatePersistence.d.ts

@@ -1,3 +1,3 @@
 import { RefObject } from '@mui/x-internals/types';
-import { GridPrivateApiCommunity } from '../../../models/api/gridApiCommunity';
-export declare const useGridStatePersistence: (apiRef: RefObject<GridPrivateApiCommunity>) => void;
+import { GridPrivateApiCommunity } from "../../../models/api/gridApiCommunity.js";
+export declare const useGridStatePersistence: (apiRef: RefObject<GridPrivateApiCommunity>) => void;

package/hooks/features/statePersistence/useGridStatePersistence.js

@@ -1,6 +1,13 @@
-import * as React from 'react';
-import { useGridApiMethod } from "../../utils/index.js";
-export const useGridStatePersistence = apiRef => {
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridStatePersistence = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _utils = require("../../utils");
+const useGridStatePersistence = apiRef => {
   const exportState = React.useCallback((params = {}) => {
     const stateToExport = apiRef.current.unstable_applyPipeProcessors('exportState', {}, params);
     return stateToExport;
@@ -14,11 +21,11 @@ export const useGridStatePersistence = apiRef => {
     response.callbacks.forEach(callback => {
       callback();
     });
-    apiRef.current.forceUpdate();
   }, [apiRef]);
   const statePersistenceApi = {
     exportState,
     restoreState
   };
-  useGridApiMethod(apiRef, statePersistenceApi, 'public');
-};
+  (0, _utils.useGridApiMethod)(apiRef, statePersistenceApi, 'public');
+};
+exports.useGridStatePersistence = useGridStatePersistence;

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

@@ -1,6 +1,6 @@
 export declare const gridFocusedVirtualCellSelector: import("../../..").OutputSelector<import("../../../models/gridStateCommunity").GridStateCommunity, import("../../..").GridCellCoordinates | null, {
-    rowIndex: number;
-    columnIndex: number;
-    id?: import("../../..").GridRowId | undefined;
-    field?: string | undefined;
-} | null>;
+  rowIndex: number;
+  columnIndex: number;
+  id?: import("../../..").GridRowId | undefined;
+  field?: string | undefined;
+} | null>;

package/hooks/features/virtualization/gridFocusedVirtualCellSelector.js

@@ -1,11 +1,17 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createSelector } from 'reselect';
-import { createSelectorMemoized } from "../../../utils/createSelector.js";
-import { gridVisibleColumnDefinitionsSelector } from "../columns/gridColumnsSelector.js";
-import { gridRenderContextSelector } from "./gridVirtualizationSelectors.js";
-import { gridFocusCellSelector } from "../focus/index.js";
-import { gridVisibleRowsSelector } from "../pagination/index.js";
-const gridIsFocusedCellOutOfContext = createSelector(gridFocusCellSelector, gridRenderContextSelector, gridVisibleRowsSelector, gridVisibleColumnDefinitionsSelector, (focusedCell, renderContext, currentPage, visibleColumns) => {
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridFocusedVirtualCellSelector = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _createSelector = require("../../../utils/createSelector");
+var _gridColumnsSelector = require("../columns/gridColumnsSelector");
+var _gridVirtualizationSelectors = require("./gridVirtualizationSelectors");
+var _focus = require("../focus");
+var _pagination = require("../pagination");
+const gridIsFocusedCellOutOfContext = (0, _createSelector.createSelector)(_focus.gridFocusCellSelector, _gridVirtualizationSelectors.gridRenderContextSelector, _pagination.gridVisibleRowsSelector, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector, (focusedCell, renderContext, currentPage, visibleColumns) => {
   if (!focusedCell) {
     return false;
   }
@@ -14,7 +20,7 @@ const gridIsFocusedCellOutOfContext = createSelector(gridFocusCellSelector, grid
   const isInRenderContext = rowIndex !== undefined && columnIndex !== -1 && rowIndex >= renderContext.firstRowIndex && rowIndex <= renderContext.lastRowIndex;
   return !isInRenderContext;
 });
-export const gridFocusedVirtualCellSelector = createSelectorMemoized(gridIsFocusedCellOutOfContext, gridVisibleColumnDefinitionsSelector, gridVisibleRowsSelector, gridFocusCellSelector, (isFocusedCellOutOfRenderContext, visibleColumns, currentPage, focusedCell) => {
+const gridFocusedVirtualCellSelector = exports.gridFocusedVirtualCellSelector = (0, _createSelector.createSelectorMemoized)(gridIsFocusedCellOutOfContext, _gridColumnsSelector.gridVisibleColumnDefinitionsSelector, _pagination.gridVisibleRowsSelector, _focus.gridFocusCellSelector, (isFocusedCellOutOfRenderContext, visibleColumns, currentPage, focusedCell) => {
   if (!isFocusedCellOutOfRenderContext) {
     return null;
   }
@@ -26,7 +32,7 @@ export const gridFocusedVirtualCellSelector = createSelectorMemoized(gridIsFocus
   if (columnIndex === -1) {
     return null;
   }
-  return _extends({}, focusedCell, {
+  return (0, _extends2.default)({}, focusedCell, {
     rowIndex,
     columnIndex
   });

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

@@ -1,10 +1,10 @@
 import type { GridColumnsRenderContext } from '../../../models/params/gridScrollParams';
-import type { GridStateCommunity } from '../../../models/gridStateCommunity';
+import { GridStateCommunity } from "../../../models/gridStateCommunity.js";
 /**
  * Get the columns state
  * @category Virtualization
  */
-export declare const gridVirtualizationSelector: (state: GridStateCommunity) => import("./useGridVirtualization").GridVirtualizationState;
+export declare const gridVirtualizationSelector: import("../../..").OutputSelector<GridStateCommunity, unknown, import("./useGridVirtualization").GridVirtualizationState>;
 /**
  * Get the enabled state for virtualization
  * @category Virtualization
@@ -33,4 +33,4 @@ export declare const gridRenderContextSelector: import("../../..").OutputSelecto
  * @category Virtualization
  * @ignore - do not document.
  */
-export declare const gridRenderContextColumnsSelector: import("../../..").OutputSelector<GridStateCommunity, number, GridColumnsRenderContext>;
+export declare const gridRenderContextColumnsSelector: import("../../..").OutputSelector<GridStateCommunity, number, GridColumnsRenderContext>;

package/hooks/features/virtualization/gridVirtualizationSelectors.js

@@ -1,35 +1,41 @@
-import { createSelector, createSelectorMemoized } from "../../../utils/createSelector.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridVirtualizationSelector = exports.gridVirtualizationRowEnabledSelector = exports.gridVirtualizationEnabledSelector = exports.gridVirtualizationColumnEnabledSelector = exports.gridRenderContextSelector = exports.gridRenderContextColumnsSelector = void 0;
+var _createSelector = require("../../../utils/createSelector");
 /**
  * Get the columns state
  * @category Virtualization
  */
-export const gridVirtualizationSelector = state => state.virtualization;
+const gridVirtualizationSelector = exports.gridVirtualizationSelector = (0, _createSelector.createRootSelector)(state => state.virtualization);
 
 /**
  * Get the enabled state for virtualization
  * @category Virtualization
  * @deprecated Use `gridVirtualizationColumnEnabledSelector` and `gridVirtualizationRowEnabledSelector`
  */
-export const gridVirtualizationEnabledSelector = createSelector(gridVirtualizationSelector, state => state.enabled);
+const gridVirtualizationEnabledSelector = exports.gridVirtualizationEnabledSelector = (0, _createSelector.createSelector)(gridVirtualizationSelector, state => state.enabled);
 
 /**
  * Get the enabled state for column virtualization
  * @category Virtualization
  */
-export const gridVirtualizationColumnEnabledSelector = createSelector(gridVirtualizationSelector, state => state.enabledForColumns);
+const gridVirtualizationColumnEnabledSelector = exports.gridVirtualizationColumnEnabledSelector = (0, _createSelector.createSelector)(gridVirtualizationSelector, state => state.enabledForColumns);
 
 /**
  * Get the enabled state for row virtualization
  * @category Virtualization
  */
-export const gridVirtualizationRowEnabledSelector = createSelector(gridVirtualizationSelector, state => state.enabledForRows);
+const gridVirtualizationRowEnabledSelector = exports.gridVirtualizationRowEnabledSelector = (0, _createSelector.createSelector)(gridVirtualizationSelector, state => state.enabledForRows);
 
 /**
  * Get the render context
  * @category Virtualization
  * @ignore - do not document.
  */
-export const gridRenderContextSelector = createSelector(gridVirtualizationSelector, state => state.renderContext);
+const gridRenderContextSelector = exports.gridRenderContextSelector = (0, _createSelector.createSelector)(gridVirtualizationSelector, state => state.renderContext);
 
 /**
  * Get the render context, with only columns filled in.
@@ -37,7 +43,7 @@ export const gridRenderContextSelector = createSelector(gridVirtualizationSelect
  * @category Virtualization
  * @ignore - do not document.
  */
-export const gridRenderContextColumnsSelector = createSelectorMemoized(state => state.virtualization.renderContext.firstColumnIndex, state => state.virtualization.renderContext.lastColumnIndex, (firstColumnIndex, lastColumnIndex) => ({
+const gridRenderContextColumnsSelector = exports.gridRenderContextColumnsSelector = (0, _createSelector.createSelectorMemoized)(apiRef => apiRef.current.state.virtualization.renderContext.firstColumnIndex, apiRef => apiRef.current.state.virtualization.renderContext.lastColumnIndex, (firstColumnIndex, lastColumnIndex) => ({
   firstColumnIndex,
   lastColumnIndex
 }));

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

@@ -1,2 +1,2 @@
-export * from './useGridVirtualization';
-export * from './gridVirtualizationSelectors';
+export * from "./useGridVirtualization.js";
+export * from "./gridVirtualizationSelectors.js";

package/hooks/features/virtualization/index.js

@@ -1,2 +1,27 @@
-export * from "./useGridVirtualization.js";
-export * from "./gridVirtualizationSelectors.js";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _useGridVirtualization = require("./useGridVirtualization");
+Object.keys(_useGridVirtualization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useGridVirtualization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useGridVirtualization[key];
+    }
+  });
+});
+var _gridVirtualizationSelectors = require("./gridVirtualizationSelectors");
+Object.keys(_gridVirtualizationSelectors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _gridVirtualizationSelectors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridVirtualizationSelectors[key];
+    }
+  });
+});