@mui/x-data-grid-pro 5.11.1 → 5.12.2

package/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -1,200 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import Divider from '@mui/material/Divider';
-import { useGridApiEventHandler, useGridApiMethod, gridFilteredDescendantCountLookupSelector } from '@mui/x-data-grid';
-import { useGridRegisterPipeProcessor, isDeepEqual } from '@mui/x-data-grid/internals';
-import { gridRowGroupingModelSelector, gridRowGroupingSanitizedModelSelector, gridRowGroupingStateSelector } from './gridRowGroupingSelector';
-import { getRowGroupingFieldFromGroupingCriteria, ROW_GROUPING_STRATEGY, isGroupingColumn, mergeStateWithRowGroupingModel, setStrategyAvailability } from './gridRowGroupingUtils';
-import { GridRowGroupableColumnMenuItems } from '../../../components/GridRowGroupableColumnMenuItems';
-import { GridRowGroupingColumnMenuItems } from '../../../components/GridRowGroupingColumnMenuItems';
-import { jsx as _jsx } from "react/jsx-runtime";
-export const rowGroupingStateInitializer = (state, props) => {
-  var _ref, _props$rowGroupingMod, _props$initialState, _props$initialState$r;
-
-  return _extends({}, state, {
-    rowGrouping: {
-      model: (_ref = (_props$rowGroupingMod = props.rowGroupingModel) != null ? _props$rowGroupingMod : (_props$initialState = props.initialState) == null ? void 0 : (_props$initialState$r = _props$initialState.rowGrouping) == null ? void 0 : _props$initialState$r.model) != null ? _ref : [],
-      unstable_sanitizedModelOnLastRowTreeCreation: []
-    }
-  });
-};
-/**
- * @requires useGridColumns (state, method) - can be after, async only
- * @requires useGridRows (state, method) - can be after, async only
- * @requires useGridParamsApi (method) - can be after, async only
- */
-
-export const useGridRowGrouping = (apiRef, props) => {
-  apiRef.current.unstable_updateControlState({
-    stateId: 'rowGrouping',
-    propModel: props.rowGroupingModel,
-    propOnChange: props.onRowGroupingModelChange,
-    stateSelector: gridRowGroupingModelSelector,
-    changeEvent: 'rowGroupingModelChange'
-  });
-  /**
-   * API METHODS
-   */
-
-  const setRowGroupingModel = React.useCallback(model => {
-    const currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (currentModel !== model) {
-      apiRef.current.setState(mergeStateWithRowGroupingModel(model));
-      setStrategyAvailability(apiRef, props.disableRowGrouping);
-      apiRef.current.forceUpdate();
-    }
-  }, [apiRef, props.disableRowGrouping]);
-  const addRowGroupingCriteria = React.useCallback((field, groupingIndex) => {
-    const currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (currentModel.includes(field)) {
-      return;
-    }
-
-    const cleanGroupingIndex = groupingIndex != null ? groupingIndex : currentModel.length;
-    const updatedModel = [...currentModel.slice(0, cleanGroupingIndex), field, ...currentModel.slice(cleanGroupingIndex)];
-    apiRef.current.setRowGroupingModel(updatedModel);
-  }, [apiRef]);
-  const removeRowGroupingCriteria = React.useCallback(field => {
-    const currentModel = gridRowGroupingModelSelector(apiRef);
-
-    if (!currentModel.includes(field)) {
-      return;
-    }
-
-    apiRef.current.setRowGroupingModel(currentModel.filter(el => el !== field));
-  }, [apiRef]);
-  const setRowGroupingCriteriaIndex = React.useCallback((field, targetIndex) => {
-    const currentModel = gridRowGroupingModelSelector(apiRef);
-    const currentTargetIndex = currentModel.indexOf(field);
-
-    if (currentTargetIndex === -1) {
-      return;
-    }
-
-    const updatedModel = [...currentModel];
-    updatedModel.splice(targetIndex, 0, updatedModel.splice(currentTargetIndex, 1)[0]);
-    apiRef.current.setRowGroupingModel(updatedModel);
-  }, [apiRef]);
-  const rowGroupingApi = {
-    setRowGroupingModel,
-    addRowGroupingCriteria,
-    removeRowGroupingCriteria,
-    setRowGroupingCriteriaIndex
-  };
-  useGridApiMethod(apiRef, rowGroupingApi, 'GridRowGroupingApi');
-  /**
-   * PRE-PROCESSING
-   */
-
-  const addColumnMenuButtons = React.useCallback((initialValue, columns) => {
-    if (props.disableRowGrouping) {
-      return initialValue;
-    }
-
-    let menuItems;
-
-    if (isGroupingColumn(columns.field)) {
-      menuItems = /*#__PURE__*/_jsx(GridRowGroupingColumnMenuItems, {});
-    } else if (columns.groupable) {
-      menuItems = /*#__PURE__*/_jsx(GridRowGroupableColumnMenuItems, {});
-    } else {
-      menuItems = null;
-    }
-
-    if (menuItems == null) {
-      return initialValue;
-    }
-
-    return [...initialValue, /*#__PURE__*/_jsx(Divider, {}), menuItems];
-  }, [props.disableRowGrouping]);
-  const stateExportPreProcessing = React.useCallback(prevState => {
-    if (props.disableRowGrouping) {
-      return prevState;
-    }
-
-    const rowGroupingModelToExport = gridRowGroupingModelSelector(apiRef);
-
-    if (rowGroupingModelToExport.length === 0) {
-      return prevState;
-    }
-
-    return _extends({}, prevState, {
-      rowGrouping: {
-        model: rowGroupingModelToExport
-      }
-    });
-  }, [apiRef, props.disableRowGrouping]);
-  const stateRestorePreProcessing = React.useCallback((params, context) => {
-    var _context$stateToResto;
-
-    if (props.disableRowGrouping) {
-      return params;
-    }
-
-    const rowGroupingModel = (_context$stateToResto = context.stateToRestore.rowGrouping) == null ? void 0 : _context$stateToResto.model;
-
-    if (rowGroupingModel != null) {
-      apiRef.current.setState(mergeStateWithRowGroupingModel(rowGroupingModel));
-    }
-
-    return params;
-  }, [apiRef, props.disableRowGrouping]);
-  useGridRegisterPipeProcessor(apiRef, 'columnMenu', addColumnMenuButtons);
-  useGridRegisterPipeProcessor(apiRef, 'exportState', stateExportPreProcessing);
-  useGridRegisterPipeProcessor(apiRef, 'restoreState', stateRestorePreProcessing);
-  /**
-   * EVENTS
-   */
-
-  const handleCellKeyDown = React.useCallback((params, event) => {
-    const cellParams = apiRef.current.getCellParams(params.id, params.field);
-
-    if (isGroupingColumn(cellParams.field) && event.key === ' ' && !event.shiftKey) {
-      var _gridFilteredDescenda;
-
-      event.stopPropagation();
-      event.preventDefault();
-      const filteredDescendantCount = (_gridFilteredDescenda = gridFilteredDescendantCountLookupSelector(apiRef)[params.id]) != null ? _gridFilteredDescenda : 0;
-      const isOnGroupingCell = props.rowGroupingColumnMode === 'single' || getRowGroupingFieldFromGroupingCriteria(params.rowNode.groupingField) === params.field;
-
-      if (!isOnGroupingCell || filteredDescendantCount === 0) {
-        return;
-      }
-
-      apiRef.current.setRowChildrenExpansion(params.id, !params.rowNode.childrenExpanded);
-    }
-  }, [apiRef, props.rowGroupingColumnMode]);
-  const checkGroupingColumnsModelDiff = React.useCallback(() => {
-    const rowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
-    const lastGroupingColumnsModelApplied = gridRowGroupingStateSelector(apiRef.current.state).unstable_sanitizedModelOnLastRowTreeCreation;
-
-    if (!isDeepEqual(lastGroupingColumnsModelApplied, rowGroupingModel)) {
-      apiRef.current.setState(state => _extends({}, state, {
-        rowGrouping: _extends({}, state.rowGrouping, {
-          unstable_sanitizedModelOnLastRowTreeCreation: rowGroupingModel
-        })
-      }));
-      apiRef.current.unstable_requestPipeProcessorsApplication('hydrateColumns');
-      setStrategyAvailability(apiRef, props.disableRowGrouping); // Refresh the row tree creation strategy processing
-      // TODO: Add a clean way to re-run a strategy processing without publishing a private event
-
-      if (apiRef.current.unstable_getActiveStrategy('rowTree') === ROW_GROUPING_STRATEGY) {
-        apiRef.current.publishEvent('activeStrategyProcessorChange', 'rowTreeCreation');
-      }
-    }
-  }, [apiRef, props.disableRowGrouping]);
-  useGridApiEventHandler(apiRef, 'cellKeyDown', handleCellKeyDown);
-  useGridApiEventHandler(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
-  useGridApiEventHandler(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);
-  /**
-   * EFFECTS
-   */
-
-  React.useEffect(() => {
-    if (props.rowGroupingModel !== undefined) {
-      apiRef.current.setRowGroupingModel(props.rowGroupingModel);
-    }
-  }, [apiRef, props.rowGroupingModel]);
-};

package/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.d.ts

@@ -1,4 +0,0 @@
-import * as React from 'react';
-import { DataGridProProcessedProps } from '../../../models/dataGridProProps';
-import { GridApiPro } from '../../../models/gridApiPro';
-export declare const useGridRowGroupingPreProcessors: (apiRef: React.MutableRefObject<GridApiPro>, props: Pick<DataGridProProcessedProps, 'disableRowGrouping' | 'groupingColDef' | 'rowGroupingColumnMode' | 'defaultGroupingExpansionDepth' | 'isGroupExpandedByDefault'>) => void;

package/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.js

@@ -1,203 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { gridColumnLookupSelector, gridRowIdsSelector, gridRowTreeSelector, useFirstRender } from '@mui/x-data-grid';
-import { useGridRegisterPipeProcessor, useGridRegisterStrategyProcessor } from '@mui/x-data-grid/internals';
-import { sortRowTree } from '../../../utils/tree/sortRowTree';
-import { buildRowTree } from '../../../utils/tree/buildRowTree';
-import { gridRowGroupingModelSelector, gridRowGroupingSanitizedModelSelector } from './gridRowGroupingSelector';
-import { createGroupingColDefForAllGroupingCriteria, createGroupingColDefForOneGroupingCriteria } from './createGroupingColDef';
-import { filterRowTreeFromGroupingColumns, getColDefOverrides, ROW_GROUPING_STRATEGY, isGroupingColumn, setStrategyAvailability } from './gridRowGroupingUtils';
-export const useGridRowGroupingPreProcessors = (apiRef, props) => {
-  const getGroupingColDefs = React.useCallback(columnsState => {
-    if (props.disableRowGrouping) {
-      return [];
-    }
-
-    const groupingColDefProp = props.groupingColDef; // We can't use `gridGroupingRowsSanitizedModelSelector` here because the new columns are not in the state yet
-
-    const rowGroupingModel = gridRowGroupingModelSelector(apiRef).filter(field => !!columnsState.lookup[field]);
-
-    if (rowGroupingModel.length === 0) {
-      return [];
-    }
-
-    switch (props.rowGroupingColumnMode) {
-      case 'single':
-        {
-          return [createGroupingColDefForAllGroupingCriteria({
-            apiRef,
-            rowGroupingModel,
-            colDefOverride: getColDefOverrides(groupingColDefProp, rowGroupingModel),
-            columnsLookup: columnsState.lookup
-          })];
-        }
-
-      case 'multiple':
-        {
-          return rowGroupingModel.map(groupingCriteria => createGroupingColDefForOneGroupingCriteria({
-            groupingCriteria,
-            colDefOverride: getColDefOverrides(groupingColDefProp, [groupingCriteria]),
-            groupedByColDef: columnsState.lookup[groupingCriteria],
-            columnsLookup: columnsState.lookup
-          }));
-        }
-
-      default:
-        {
-          return [];
-        }
-    }
-  }, [apiRef, props.groupingColDef, props.rowGroupingColumnMode, props.disableRowGrouping]);
-  const updateGroupingColumn = React.useCallback(columnsState => {
-    const groupingColDefs = getGroupingColDefs(columnsState);
-    let newColumnFields = [];
-    const newColumnsLookup = {}; // We only keep the non-grouping columns
-
-    columnsState.all.forEach(field => {
-      if (!isGroupingColumn(field)) {
-        newColumnFields.push(field);
-        newColumnsLookup[field] = columnsState.lookup[field];
-      }
-    }); // We add the grouping column
-
-    groupingColDefs.forEach(groupingColDef => {
-      const matchingGroupingColDef = columnsState.lookup[groupingColDef.field];
-
-      if (matchingGroupingColDef) {
-        groupingColDef.width = matchingGroupingColDef.width;
-        groupingColDef.flex = matchingGroupingColDef.flex;
-      }
-
-      newColumnsLookup[groupingColDef.field] = groupingColDef;
-    });
-    const startIndex = newColumnFields[0] === '__check__' ? 1 : 0;
-    newColumnFields = [...newColumnFields.slice(0, startIndex), ...groupingColDefs.map(colDef => colDef.field), ...newColumnFields.slice(startIndex)];
-    columnsState.all = newColumnFields;
-    columnsState.lookup = newColumnsLookup;
-    return columnsState;
-  }, [getGroupingColDefs]);
-  const createRowTree = React.useCallback(params => {
-    const rowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
-    const columnsLookup = gridColumnLookupSelector(apiRef);
-    apiRef.current.setState(state => _extends({}, state, {
-      rowGrouping: _extends({}, state.rowGrouping, {
-        unstable_sanitizedModelOnLastRowTreeCreation: rowGroupingModel
-      })
-    }));
-    const distinctValues = Object.fromEntries(rowGroupingModel.map(groupingField => [groupingField, {
-      lookup: {},
-      list: []
-    }]));
-
-    const getCellGroupingCriteria = ({
-      row,
-      id,
-      colDef
-    }) => {
-      let key;
-
-      if (colDef.groupingValueGetter) {
-        const groupingValueGetterParams = {
-          colDef,
-          field: colDef.field,
-          value: row[colDef.field],
-          id,
-          row,
-          rowNode: {
-            isAutoGenerated: false,
-            id
-          }
-        };
-        key = colDef.groupingValueGetter(groupingValueGetterParams);
-      } else {
-        key = row[colDef.field];
-      }
-
-      return {
-        key,
-        field: colDef.field
-      };
-    };
-
-    params.ids.forEach(rowId => {
-      const row = params.idRowsLookup[rowId];
-      rowGroupingModel.forEach(groupingCriteria => {
-        const {
-          key
-        } = getCellGroupingCriteria({
-          row,
-          id: rowId,
-          colDef: columnsLookup[groupingCriteria]
-        });
-        const groupingFieldsDistinctKeys = distinctValues[groupingCriteria];
-
-        if (key != null && !groupingFieldsDistinctKeys.lookup[key.toString()]) {
-          groupingFieldsDistinctKeys.lookup[key.toString()] = true;
-          groupingFieldsDistinctKeys.list.push(key);
-        }
-      });
-    });
-    const rows = params.ids.map(rowId => {
-      const row = params.idRowsLookup[rowId];
-      const parentPath = rowGroupingModel.map(groupingField => getCellGroupingCriteria({
-        row,
-        id: rowId,
-        colDef: columnsLookup[groupingField]
-      })).filter(cell => cell.key != null);
-      const leafGroupingCriteria = {
-        key: rowId.toString(),
-        field: null
-      };
-      return {
-        path: [...parentPath, leafGroupingCriteria],
-        id: rowId
-      };
-    });
-    return buildRowTree(_extends({}, params, {
-      rows,
-      defaultGroupingExpansionDepth: props.defaultGroupingExpansionDepth,
-      isGroupExpandedByDefault: props.isGroupExpandedByDefault,
-      groupingName: ROW_GROUPING_STRATEGY
-    }));
-  }, [apiRef, props.defaultGroupingExpansionDepth, props.isGroupExpandedByDefault]);
-  const filterRows = React.useCallback(params => {
-    const rowTree = gridRowTreeSelector(apiRef);
-    return filterRowTreeFromGroupingColumns({
-      rowTree,
-      isRowMatchingFilters: params.isRowMatchingFilters
-    });
-  }, [apiRef]);
-  const sortRows = React.useCallback(params => {
-    const rowTree = gridRowTreeSelector(apiRef);
-    const rowIds = gridRowIdsSelector(apiRef);
-    return sortRowTree({
-      rowTree,
-      rowIds,
-      sortRowList: params.sortRowList,
-      disableChildrenSorting: false
-    });
-  }, [apiRef]);
-  useGridRegisterPipeProcessor(apiRef, 'hydrateColumns', updateGroupingColumn);
-  useGridRegisterStrategyProcessor(apiRef, ROW_GROUPING_STRATEGY, 'rowTreeCreation', createRowTree);
-  useGridRegisterStrategyProcessor(apiRef, ROW_GROUPING_STRATEGY, 'filtering', filterRows);
-  useGridRegisterStrategyProcessor(apiRef, ROW_GROUPING_STRATEGY, 'sorting', sortRows);
-  /**
-   * 1ST RENDER
-   */
-
-  useFirstRender(() => {
-    setStrategyAvailability(apiRef, props.disableRowGrouping);
-  });
-  /**
-   * EFFECTS
-   */
-
-  const isFirstRender = React.useRef(true);
-  React.useEffect(() => {
-    if (!isFirstRender.current) {
-      setStrategyAvailability(apiRef, props.disableRowGrouping);
-    } else {
-      isFirstRender.current = false;
-    }
-  }, [apiRef, props.disableRowGrouping]);
-};

package/legacy/components/GridGroupingColumnLeafCell.js

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import Box from '@mui/material/Box';
-import { useGridRootProps } from '../hooks/utils/useGridRootProps';
-import { jsx as _jsx } from "react/jsx-runtime";
-
-var GridGroupingColumnLeafCell = function GridGroupingColumnLeafCell(props) {
-  var _props$formattedValue;
-
-  var rowNode = props.rowNode;
-  var rootProps = useGridRootProps();
-  var marginLeft = rootProps.rowGroupingColumnMode === 'multiple' ? 1 : rowNode.depth * 2;
-  return /*#__PURE__*/_jsx(Box, {
-    sx: {
-      ml: marginLeft
-    },
-    children: (_props$formattedValue = props.formattedValue) != null ? _props$formattedValue : props.value
-  });
-};
-
-export { GridGroupingColumnLeafCell };

package/legacy/components/GridGroupingCriteriaCell.js

@@ -1,74 +0,0 @@
-import * as React from 'react';
-import { unstable_composeClasses as composeClasses } from '@mui/material';
-import IconButton from '@mui/material/IconButton';
-import Box from '@mui/material/Box';
-import { useGridSelector, gridFilteredDescendantCountLookupSelector, getDataGridUtilityClass } from '@mui/x-data-grid';
-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";
-
-var useUtilityClasses = function useUtilityClasses(ownerState) {
-  var classes = ownerState.classes;
-  var slots = {
-    root: ['groupingCriteriaCell'],
-    toggle: ['groupingCriteriaCellToggle']
-  };
-  return composeClasses(slots, getDataGridUtilityClass, classes);
-};
-
-export var GridGroupingCriteriaCell = function GridGroupingCriteriaCell(props) {
-  var _filteredDescendantCo;
-
-  var id = props.id,
-      field = props.field,
-      rowNode = props.rowNode,
-      hideDescendantCount = props.hideDescendantCount,
-      formattedValue = props.formattedValue;
-  var rootProps = useGridRootProps();
-  var apiRef = useGridApiContext();
-  var ownerState = {
-    classes: rootProps.classes
-  };
-  var classes = useUtilityClasses(ownerState);
-  var filteredDescendantCountLookup = useGridSelector(apiRef, gridFilteredDescendantCountLookupSelector);
-  var filteredDescendantCount = (_filteredDescendantCo = filteredDescendantCountLookup[rowNode.id]) != null ? _filteredDescendantCo : 0;
-  var Icon = rowNode.childrenExpanded ? rootProps.components.GroupingCriteriaCollapseIcon : rootProps.components.GroupingCriteriaExpandIcon;
-
-  var handleKeyDown = function handleKeyDown(event) {
-    if (event.key === ' ') {
-      event.stopPropagation();
-    }
-
-    apiRef.current.publishEvent('cellKeyDown', props, event);
-  };
-
-  var handleClick = function handleClick(event) {
-    apiRef.current.setRowChildrenExpansion(id, !rowNode.childrenExpanded);
-    apiRef.current.setCellFocus(id, field);
-    event.stopPropagation();
-  };
-
-  var marginLeft = rootProps.rowGroupingColumnMode === 'multiple' ? 0 : rowNode.depth * 2;
-  return /*#__PURE__*/_jsxs(Box, {
-    className: classes.root,
-    sx: {
-      ml: marginLeft
-    },
-    children: [/*#__PURE__*/_jsx("div", {
-      className: classes.toggle,
-      children: filteredDescendantCount > 0 && /*#__PURE__*/_jsx(IconButton, {
-        size: "small",
-        onClick: handleClick,
-        onKeyDown: handleKeyDown,
-        tabIndex: -1,
-        "aria-label": rowNode.childrenExpanded ? apiRef.current.getLocaleText('treeDataCollapse') : apiRef.current.getLocaleText('treeDataExpand'),
-        children: /*#__PURE__*/_jsx(Icon, {
-          fontSize: "inherit"
-        })
-      })
-    }), /*#__PURE__*/_jsxs("span", {
-      children: [formattedValue === undefined ? rowNode.groupingKey : formattedValue, !hideDescendantCount && filteredDescendantCount > 0 ? " (".concat(filteredDescendantCount, ")") : '']
-    })]
-  });
-};

package/legacy/components/GridRowGroupableColumnMenuItems.js

@@ -1,61 +0,0 @@
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import MenuItem from '@mui/material/MenuItem';
-import { gridColumnLookupSelector, useGridSelector } from '@mui/x-data-grid';
-import { useGridApiContext } from '../hooks/utils/useGridApiContext';
-import { gridRowGroupingSanitizedModelSelector } from '../hooks/features/rowGrouping/gridRowGroupingSelector';
-import { jsx as _jsx } from "react/jsx-runtime";
-
-var GridRowGroupableColumnMenuItems = function GridRowGroupableColumnMenuItems(props) {
-  var _columnsLookup$column;
-
-  var column = props.column,
-      onClick = props.onClick;
-  var apiRef = useGridApiContext();
-  var rowGroupingModel = useGridSelector(apiRef, gridRowGroupingSanitizedModelSelector);
-  var columnsLookup = useGridSelector(apiRef, gridColumnLookupSelector);
-
-  if (!(column != null && column.groupable)) {
-    return null;
-  }
-
-  var ungroupColumn = function ungroupColumn(event) {
-    apiRef.current.removeRowGroupingCriteria(column.field);
-
-    if (onClick) {
-      onClick(event);
-    }
-  };
-
-  var groupColumn = function groupColumn(event) {
-    apiRef.current.addRowGroupingCriteria(column.field);
-
-    if (onClick) {
-      onClick(event);
-    }
-  };
-
-  var name = (_columnsLookup$column = columnsLookup[column.field].headerName) != null ? _columnsLookup$column : column.field;
-
-  if (rowGroupingModel.includes(column.field)) {
-    return /*#__PURE__*/_jsx(MenuItem, {
-      onClick: ungroupColumn,
-      children: apiRef.current.getLocaleText('unGroupColumn')(name)
-    });
-  }
-
-  return /*#__PURE__*/_jsx(MenuItem, {
-    onClick: groupColumn,
-    children: apiRef.current.getLocaleText('groupColumn')(name)
-  });
-};
-
-process.env.NODE_ENV !== "production" ? GridRowGroupableColumnMenuItems.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "yarn proptypes"  |
-  // ----------------------------------------------------------------------
-  column: PropTypes.object,
-  onClick: PropTypes.func
-} : void 0;
-export { GridRowGroupableColumnMenuItems };

