@mui/x-data-grid 5.6.0 → 5.8.0

package/hooks/features/columns/useGridColumns.js

@@ -5,20 +5,23 @@ import { useGridApiMethod } from '../../utils/useGridApiMethod';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { gridColumnFieldsSelector, gridColumnDefinitionsSelector, gridColumnLookupSelector, gridColumnsMetaSelector, gridColumnsSelector, gridColumnVisibilityModelSelector, gridVisibleColumnDefinitionsSelector, gridColumnPositionsSelector } from './gridColumnsSelector';
 import { useGridApiEventHandler, useGridApiOptionHandler } from '../../utils/useGridApiEventHandler';
-import { useGridRegisterPreProcessor } from '../../core/preProcessing';
-import { hydrateColumnsWidth, computeColumnTypes, createColumnsState, setColumnsState } from './gridColumnsUtils';
+import { useGridRegisterPipeProcessor } from '../../core/pipeProcessing';
+import { hydrateColumnsWidth, computeColumnTypes, createColumnsState, mergeColumnsState, COLUMNS_DIMENSION_PROPERTIES } from './gridColumnsUtils';
+import { GridPreferencePanelsValue } from '../preferencesPanel';
+import { jsx as _jsx } from "react/jsx-runtime";
 export const columnsStateInitializer = (state, props, apiRef) => {
-  var _props$initialState, _props$initialState$c, _ref, _props$columnVisibili, _props$initialState2, _props$initialState2$;
+  var _props$initialState, _props$initialState$c, _props$initialState2, _ref, _props$columnVisibili, _props$initialState3, _props$initialState3$;
 
-  const shouldUseVisibleColumnModel = !!props.columnVisibilityModel || !!((_props$initialState = props.initialState) != null && (_props$initialState$c = _props$initialState.columns) != null && _props$initialState$c.columnVisibilityModel);
+  const isUsingColumnVisibilityModel = !!props.columnVisibilityModel || !!((_props$initialState = props.initialState) != null && (_props$initialState$c = _props$initialState.columns) != null && _props$initialState$c.columnVisibilityModel);
   const columnsTypes = computeColumnTypes(props.columnTypes);
   const columnsState = createColumnsState({
     apiRef,
-    columnsTypes,
+    columnTypes: columnsTypes,
     columnsToUpsert: props.columns,
-    shouldRegenColumnVisibilityModelFromColumns: !shouldUseVisibleColumnModel,
-    currentColumnVisibilityModel: (_ref = (_props$columnVisibili = props.columnVisibilityModel) != null ? _props$columnVisibili : (_props$initialState2 = props.initialState) == null ? void 0 : (_props$initialState2$ = _props$initialState2.columns) == null ? void 0 : _props$initialState2$.columnVisibilityModel) != null ? _ref : {},
-    reset: true
+    initialState: (_props$initialState2 = props.initialState) == null ? void 0 : _props$initialState2.columns,
+    shouldRegenColumnVisibilityModelFromColumns: !isUsingColumnVisibilityModel,
+    currentColumnVisibilityModel: (_ref = (_props$columnVisibili = props.columnVisibilityModel) != null ? _props$columnVisibili : (_props$initialState3 = props.initialState) == null ? void 0 : (_props$initialState3$ = _props$initialState3.columns) == null ? void 0 : _props$initialState3$.columnVisibilityModel) != null ? _ref : {},
+    keepOnlyColumnsToUpsert: true
   });
   return _extends({}, state, {
     columns: columnsState
@@ -31,16 +34,18 @@ export const columnsStateInitializer = (state, props, apiRef) => {
  */
 
 export function useGridColumns(apiRef, props) {
-  var _props$initialState3, _props$initialState3$;
+  var _props$initialState4, _props$initialState4$, _props$componentsProp2;
 
   const logger = useGridLogger(apiRef, 'useGridColumns');
-  const columnsTypes = React.useMemo(() => computeColumnTypes(props.columnTypes), [props.columnTypes]);
+  const columnTypes = React.useMemo(() => computeColumnTypes(props.columnTypes), [props.columnTypes]);
+  const previousColumnsProp = React.useRef(props.columns);
+  const previousColumnTypesProp = React.useRef(columnTypes);
   /**
    * If `initialState.columns.columnVisibilityModel` or `columnVisibilityModel` was defined during the 1st render, we are directly updating the model
    * If not, we keep the old behavior and update the `GridColDef.hide` option (which will update the state model through the `GridColDef.hide` => `columnVisibilityModel` sync in `createColumnsState`
    */
 
-  const shouldUseVisibleColumnModel = React.useRef(!!props.columnVisibilityModel || !!((_props$initialState3 = props.initialState) != null && (_props$initialState3$ = _props$initialState3.columns) != null && _props$initialState3$.columnVisibilityModel)).current;
+  const isUsingColumnVisibilityModel = React.useRef(!!props.columnVisibilityModel || !!((_props$initialState4 = props.initialState) != null && (_props$initialState4$ = _props$initialState4.columns) != null && _props$initialState4$.columnVisibilityModel));
   apiRef.current.unstable_updateControlState({
     stateId: 'visibleColumns',
     propModel: props.columnVisibilityModel,
@@ -50,7 +55,7 @@ export function useGridColumns(apiRef, props) {
   });
   const setGridColumnsState = React.useCallback(columnsState => {
     logger.debug('Updating columns state.');
-    apiRef.current.setState(setColumnsState(columnsState));
+    apiRef.current.setState(mergeColumnsState(columnsState));
     apiRef.current.forceUpdate();
     apiRef.current.publishEvent(GridEvents.columnsChange, columnsState.all);
   }, [logger, apiRef]);
@@ -77,32 +82,34 @@ export function useGridColumns(apiRef, props) {
       apiRef.current.setState(state => _extends({}, state, {
         columns: createColumnsState({
           apiRef,
-          columnsTypes,
+          columnTypes,
           columnsToUpsert: [],
+          initialState: undefined,
           shouldRegenColumnVisibilityModelFromColumns: false,
           currentColumnVisibilityModel: model,
-          reset: false
+          keepOnlyColumnsToUpsert: false
         })
       }));
       apiRef.current.forceUpdate();
     }
-  }, [apiRef, columnsTypes]);
+  }, [apiRef, columnTypes]);
   const updateColumns = React.useCallback(columns => {
     const columnsState = createColumnsState({
       apiRef,
-      columnsTypes,
+      columnTypes,
       columnsToUpsert: columns,
+      initialState: undefined,
       shouldRegenColumnVisibilityModelFromColumns: true,
-      reset: false
+      keepOnlyColumnsToUpsert: false
     });
     setGridColumnsState(columnsState);
-  }, [apiRef, setGridColumnsState, columnsTypes]);
+  }, [apiRef, setGridColumnsState, columnTypes]);
   const updateColumn = React.useCallback(column => apiRef.current.updateColumns([column]), [apiRef]);
   const setColumnVisibility = React.useCallback((field, isVisible) => {
     // We keep updating the `hide` option of `GridColDef` when not controlling the model to avoid any breaking change.
     // `updateColumns` take care of updating the model itself if needs be.
     // TODO v6: stop using the `hide` field even when the model is not defined
-    if (shouldUseVisibleColumnModel) {
+    if (isUsingColumnVisibilityModel.current) {
       var _columnVisibilityMode;
 
       const columnVisibilityModel = gridColumnVisibilityModelSelector(apiRef);
@@ -130,7 +137,7 @@ export function useGridColumns(apiRef, props) {
       };
       apiRef.current.publishEvent(GridEvents.columnVisibilityChange, params);
     }
-  }, [apiRef, shouldUseVisibleColumnModel]);
+  }, [apiRef]);
   const setColumnIndex = React.useCallback((field, targetIndexPosition) => {
     const allColumns = gridColumnFieldsSelector(apiRef);
     const oldIndexPosition = allColumns.findIndex(col => col === field);
@@ -189,53 +196,83 @@ export function useGridColumns(apiRef, props) {
    */
 
   const stateExportPreProcessing = React.useCallback(prevState => {
-    if (!shouldUseVisibleColumnModel) {
-      return prevState;
+    const columnsStateToExport = {};
+
+    if (isUsingColumnVisibilityModel.current) {
+      const columnVisibilityModelToExport = gridColumnVisibilityModelSelector(apiRef);
+      const hasHiddenColumns = Object.values(columnVisibilityModelToExport).some(value => value === false);
+
+      if (hasHiddenColumns) {
+        columnsStateToExport.columnVisibilityModel = columnVisibilityModelToExport;
+      }
     }
 
-    const columnVisibilityModelToExport = gridColumnVisibilityModelSelector(apiRef);
-    const hasHiddenColumns = Object.values(columnVisibilityModelToExport).some(value => value === false);
+    columnsStateToExport.orderedFields = gridColumnFieldsSelector(apiRef);
+    const columns = gridColumnDefinitionsSelector(apiRef);
+    const dimensions = {};
+    columns.forEach(colDef => {
+      if (colDef.hasBeenResized) {
+        const colDefDimensions = {};
+        COLUMNS_DIMENSION_PROPERTIES.forEach(propertyName => {
+          colDefDimensions[propertyName] = colDef[propertyName];
+        });
+        dimensions[colDef.field] = colDefDimensions;
+      }
+    });
 
-    if (!hasHiddenColumns) {
-      return prevState;
+    if (Object.keys(dimensions).length > 0) {
+      columnsStateToExport.dimensions = dimensions;
     }
 
     return _extends({}, prevState, {
-      columns: {
-        columnVisibilityModel: columnVisibilityModelToExport
-      }
+      columns: columnsStateToExport
     });
-  }, [apiRef, shouldUseVisibleColumnModel]);
+  }, [apiRef]);
   const stateRestorePreProcessing = React.useCallback((params, context) => {
     var _context$stateToResto;
 
-    if (!shouldUseVisibleColumnModel) {
+    const columnVisibilityModelToImport = isUsingColumnVisibilityModel.current ? (_context$stateToResto = context.stateToRestore.columns) == null ? void 0 : _context$stateToResto.columnVisibilityModel : undefined;
+    const initialState = context.stateToRestore.columns;
+
+    if (columnVisibilityModelToImport == null && initialState == null) {
       return params;
     }
 
-    const columnVisibilityModel = (_context$stateToResto = context.stateToRestore.columns) == null ? void 0 : _context$stateToResto.columnVisibilityModel;
+    const columnsState = createColumnsState({
+      apiRef,
+      columnTypes,
+      columnsToUpsert: [],
+      initialState,
+      shouldRegenColumnVisibilityModelFromColumns: !isUsingColumnVisibilityModel.current,
+      currentColumnVisibilityModel: columnVisibilityModelToImport,
+      keepOnlyColumnsToUpsert: false
+    });
+    apiRef.current.setState(mergeColumnsState(columnsState));
 
-    if (columnVisibilityModel != null) {
-      const columnsState = createColumnsState({
-        apiRef,
-        columnsTypes,
-        columnsToUpsert: [],
-        shouldRegenColumnVisibilityModelFromColumns: false,
-        currentColumnVisibilityModel: columnVisibilityModel,
-        reset: false
-      });
-      apiRef.current.setState(setColumnsState(columnsState));
+    if (initialState != null) {
+      apiRef.current.publishEvent(GridEvents.columnsChange, columnsState.all);
     }
 
     return params;
-  }, [apiRef, shouldUseVisibleColumnModel, columnsTypes]);
-  useGridRegisterPreProcessor(apiRef, 'exportState', stateExportPreProcessing);
-  useGridRegisterPreProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
+  }, [apiRef, columnTypes]);
+  const preferencePanelPreProcessing = React.useCallback((initialValue, value) => {
+    if (value === GridPreferencePanelsValue.columns) {
+      var _props$componentsProp;
+
+      const ColumnsPanel = props.components.ColumnsPanel;
+      return /*#__PURE__*/_jsx(ColumnsPanel, _extends({}, (_props$componentsProp = props.componentsProps) == null ? void 0 : _props$componentsProp.columnsPanel));
+    }
+
+    return initialValue;
+  }, [props.components.ColumnsPanel, (_props$componentsProp2 = props.componentsProps) == null ? void 0 : _props$componentsProp2.columnsPanel]);
+  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
+  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
+  useGridRegisterPipeProcessor(apiRef, 'preferencePanel', preferencePanelPreProcessing);
   /**
    * EVENTS
    */
 
-  const handlePreProcessorRegister = React.useCallback(name => {
+  const handlepipeProcessorRegister = React.useCallback(name => {
     if (name !== 'hydrateColumns') {
       return;
     }
@@ -243,13 +280,14 @@ export function useGridColumns(apiRef, props) {
     logger.info(`Columns pre-processing have changed, regenerating the columns`);
     const columnsState = createColumnsState({
       apiRef,
-      columnsTypes,
+      columnTypes,
       columnsToUpsert: [],
-      shouldRegenColumnVisibilityModelFromColumns: !shouldUseVisibleColumnModel,
-      reset: false
+      initialState: undefined,
+      shouldRegenColumnVisibilityModelFromColumns: !isUsingColumnVisibilityModel.current,
+      keepOnlyColumnsToUpsert: false
     });
     setGridColumnsState(columnsState);
-  }, [apiRef, logger, setGridColumnsState, columnsTypes, shouldUseVisibleColumnModel]);
+  }, [apiRef, logger, setGridColumnsState, columnTypes]);
   const prevInnerWidth = React.useRef(null);
 
   const handleGridSizeChange = viewportInnerSize => {
@@ -259,7 +297,7 @@ export function useGridColumns(apiRef, props) {
     }
   };
 
-  useGridApiEventHandler(apiRef, GridEvents.preProcessorRegister, handlePreProcessorRegister);
+  useGridApiEventHandler(apiRef, GridEvents.pipeProcessorRegister, handlepipeProcessorRegister);
   useGridApiEventHandler(apiRef, GridEvents.viewportInnerSizeChange, handleGridSizeChange);
   useGridApiOptionHandler(apiRef, GridEvents.columnVisibilityChange, props.onColumnVisibilityChange);
   /**
@@ -276,16 +314,24 @@ export function useGridColumns(apiRef, props) {
     }
 
     logger.info(`GridColumns have changed, new length ${props.columns.length}`);
+
+    if (previousColumnsProp.current === props.columns && previousColumnTypesProp.current === columnTypes) {
+      return;
+    }
+
     const columnsState = createColumnsState({
       apiRef,
-      columnsTypes,
+      columnTypes,
+      initialState: undefined,
       // If the user provides a model, we don't want to set it in the state here because it has it's dedicated `useEffect` which calls `setColumnVisibilityModel`
-      shouldRegenColumnVisibilityModelFromColumns: !shouldUseVisibleColumnModel,
+      shouldRegenColumnVisibilityModelFromColumns: !isUsingColumnVisibilityModel.current,
       columnsToUpsert: props.columns,
-      reset: true
+      keepOnlyColumnsToUpsert: true
     });
+    previousColumnsProp.current = props.columns;
+    previousColumnTypesProp.current = columnTypes;
     setGridColumnsState(columnsState);
-  }, [logger, apiRef, setGridColumnsState, props.columns, columnsTypes, shouldUseVisibleColumnModel]);
+  }, [logger, apiRef, setGridColumnsState, props.columns, columnTypes]);
   React.useEffect(() => {
     if (props.columnVisibilityModel !== undefined) {
       apiRef.current.setColumnVisibilityModel(props.columnVisibilityModel);

package/hooks/features/density/useGridDensity.d.ts

@@ -1,6 +1,8 @@
 import * as React from 'react';
 import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
 import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
+import { GridStateInitializer } from '../../utils/useGridInitializeState';
 export declare const COMPACT_DENSITY_FACTOR = 0.7;
 export declare const COMFORTABLE_DENSITY_FACTOR = 1.3;
+export declare const densityStateInitializer: GridStateInitializer<Pick<DataGridProcessedProps, 'density' | 'headerHeight' | 'rowHeight'>>;
 export declare const useGridDensity: (apiRef: React.MutableRefObject<GridApiCommunity>, props: Pick<DataGridProcessedProps, 'headerHeight' | 'rowHeight' | 'density'>) => void;

package/hooks/features/density/useGridDensity.js

@@ -3,7 +3,6 @@ import * as React from 'react';
 import { GridDensityTypes } from '../../../models/gridDensity';
 import { useGridLogger } from '../../utils/useGridLogger';
 import { useGridApiMethod } from '../../utils/useGridApiMethod';
-import { useGridStateInit } from '../../utils/useGridStateInit';
 import { gridDensitySelector } from './densitySelector';
 import { isDeepEqual } from '../../../utils/utils';
 export const COMPACT_DENSITY_FACTOR = 0.7;
@@ -37,11 +36,11 @@ const getUpdatedDensityState = (newDensity, newHeaderHeight, newRowHeight) => {
   }
 };
 
+export const densityStateInitializer = (state, props) => _extends({}, state, {
+  density: getUpdatedDensityState(props.density, props.headerHeight, props.rowHeight)
+});
 export const useGridDensity = (apiRef, props) => {
   const logger = useGridLogger(apiRef, 'useDensity');
-  useGridStateInit(apiRef, state => _extends({}, state, {
-    density: getUpdatedDensityState(props.density, props.headerHeight, props.rowHeight)
-  }));
   const setDensity = React.useCallback((newDensity, newHeaderHeight = props.headerHeight, newRowHeight = props.rowHeight) => {
     logger.debug(`Set grid density to ${newDensity}`);
     apiRef.current.setState(state => {

package/hooks/features/dimensions/gridDimensionsApi.d.ts

@@ -33,4 +33,9 @@ export interface GridDimensionsApi {
      * @ignore - do not document.
      */
     unstable_getViewportPageSize: () => number;
+    /**
+     * Forces a recalculation of all dimensions.
+     * @ignore - do not document.
+     */
+    unstable_updateGridDimensionsRef: () => void;
 }

package/hooks/features/dimensions/useGridDimensions.js

@@ -7,7 +7,7 @@ import { useGridLogger } from '../../utils/useGridLogger';
 import { gridColumnsTotalWidthSelector } from '../columns';
 import { gridDensityHeaderHeightSelector, gridDensityRowHeightSelector } from '../density';
 import { useGridSelector } from '../../utils';
-import { getCurrentPageRows } from '../../utils/useCurrentPageRows';
+import { getVisibleRows } from '../../utils/useGridVisibleRows';
 import { gridRowsMetaSelector } from '../rows/gridRowsMetaSelector';
 const isTestEnvironment = process.env.NODE_ENV === 'test';
 
@@ -116,7 +116,7 @@ export function useGridDimensions(apiRef, props) {
       return 0;
     }
 
-    const currentPage = getCurrentPageRows(apiRef, {
+    const currentPage = getVisibleRows(apiRef, {
       pagination: props.pagination,
       paginationMode: props.paginationMode
     }); // TODO: Use a combination of scrollTop, dimensions.viewportInnerSize.height and rowsMeta.possitions
@@ -134,7 +134,8 @@ export function useGridDimensions(apiRef, props) {
   const dimensionsApi = {
     resize,
     getRootDimensions,
-    unstable_getViewportPageSize: getViewportPageSize
+    unstable_getViewportPageSize: getViewportPageSize,
+    unstable_updateGridDimensionsRef: updateGridDimensionsRef
   };
   useGridApiMethod(apiRef, dimensionsApi, 'GridDimensionsApi');
   const debounceResize = React.useMemo(() => debounce(resize, 60), [resize]);

package/hooks/features/editRows/useGridCellEditing.new.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { GridApiCommunity } from '../../../models/api/gridApiCommunity';
+import { DataGridProcessedProps } from '../../../models/props/DataGridProps';
+export declare const useGridCellEditing: (apiRef: React.MutableRefObject<GridApiCommunity>, props: Pick<DataGridProcessedProps, 'editMode' | 'processRowUpdate' | 'onCellEditStart' | 'onCellEditStop' | 'onProcessRowUpdateError'>) => void;