@mui/x-data-grid 5.6.1 → 5.7.0

package/components/containers/GridRootStyles.js

@@ -108,11 +108,11 @@ export const GridRootStyles = styled('div', {
     [`&.${gridClasses.autoHeight}`]: {
       height: 'auto',
       [`& .${gridClasses['row--lastVisible']} .${gridClasses.cell}`]: {
-        borderColor: 'transparent'
+        borderBottomColor: 'transparent'
       }
     },
     [`& .${gridClasses['virtualScrollerContent--overflowed']} .${gridClasses['row--lastVisible']} .${gridClasses.cell}`]: {
-      borderColor: 'transparent'
+      borderBottomColor: 'transparent'
     },
     [`& .${gridClasses.columnHeader}, & .${gridClasses.cell}`]: {
       WebkitTapHighlightColor: 'transparent',

package/components/panel/GridColumnsPanel.d.ts

@@ -1,2 +1,5 @@
 /// <reference types="react" />
-export declare function GridColumnsPanel(): JSX.Element;
+import { GridPanelWrapperProps } from './GridPanelWrapper';
+export interface GridColumnsPanelProps extends GridPanelWrapperProps {
+}
+export declare function GridColumnsPanel(props: GridColumnsPanelProps): JSX.Element;

package/components/panel/GridColumnsPanel.js

@@ -54,7 +54,7 @@ const GridColumnsPanelRowRoot = styled('div', {
 const GridIconButtonRoot = styled(IconButton)({
   justifyContent: 'flex-end'
 });
-export function GridColumnsPanel() {
+export function GridColumnsPanel(props) {
   var _rootProps$components, _rootProps$components3, _rootProps$components4;
 
   const apiRef = useGridApiContext();
@@ -102,7 +102,7 @@ export function GridColumnsPanel() {
   React.useEffect(() => {
     searchInputRef.current.focus();
   }, []);
-  return /*#__PURE__*/_jsxs(GridPanelWrapper, {
+  return /*#__PURE__*/_jsxs(GridPanelWrapper, _extends({}, props, {
     children: [/*#__PURE__*/_jsx(GridPanelHeader, {
       children: /*#__PURE__*/_jsx(rootProps.components.BaseTextField, _extends({
         label: apiRef.current.getLocaleText('columnsPanelTextFieldLabel'),
@@ -155,5 +155,5 @@ export function GridColumnsPanel() {
         children: apiRef.current.getLocaleText('columnsPanelShowAllButton')
       }))]
     })]
-  });
+  }));
 }

package/components/panel/GridPanelWrapper.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Theme } from '@mui/material/styles';
 import { MUIStyledCommonProps } from '@mui/system';
-interface GridPanelWrapperProps extends React.PropsWithChildren<React.HTMLAttributes<HTMLDivElement>>, MUIStyledCommonProps<Theme> {
+export interface GridPanelWrapperProps extends React.PropsWithChildren<React.HTMLAttributes<HTMLDivElement>>, MUIStyledCommonProps<Theme> {
 }
 declare function GridPanelWrapper(props: GridPanelWrapperProps): JSX.Element;
 export { GridPanelWrapper };

package/components/panel/GridPreferencesPanel.js

@@ -7,21 +7,19 @@ import { GridPreferencePanelsValue } from '../../hooks/features/preferencesPanel
 import { useGridApiContext } from '../../hooks/utils/useGridApiContext';
 import { useGridRootProps } from '../../hooks/utils/useGridRootProps';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { jsxs as _jsxs } from "react/jsx-runtime";
 export const GridPreferencesPanel = /*#__PURE__*/React.forwardRef(function GridPreferencesPanel(props, ref) {
-  var _rootProps$components, _rootProps$components2, _rootProps$components3, _rootProps$components4;
+  var _preferencePanelState, _rootProps$components, _rootProps$components2;
 
   const apiRef = useGridApiContext();
   const columns = useGridSelector(apiRef, gridColumnDefinitionsSelector);
   const rootProps = useGridRootProps();
   const preferencePanelState = useGridSelector(apiRef, gridPreferencePanelStateSelector);
-  const isColumnsTabOpen = preferencePanelState.openedPanelValue === GridPreferencePanelsValue.columns;
-  const isFiltersTabOpen = !preferencePanelState.openedPanelValue || !isColumnsTabOpen;
-  return /*#__PURE__*/_jsxs(rootProps.components.Panel, _extends({
+  const panelContent = apiRef.current.unstable_applyPreProcessors('preferencePanel', null, (_preferencePanelState = preferencePanelState.openedPanelValue) != null ? _preferencePanelState : GridPreferencePanelsValue.filters);
+  return /*#__PURE__*/_jsx(rootProps.components.Panel, _extends({
     ref: ref,
     as: rootProps.components.BasePopper,
     open: columns.length > 0 && preferencePanelState.open
   }, (_rootProps$components = rootProps.componentsProps) == null ? void 0 : _rootProps$components.panel, props, (_rootProps$components2 = rootProps.componentsProps) == null ? void 0 : _rootProps$components2.basePopper, {
-    children: [!rootProps.disableColumnSelector && isColumnsTabOpen && /*#__PURE__*/_jsx(rootProps.components.ColumnsPanel, _extends({}, (_rootProps$components3 = rootProps.componentsProps) == null ? void 0 : _rootProps$components3.columnsPanel)), !rootProps.disableColumnFilter && isFiltersTabOpen && /*#__PURE__*/_jsx(rootProps.components.FilterPanel, _extends({}, (_rootProps$components4 = rootProps.componentsProps) == null ? void 0 : _rootProps$components4.filterPanel))]
+    children: panelContent
   }));
 });

package/hooks/core/preProcessing/gridPreProcessingApi.d.ts

@@ -1,32 +1,24 @@
-/// <reference types="react" />
+import * as React from 'react';
 import { GridCellIndexCoordinates, GridScrollParams } from '../../../models';
 import { GridInitialStateCommunity } from '../../../models/gridStateCommunity';
 import { GridColDef } from '../../../models/colDef/gridColDef';
 import { GridRestoreStatePreProcessingContext, GridRestoreStatePreProcessingValue } from '../../features/statePersistence/gridStatePersistenceInterface';
-import { GridFilteringMethodCollection } from '../../features/filter/gridFilterState';
-import { GridSortingMethodCollection } from '../../features/sorting/gridSortingState';
-import { GridColumnsRawState } from '../../features/columns/gridColumnsInterfaces';
+import { GridHydrateColumnsValue } from '../../features/columns/gridColumnsInterfaces';
 import { GridRowEntry } from '../../../models/gridRows';
-export declare type PreProcessorCallback = (value: any, params?: any) => any;
+import { GridPreferencePanelsValue } from '../../features/preferencesPanel';
 export declare type GridPreProcessingGroup = keyof GridPreProcessingGroupLookup;
 export interface GridPreProcessingGroupLookup {
     hydrateColumns: {
-        value: Omit<GridColumnsRawState, 'columnVisibilityModel'>;
+        value: GridHydrateColumnsValue;
     };
     scrollToIndexes: {
         value: Partial<GridScrollParams>;
         context: Partial<GridCellIndexCoordinates>;
     };
     columnMenu: {
-        value: JSX.Element[];
+        value: React.ReactNode[];
         context: GridColDef;
     };
-    filteringMethod: {
-        value: GridFilteringMethodCollection;
-    };
-    sortingMethod: {
-        value: GridSortingMethodCollection;
-    };
     exportState: {
         value: GridInitialStateCommunity;
     };
@@ -38,6 +30,10 @@ export interface GridPreProcessingGroupLookup {
         value: Record<string, number>;
         context: GridRowEntry;
     };
+    preferencePanel: {
+        value: React.ReactNode;
+        context: GridPreferencePanelsValue;
+    };
 }
 export declare type GridPreProcessor<P extends GridPreProcessingGroup> = (value: GridPreProcessingGroupLookup[P]['value'], context: GridPreProcessingGroupLookup[P] extends {
     context: any;
@@ -53,11 +49,11 @@ export interface GridPreProcessingApi {
      * Register a pre-processor and emit an event to notify the agents to re-apply the pre-processors.
      * @param {GridPreProcessingGroup} group The name of the group to bind this pre-processor to.
      * @param {number} id An unique and static identifier of the pre-processor.
-     * @param {PreProcessorCallback} callback The pre-processor to register.
+     * @param {GridPreProcessor} callback The pre-processor to register.
      * @returns {() => void} A function to unregister the pre-processor.
      * @ignore - do not document.
      */
-    unstable_registerPreProcessor: (group: GridPreProcessingGroup, id: string, callback: PreProcessorCallback) => () => void;
+    unstable_registerPreProcessor: <G extends GridPreProcessingGroup>(group: GridPreProcessingGroup, id: string, callback: GridPreProcessor<G>) => () => void;
     /**
      * Apply on the value the pre-processors registered on the given group.
      * @param {GridPreProcessingGroup} group The name of the processing group.

package/hooks/core/preProcessing/useGridPreProcessing.d.ts

@@ -1,3 +1,6 @@
 import * as React from 'react';
 import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+/**
+ * TODO: Rename `useGridPipProcessing`
+ */
 export declare const useGridPreProcessing: (apiRef: React.MutableRefObject<GridApiCommunity>) => void;

package/hooks/core/preProcessing/useGridPreProcessing.js

@@ -4,6 +4,10 @@ import _extends from "@babel/runtime/helpers/esm/extends";
 import * as React from 'react';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { GridEvents } from '../../../models/events';
+/**
+ * TODO: Rename `useGridPipProcessing`
+ */
+
 export const useGridPreProcessing = apiRef => {
   const preProcessorsRef = React.useRef({});
   const registerPreProcessor = React.useCallback((group, id, callback) => {
@@ -14,7 +18,7 @@ export const useGridPreProcessing = apiRef => {
     const preProcessors = preProcessorsRef.current[group];
     const oldCallback = preProcessors[id];
 
-    if (!oldCallback || oldCallback !== callback) {
+    if (oldCallback !== callback) {
       preProcessorsRef.current[group] = _extends({}, preProcessors, {
         [id]: callback
       });

package/hooks/core/preProcessing/useGridRegisterPreProcessor.d.ts

@@ -1,4 +1,7 @@
 import * as React from 'react';
 import { GridApiCommon } from '../../../models/api/gridApiCommon';
-import { GridPreProcessingGroup, PreProcessorCallback } from './gridPreProcessingApi';
-export declare const useGridRegisterPreProcessor: <Api extends GridApiCommon>(apiRef: React.MutableRefObject<Api>, group: GridPreProcessingGroup, callback: PreProcessorCallback) => void;
+import { GridPreProcessor } from './gridPreProcessingApi';
+/**
+ * TODO: Rename `useGridRegisterPipeProcessor`
+ */
+export declare const useGridRegisterPreProcessor: <Api extends GridApiCommon, G extends keyof import("./gridPreProcessingApi").GridPreProcessingGroupLookup>(apiRef: React.MutableRefObject<Api>, group: G, callback: GridPreProcessor<G>) => void;

package/hooks/core/preProcessing/useGridRegisterPreProcessor.js

@@ -1,5 +1,9 @@
 import * as React from 'react';
 import { useFirstRender } from '../../utils/useFirstRender';
+
+/**
+ * TODO: Rename `useGridRegisterPipeProcessor`
+ */
 export const useGridRegisterPreProcessor = (apiRef, group, callback) => {
   const cleanup = React.useRef();
   const id = React.useRef(`mui-${Math.round(Math.random() * 1e9)}`);

package/hooks/core/strategyProcessing/gridStrategyProcessingApi.d.ts

@@ -0,0 +1,58 @@
+import { GridRowTreeCreationParams, GridRowTreeCreationValue } from '../../features/rows/gridRowsState';
+import { GridFilteringMethodParams, GridFilteringMethodValue } from '../../features/filter/gridFilterState';
+import { GridSortingMethodParams, GridSortingMethodValue } from '../../features/sorting/gridSortingState';
+export declare type GridStrategyProcessorName = keyof GridStrategyProcessingLookup;
+export declare type GridStrategyGroup = GridStrategyProcessingLookup[keyof GridStrategyProcessingLookup]['group'];
+export interface GridStrategyProcessingLookup {
+    rowTreeCreation: {
+        group: 'rowTree';
+        params: GridRowTreeCreationParams;
+        value: GridRowTreeCreationValue;
+    };
+    filtering: {
+        group: 'rowTree';
+        params: GridFilteringMethodParams;
+        value: GridFilteringMethodValue;
+    };
+    sorting: {
+        group: 'rowTree';
+        params: GridSortingMethodParams;
+        value: GridSortingMethodValue;
+    };
+}
+export declare type GridStrategyProcessor<P extends GridStrategyProcessorName> = (params: GridStrategyProcessingLookup[P]['params']) => GridStrategyProcessingLookup[P]['value'];
+export interface GridStrategyProcessingApi {
+    /**
+     * Registers a strategy processor.
+     * If the strategy is active, it emits an event to notify the agents to re-apply the processor.
+     * @template P
+     * @param {string} strategyName The name of the strategy on which this processor should be applied.
+     * @param {GridStrategyProcessorName} processorName The name of the processor.
+     * @param {GridStrategyProcessor<P>} processor The processor to register.
+     * @returns {() => void} A function to unregister the processor.
+     * @ignore - do not document.
+     */
+    unstable_registerStrategyProcessor: <P extends GridStrategyProcessorName>(strategyName: string, processorName: P, callback: GridStrategyProcessor<P>) => () => void;
+    /**
+     * Set a callback to know if a strategy is available.
+     * @param {string} strategyName The name of the strategy.
+     * @param {boolean} callback A callback to know if this strategy is available.
+     * @ignore - do not document.
+     */
+    unstable_setStrategyAvailability: (strategyGroup: GridStrategyGroup, strategyName: string, callback: () => boolean) => void;
+    /**
+     * Returns the name of the active strategy of a given strategy group
+     * @param {GridStrategyGroup} strategyGroup The group from which we want the active strategy.
+     * @returns {string} The name of the active strategy.
+     * @ignore - do not document.
+     */
+    unstable_getActiveStrategy: (strategyGroup: GridStrategyGroup) => string;
+    /**
+     * Run the processor registered for the active strategy.
+     * @param {GridStrategyProcessorName} processorName The name of the processor to run.
+     * @param {GridStrategyProcessingLookup[P]['params']} params Additional params to pass to the processor.
+     * @returns {GridStrategyProcessingLookup[P]['value']} The value returned by the processor.
+     * @ignore - do not document.
+     */
+    unstable_applyStrategyProcessor: <P extends GridStrategyProcessorName>(processorName: P, params: GridStrategyProcessingLookup[P]['params']) => GridStrategyProcessingLookup[P]['value'];
+}

package/hooks/core/strategyProcessing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './gridStrategyProcessingApi';
+export * from './useGridRegisterStrategyProcessor';
+export * from './useGridStrategyProcessing';

package/hooks/core/strategyProcessing/index.js

@@ -0,0 +1,3 @@
+export * from './gridStrategyProcessingApi';
+export * from './useGridRegisterStrategyProcessor';
+export * from './useGridStrategyProcessing';

package/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommon } from '../../../models/api/gridApiCommon';
+import { GridStrategyProcessor } from './gridStrategyProcessingApi';
+export declare const useGridRegisterStrategyProcessor: <Api extends GridApiCommon, G extends keyof import("./gridStrategyProcessingApi").GridStrategyProcessingLookup>(apiRef: React.MutableRefObject<Api>, strategyName: string, group: G, processor: GridStrategyProcessor<G>) => void;

package/hooks/core/strategyProcessing/useGridRegisterStrategyProcessor.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { useFirstRender } from '../../utils/useFirstRender';
+export const useGridRegisterStrategyProcessor = (apiRef, strategyName, group, processor) => {
+  const registerPreProcessor = React.useCallback(() => {
+    apiRef.current.unstable_registerStrategyProcessor(strategyName, group, processor);
+  }, [apiRef, processor, group, strategyName]);
+  useFirstRender(() => {
+    registerPreProcessor();
+  });
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false;
+    } else {
+      registerPreProcessor();
+    }
+  }, [registerPreProcessor]);
+};

package/hooks/core/strategyProcessing/useGridStrategyProcessing.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+import { GridStrategyProcessorName, GridStrategyProcessingLookup } from './gridStrategyProcessingApi';
+export declare const GRID_DEFAULT_STRATEGY = "none";
+export declare const GRID_STRATEGIES_PROCESSORS: {
+    [P in GridStrategyProcessorName]: GridStrategyProcessingLookup[P]['group'];
+};
+/**
+ * Implements a variant of the Strategy Pattern (see https://en.wikipedia.org/wiki/Strategy_pattern)
+ *
+ * Some plugins contain custom logic that must only be run if the right strategy is active.
+ * For instance, the tree data plugin has:
+ * - custom row tree creation algorithm.
+ * - custom sorting algorithm.
+ * - custom filtering algorithm.
+ *
+ * These plugins must use:
+ * - `apiRef.current.unstable_registerStrategyProcessor` to register their processors.
+ * - `apiRef.current.unstable_setStrategyAvailability` to tell if their strategy can be used.
+ *
+ * Some hooks need to run the custom logic of the active strategy.
+ * For instance, the `useGridFiltering` wants to run:
+ * - the tree data filtering if the tree data is the current way of grouping rows.
+ * - the row grouping filtering if the row grouping is the current way of grouping rows.
+ * - the flat filtering if there is no grouping of the rows (equivalent to the "none" strategy).
+ *
+ * These hooks must use:
+ * - `apiRef.current.unstable_applyStrategyProcessor` to run a processor.
+ * - `GridEvents.strategyAvailabilityChange` to update something when the active strategy changes.
+ *    Warning: Be careful not to apply the processor several times.
+ *    For instance `GridEvents.rowsSet` is fired by `useGridRows` whenever the active strategy changes.
+ *    So listening to both would most likely run your logic twice.
+ * - `GridEvents.activeStrategyProcessorChange` to update something when the processor of the active strategy changes
+ *
+ * Each processor name is part of a strategy group which can only have one active strategy at the time.
+ */
+export declare const useGridStrategyProcessing: (apiRef: React.MutableRefObject<GridApiCommunity>) => void;

package/hooks/core/strategyProcessing/useGridStrategyProcessing.js

@@ -0,0 +1,114 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _toPropertyKey from "@babel/runtime/helpers/esm/toPropertyKey";
+import * as React from 'react';
+import { useGridApiMethod } from '../../utils/useGridApiMethod';
+import { GridEvents } from '../../../models/events';
+export const GRID_DEFAULT_STRATEGY = 'none';
+export const GRID_STRATEGIES_PROCESSORS = {
+  rowTreeCreation: 'rowTree',
+  filtering: 'rowTree',
+  sorting: 'rowTree'
+};
+
+/**
+ * Implements a variant of the Strategy Pattern (see https://en.wikipedia.org/wiki/Strategy_pattern)
+ *
+ * Some plugins contain custom logic that must only be run if the right strategy is active.
+ * For instance, the tree data plugin has:
+ * - custom row tree creation algorithm.
+ * - custom sorting algorithm.
+ * - custom filtering algorithm.
+ *
+ * These plugins must use:
+ * - `apiRef.current.unstable_registerStrategyProcessor` to register their processors.
+ * - `apiRef.current.unstable_setStrategyAvailability` to tell if their strategy can be used.
+ *
+ * Some hooks need to run the custom logic of the active strategy.
+ * For instance, the `useGridFiltering` wants to run:
+ * - the tree data filtering if the tree data is the current way of grouping rows.
+ * - the row grouping filtering if the row grouping is the current way of grouping rows.
+ * - the flat filtering if there is no grouping of the rows (equivalent to the "none" strategy).
+ *
+ * These hooks must use:
+ * - `apiRef.current.unstable_applyStrategyProcessor` to run a processor.
+ * - `GridEvents.strategyAvailabilityChange` to update something when the active strategy changes.
+ *    Warning: Be careful not to apply the processor several times.
+ *    For instance `GridEvents.rowsSet` is fired by `useGridRows` whenever the active strategy changes.
+ *    So listening to both would most likely run your logic twice.
+ * - `GridEvents.activeStrategyProcessorChange` to update something when the processor of the active strategy changes
+ *
+ * Each processor name is part of a strategy group which can only have one active strategy at the time.
+ */
+export const useGridStrategyProcessing = apiRef => {
+  const availableStrategies = React.useRef(new Map());
+  const strategiesCache = React.useRef({});
+  const registerStrategyProcessor = React.useCallback((strategyName, processorName, processor) => {
+    const cleanup = () => {
+      const _ref = strategiesCache.current[processorName],
+            otherProcessors = _objectWithoutPropertiesLoose(_ref, [strategyName].map(_toPropertyKey));
+
+      strategiesCache.current[processorName] = otherProcessors;
+    };
+
+    if (!strategiesCache.current[processorName]) {
+      strategiesCache.current[processorName] = {};
+    }
+
+    const groupPreProcessors = strategiesCache.current[processorName];
+    const previousProcessor = groupPreProcessors[strategyName];
+    groupPreProcessors[strategyName] = processor;
+
+    if (!previousProcessor || previousProcessor === processor) {
+      return cleanup;
+    }
+
+    if (strategyName === apiRef.current.unstable_getActiveStrategy(GRID_STRATEGIES_PROCESSORS[processorName])) {
+      apiRef.current.publishEvent(GridEvents.activeStrategyProcessorChange, processorName);
+    }
+
+    return cleanup;
+  }, [apiRef]);
+  const applyStrategyProcessor = React.useCallback((processorName, params) => {
+    const activeStrategy = apiRef.current.unstable_getActiveStrategy(GRID_STRATEGIES_PROCESSORS[processorName]);
+
+    if (activeStrategy == null) {
+      throw new Error("Can't apply a strategy processor before defining an active strategy");
+    }
+
+    const groupCache = strategiesCache.current[processorName];
+
+    if (!groupCache || !groupCache[activeStrategy]) {
+      throw new Error(`No processor found for processor "${processorName}" on strategy "${activeStrategy}"`);
+    }
+
+    const processor = groupCache[activeStrategy];
+    return processor(params);
+  }, [apiRef]);
+  const getActiveStrategy = React.useCallback(strategyGroup => {
+    var _availableStrategyEnt;
+
+    const strategyEntries = Array.from(availableStrategies.current.entries());
+    const availableStrategyEntry = strategyEntries.find(([, strategy]) => {
+      if (strategy.group !== strategyGroup) {
+        return false;
+      }
+
+      return strategy.isAvailable();
+    });
+    return (_availableStrategyEnt = availableStrategyEntry == null ? void 0 : availableStrategyEntry[0]) != null ? _availableStrategyEnt : GRID_DEFAULT_STRATEGY;
+  }, []);
+  const setStrategyAvailability = React.useCallback((strategyGroup, strategyName, isAvailable) => {
+    availableStrategies.current.set(strategyName, {
+      group: strategyGroup,
+      isAvailable
+    });
+    apiRef.current.publishEvent(GridEvents.strategyAvailabilityChange);
+  }, [apiRef]);
+  const strategyProcessingApi = {
+    unstable_registerStrategyProcessor: registerStrategyProcessor,
+    unstable_applyStrategyProcessor: applyStrategyProcessor,
+    unstable_getActiveStrategy: getActiveStrategy,
+    unstable_setStrategyAvailability: setStrategyAvailability
+  };
+  useGridApiMethod(apiRef, strategyProcessingApi, 'GridStrategyProcessing');
+};

package/hooks/core/useGridInitialization.js

@@ -3,7 +3,7 @@ import { useGridApiInitialization } from './useGridApiInitialization';
 import { useGridErrorHandler } from './useGridErrorHandler';
 import { useGridLocaleText } from './useGridLocaleText';
 import { useGridPreProcessing } from './preProcessing';
-import { useGridRowGroupsPreProcessing } from './rowGroupsPreProcessing';
+import { useGridStrategyProcessing } from './strategyProcessing';
 import { useGridStateInitialization } from './useGridStateInitialization';
 /**
  * Initialize the technical pieces of the DataGrid (logger, state, ...) that any DataGrid implementation needs
@@ -15,7 +15,7 @@ export const useGridInitialization = (inputApiRef, props) => {
   useGridErrorHandler(apiRef, props);
   useGridStateInitialization(apiRef, props);
   useGridPreProcessing(apiRef);
-  useGridRowGroupsPreProcessing(apiRef);
+  useGridStrategyProcessing(apiRef);
   useGridLocaleText(apiRef, props);
   return apiRef;
 };

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

@@ -1,5 +1,6 @@
 import type { GridRowId } from '../../../models';
 import { GridColDef, GridStateColDef } from '../../../models/colDef/gridColDef';
+import type { GridColumnDimensionProperties } from './gridColumnsUtils';
 export declare type GridColumnLookup = {
     [field: string]: GridStateColDef;
 };
@@ -8,16 +9,20 @@ export declare type GridColumnRawLookup = {
 };
 export interface GridColumnsState {
     /**
-     * TODO v6: Rename `orderedFields`.
+     * TODO v6: Rename `all` to `orderedFields`
      */
     all: string[];
     lookup: GridColumnLookup;
     columnVisibilityModel: GridColumnVisibilityModel;
 }
+export declare type GridColumnDimensions = Pick<GridStateColDef, GridColumnDimensionProperties>;
 export interface GridColumnsInitialState {
     columnVisibilityModel?: GridColumnVisibilityModel;
+    orderedFields?: string[];
+    dimensions?: Record<string, GridColumnDimensions>;
 }
 export declare type GridColumnsRawState = Omit<GridColumnsState, 'lookup'> & {
     lookup: GridColumnRawLookup;
 };
+export declare type GridHydrateColumnsValue = Omit<GridColumnsRawState, 'columnVisibilityModel'>;
 export declare type GridColumnVisibilityModel = Record<GridRowId, boolean>;

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

@@ -1,9 +1,11 @@
 import * as React from 'react';
-import { GridColumnsState, GridColumnsRawState, GridColumnVisibilityModel } from './gridColumnsInterfaces';
+import { GridColumnsState, GridColumnsRawState, GridColumnVisibilityModel, GridColumnsInitialState } from './gridColumnsInterfaces';
 import { GridColType, GridColumnTypesRecord } from '../../../models';
 import { GridStateCommunity } from '../../../models/gridStateCommunity';
 import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
 import { GridColDef } from '../../../models/colDef/gridColDef';
+export declare const COLUMNS_DIMENSION_PROPERTIES: readonly ["maxWidth", "minWidth", "width", "flex"];
+export declare type GridColumnDimensionProperties = typeof COLUMNS_DIMENSION_PROPERTIES[number];
 export declare const computeColumnTypes: (customColumnTypes?: GridColumnTypesRecord) => GridColumnTypesRecord;
 /**
  * Computes width for flex columns.
@@ -31,16 +33,22 @@ export declare function computeFlexColumnsWidth({ initialFreeSpace, totalFlexUni
  * TODO: Improve the `GridColDef` typing to reflect the fact that `minWidth` / `maxWidth` and `width` can't be null after the merge with the `type` default values.
  */
 export declare const hydrateColumnsWidth: (rawState: GridColumnsRawState, viewportInnerWidth: number) => GridColumnsState;
+/**
+ * Apply the order and the dimensions of the initial state.
+ * The columns not registered in `orderedFields` will be placed after the imported columns.
+ */
+export declare const applyInitialState: (columnsState: Omit<GridColumnsRawState, 'columnVisibilityModel'>, initialState: GridColumnsInitialState | undefined) => Omit<GridColumnsRawState, "columnVisibilityModel">;
 /**
  * @deprecated Should have been internal only, you can inline the logic.
  */
 export declare const getGridColDef: (columnTypes: GridColumnTypesRecord, type: GridColType | undefined) => import("../../../models").GridColTypeDef;
-export declare const createColumnsState: ({ apiRef, columnsToUpsert, columnsTypes, currentColumnVisibilityModel, shouldRegenColumnVisibilityModelFromColumns, reset, }: {
+export declare const createColumnsState: ({ apiRef, columnsToUpsert, initialState, columnsTypes, currentColumnVisibilityModel, shouldRegenColumnVisibilityModelFromColumns, keepOnlyColumnsToUpsert, }: {
     columnsToUpsert: GridColDef[];
+    initialState: GridColumnsInitialState | undefined;
     columnsTypes: GridColumnTypesRecord;
     currentColumnVisibilityModel?: GridColumnVisibilityModel | undefined;
     shouldRegenColumnVisibilityModelFromColumns: boolean;
+    keepOnlyColumnsToUpsert: boolean;
     apiRef: React.MutableRefObject<GridApiCommunity>;
-    reset: boolean;
 }) => GridColumnsState;
-export declare const setColumnsState: (columnsState: GridColumnsState) => (state: GridStateCommunity) => GridStateCommunity;
+export declare const mergeColumnsState: (columnsState: GridColumnsState) => (state: GridStateCommunity) => GridStateCommunity;