package/legacy/components/GridRowGroupingColumnMenuItems.js

@@ -1,56 +0,0 @@
-import * as React from 'react';
-import PropTypes from 'prop-types';
-import MenuItem from '@mui/material/MenuItem';
-import { useGridSelector, gridColumnLookupSelector } from '@mui/x-data-grid';
-import { useGridApiContext } from '../hooks/utils/useGridApiContext';
-import { gridRowGroupingSanitizedModelSelector } from '../hooks/features/rowGrouping/gridRowGroupingSelector';
-import { getRowGroupingCriteriaFromGroupingField, GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD, isGroupingColumn } from '../hooks/features/rowGrouping/gridRowGroupingUtils';
-import { jsx as _jsx } from "react/jsx-runtime";
-
-var GridRowGroupingColumnMenuItems = function GridRowGroupingColumnMenuItems(props) {
-  var column = props.column,
-      onClick = props.onClick;
-  var apiRef = useGridApiContext();
-  var rowGroupingModel = useGridSelector(apiRef, gridRowGroupingSanitizedModelSelector);
-  var columnsLookup = useGridSelector(apiRef, gridColumnLookupSelector);
-
-  var renderUnGroupingMenuItem = function renderUnGroupingMenuItem(field) {
-    var _columnsLookup$field$;
-
-    var ungroupColumn = function ungroupColumn(event) {
-      apiRef.current.removeRowGroupingCriteria(field);
-
-      if (onClick) {
-        onClick(event);
-      }
-    };
-
-    var name = (_columnsLookup$field$ = columnsLookup[field].headerName) != null ? _columnsLookup$field$ : field;
-    return /*#__PURE__*/_jsx(MenuItem, {
-      onClick: ungroupColumn,
-      children: apiRef.current.getLocaleText('unGroupColumn')(name)
-    }, field);
-  };
-
-  if (!column || !isGroupingColumn(column.field)) {
-    return null;
-  }
-
-  if (column.field === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
-    return /*#__PURE__*/_jsx(React.Fragment, {
-      children: rowGroupingModel.map(renderUnGroupingMenuItem)
-    });
-  }
-
-  return renderUnGroupingMenuItem(getRowGroupingCriteriaFromGroupingField(column.field));
-};
-
-process.env.NODE_ENV !== "production" ? GridRowGroupingColumnMenuItems.propTypes = {
-  // ----------------------------- Warning --------------------------------
-  // | These PropTypes are generated from the TypeScript type definitions |
-  // | To update them edit the TypeScript types and run "yarn proptypes"  |
-  // ----------------------------------------------------------------------
-  column: PropTypes.object,
-  onClick: PropTypes.func
-} : void 0;
-export { GridRowGroupingColumnMenuItems };

package/legacy/hooks/features/detailPanel/useGridDetailPanelCache.js

@@ -1,57 +0,0 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import * as React from 'react';
-import { useGridApiEventHandler, gridRowIdsSelector } from '@mui/x-data-grid';
-
-function cacheContentAndHeight(apiRef, getDetailPanelContent, getDetailPanelHeight) {
-  if (typeof getDetailPanelContent !== 'function') {
-    return {};
-  } // TODO change to lazy approach using a Proxy
-  // only call getDetailPanelContent when asked for an id
-
-
-  var rowIds = gridRowIdsSelector(apiRef);
-  var contentCache = rowIds.reduce(function (acc, id) {
-    var params = apiRef.current.getRowParams(id);
-    acc[id] = getDetailPanelContent(params);
-    return acc;
-  }, {});
-  var heightCache = rowIds.reduce(function (acc, id) {
-    if (contentCache[id] == null) {
-      return acc;
-    }
-
-    var params = apiRef.current.getRowParams(id);
-    acc[id] = getDetailPanelHeight(params);
-    return acc;
-  }, {});
-  return {
-    contentCache: contentCache,
-    heightCache: heightCache
-  };
-}
-
-export var useGridDetailPanelCache = function useGridDetailPanelCache(apiRef, props) {
-  var updateCaches = React.useCallback(function () {
-    apiRef.current.setState(function (state) {
-      return _extends({}, state, {
-        detailPanel: _extends({}, state.detailPanel, cacheContentAndHeight(apiRef, props.getDetailPanelContent, props.getDetailPanelHeight))
-      });
-    });
-    apiRef.current.forceUpdate();
-  }, [apiRef, props.getDetailPanelContent, props.getDetailPanelHeight]);
-  useGridApiEventHandler(apiRef, 'sortedRowsSet', updateCaches);
-  var isFirstRender = React.useRef(true);
-
-  if (isFirstRender.current) {
-    isFirstRender.current = false;
-    updateCaches();
-  }
-
-  React.useEffect(function () {
-    if (isFirstRender.current) {
-      return;
-    }
-
-    updateCaches();
-  }, [updateCaches]);
-};