@mui/x-data-grid-premium 5.11.0

package/legacy/hooks/features/rowGrouping/useGridRowGrouping.js

@@ -0,0 +1,206 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+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-pro';
+import { useGridRegisterPipeProcessor, isDeepEqual } from '@mui/x-data-grid-pro/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 var rowGroupingStateInitializer = function 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 var useGridRowGrouping = function useGridRowGrouping(apiRef, props) {
+  apiRef.current.unstable_updateControlState({
+    stateId: 'rowGrouping',
+    propModel: props.rowGroupingModel,
+    propOnChange: props.onRowGroupingModelChange,
+    stateSelector: gridRowGroupingModelSelector,
+    changeEvent: 'rowGroupingModelChange'
+  });
+  /**
+   * API METHODS
+   */
+
+  var setRowGroupingModel = React.useCallback(function (model) {
+    var currentModel = gridRowGroupingModelSelector(apiRef);
+
+    if (currentModel !== model) {
+      apiRef.current.setState(mergeStateWithRowGroupingModel(model));
+      setStrategyAvailability(apiRef, props.disableRowGrouping);
+      apiRef.current.forceUpdate();
+    }
+  }, [apiRef, props.disableRowGrouping]);
+  var addRowGroupingCriteria = React.useCallback(function (field, groupingIndex) {
+    var currentModel = gridRowGroupingModelSelector(apiRef);
+
+    if (currentModel.includes(field)) {
+      return;
+    }
+
+    var cleanGroupingIndex = groupingIndex != null ? groupingIndex : currentModel.length;
+    var updatedModel = [].concat(_toConsumableArray(currentModel.slice(0, cleanGroupingIndex)), [field], _toConsumableArray(currentModel.slice(cleanGroupingIndex)));
+    apiRef.current.setRowGroupingModel(updatedModel);
+  }, [apiRef]);
+  var removeRowGroupingCriteria = React.useCallback(function (field) {
+    var currentModel = gridRowGroupingModelSelector(apiRef);
+
+    if (!currentModel.includes(field)) {
+      return;
+    }
+
+    apiRef.current.setRowGroupingModel(currentModel.filter(function (el) {
+      return el !== field;
+    }));
+  }, [apiRef]);
+  var setRowGroupingCriteriaIndex = React.useCallback(function (field, targetIndex) {
+    var currentModel = gridRowGroupingModelSelector(apiRef);
+    var currentTargetIndex = currentModel.indexOf(field);
+
+    if (currentTargetIndex === -1) {
+      return;
+    }
+
+    var updatedModel = _toConsumableArray(currentModel);
+
+    updatedModel.splice(targetIndex, 0, updatedModel.splice(currentTargetIndex, 1)[0]);
+    apiRef.current.setRowGroupingModel(updatedModel);
+  }, [apiRef]);
+  var rowGroupingApi = {
+    setRowGroupingModel: setRowGroupingModel,
+    addRowGroupingCriteria: addRowGroupingCriteria,
+    removeRowGroupingCriteria: removeRowGroupingCriteria,
+    setRowGroupingCriteriaIndex: setRowGroupingCriteriaIndex
+  };
+  useGridApiMethod(apiRef, rowGroupingApi, 'GridRowGroupingApi');
+  /**
+   * PRE-PROCESSING
+   */
+
+  var addColumnMenuButtons = React.useCallback(function (initialValue, columns) {
+    if (props.disableRowGrouping) {
+      return initialValue;
+    }
+
+    var 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 [].concat(_toConsumableArray(initialValue), [/*#__PURE__*/_jsx(Divider, {}), menuItems]);
+  }, [props.disableRowGrouping]);
+  var stateExportPreProcessing = React.useCallback(function (prevState) {
+    if (props.disableRowGrouping) {
+      return prevState;
+    }
+
+    var rowGroupingModelToExport = gridRowGroupingModelSelector(apiRef);
+
+    if (rowGroupingModelToExport.length === 0) {
+      return prevState;
+    }
+
+    return _extends({}, prevState, {
+      rowGrouping: {
+        model: rowGroupingModelToExport
+      }
+    });
+  }, [apiRef, props.disableRowGrouping]);
+  var stateRestorePreProcessing = React.useCallback(function (params, context) {
+    var _context$stateToResto;
+
+    if (props.disableRowGrouping) {
+      return params;
+    }
+
+    var 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
+   */
+
+  var handleCellKeyDown = React.useCallback(function (params, event) {
+    var cellParams = apiRef.current.getCellParams(params.id, params.field);
+
+    if (isGroupingColumn(cellParams.field) && event.key === ' ' && !event.shiftKey) {
+      var _gridFilteredDescenda;
+
+      event.stopPropagation();
+      event.preventDefault();
+      var filteredDescendantCount = (_gridFilteredDescenda = gridFilteredDescendantCountLookupSelector(apiRef)[params.id]) != null ? _gridFilteredDescenda : 0;
+      var 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]);
+  var checkGroupingColumnsModelDiff = React.useCallback(function () {
+    var rowGroupingModel = gridRowGroupingSanitizedModelSelector(apiRef);
+    var lastGroupingColumnsModelApplied = gridRowGroupingStateSelector(apiRef.current.state).unstable_sanitizedModelOnLastRowTreeCreation;
+
+    if (!isDeepEqual(lastGroupingColumnsModelApplied, rowGroupingModel)) {
+      apiRef.current.setState(function (state) {
+        return _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(function () {
+    if (props.rowGroupingModel !== undefined) {
+      apiRef.current.setRowGroupingModel(props.rowGroupingModel);
+    }
+  }, [apiRef, props.rowGroupingModel]);
+};

package/legacy/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.js

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

package/legacy/hooks/index.js

@@ -0,0 +1,3 @@
+// Only export the variable and types that should be publicly exposed and re-exported from `@mui/x-data-grid-premium`
+export * from './features';
+export * from './utils';

package/legacy/hooks/utils/index.js

@@ -0,0 +1 @@
+export * from './useKeepGroupedColumnsHidden';

package/legacy/hooks/utils/useGridApiContext.js

@@ -0,0 +1,2 @@
+import { useGridApiContext as useCommunityGridApiContext } from '@mui/x-data-grid-pro';
+export var useGridApiContext = useCommunityGridApiContext;

package/legacy/hooks/utils/useGridApiRef.js

@@ -0,0 +1,2 @@
+import { useGridApiRef as useCommunityGridApiRef } from '@mui/x-data-grid-pro';
+export var useGridApiRef = useCommunityGridApiRef;

package/legacy/hooks/utils/useGridRootProps.js

@@ -0,0 +1,2 @@
+import { useGridRootProps as useCommunityGridRootProps } from '@mui/x-data-grid-pro';
+export var useGridRootProps = useCommunityGridRootProps;

package/legacy/hooks/utils/useKeepGroupedColumnsHidden.js

@@ -0,0 +1,50 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { gridColumnVisibilityModelSelector, GridEvents } from '@mui/x-data-grid-pro';
+
+var updateColumnVisibilityModel = function updateColumnVisibilityModel(columnVisibilityModel, rowGroupingModel, prevRowGroupingModel) {
+  var newColumnVisibilityModel = _extends({}, columnVisibilityModel);
+
+  rowGroupingModel == null ? void 0 : rowGroupingModel.forEach(function (field) {
+    if (!(prevRowGroupingModel != null && prevRowGroupingModel.includes(field))) {
+      newColumnVisibilityModel[field] = false;
+    }
+  });
+  prevRowGroupingModel == null ? void 0 : prevRowGroupingModel.forEach(function (field) {
+    if (!(rowGroupingModel != null && rowGroupingModel.includes(field))) {
+      newColumnVisibilityModel[field] = true;
+    }
+  });
+  return newColumnVisibilityModel;
+};
+/**
+ * Automatically hide columns when added to the row grouping model and stop hiding them when they are removed.
+ * Handles both the `props.initialState.rowGrouping.model` and `props.rowGroupingModel`
+ * Does not work when used with the `hide` property of `GridColDef`
+ */
+
+
+export var useKeepGroupedColumnsHidden = function useKeepGroupedColumnsHidden(props) {
+  var _props$rowGroupingMod, _props$initialState, _props$initialState$r;
+
+  var initialProps = React.useRef(props);
+  var rowGroupingModel = React.useRef((_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);
+  React.useEffect(function () {
+    props.apiRef.current.subscribeEvent(GridEvents.rowGroupingModelChange, function (newModel) {
+      var columnVisibilityModel = updateColumnVisibilityModel(gridColumnVisibilityModelSelector(props.apiRef), newModel, rowGroupingModel.current);
+      props.apiRef.current.setColumnVisibilityModel(columnVisibilityModel);
+      rowGroupingModel.current = newModel;
+    });
+  }, [props.apiRef]);
+  return React.useMemo(function () {
+    var _invariantInitialStat;
+
+    var invariantInitialState = initialProps.current.initialState;
+    var columnVisibilityModel = updateColumnVisibilityModel(invariantInitialState == null ? void 0 : (_invariantInitialStat = invariantInitialState.columns) == null ? void 0 : _invariantInitialStat.columnVisibilityModel, rowGroupingModel.current, undefined);
+    return _extends({}, invariantInitialState, {
+      columns: _extends({}, invariantInitialState == null ? void 0 : invariantInitialState.columns, {
+        columnVisibilityModel: columnVisibilityModel
+      })
+    });
+  }, []);
+};

package/legacy/index.js

@@ -0,0 +1,25 @@
+/** @license MUI v5.11.0
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import './typeOverloads';
+import '@mui/x-data-grid-pro/typeOverloads';
+export { LicenseInfo } from '@mui/x-license-pro';
+export * from '@mui/x-data-grid/components';
+export * from '@mui/x-data-grid-pro/components';
+export * from '@mui/x-data-grid/constants';
+export * from '@mui/x-data-grid/hooks';
+export * from '@mui/x-data-grid-pro/hooks';
+export * from '@mui/x-data-grid/locales';
+export * from '@mui/x-data-grid/models';
+export * from '@mui/x-data-grid-pro/models';
+export * from '@mui/x-data-grid/context';
+export * from '@mui/x-data-grid/colDef';
+export * from '@mui/x-data-grid/utils';
+export * from '@mui/x-data-grid-pro/utils';
+export * from './DataGridPremium';
+export * from './hooks';
+export * from './models';
+export * from './components';
+export { useGridApiContext, useGridApiRef, useGridRootProps } from './typeOverloads/reexports';

package/legacy/models/dataGridPremiumProps.js

@@ -0,0 +1 @@
+export {};

package/legacy/models/gridApiPremium.js

@@ -0,0 +1 @@
+export {};

package/legacy/models/gridGroupingValueGetterParams.js

@@ -0,0 +1 @@
+export {};

package/legacy/models/gridStatePremium.js

@@ -0,0 +1 @@
+export {};

package/legacy/models/index.js

@@ -0,0 +1 @@
+export * from './gridGroupingValueGetterParams';

package/legacy/typeOverloads/index.js

@@ -0,0 +1 @@
+import '@mui/x-data-grid-pro/typeOverloads';

package/legacy/typeOverloads/modules.js

@@ -0,0 +1,33 @@
+// import { GridKeyValue, GridValidRowModel } from '@mui/x-data-grid-pro';
+// import type { GridControlledStateEventLookupPro } from '@mui/x-data-grid-pro/typeOverloads';
+// import type { GridGroupingValueGetterParams } from '../models';
+// import type { GridRowGroupingModel } from '../hooks';
+//
+// export interface GridControlledStateEventLookupPremium {
+//   /**
+//    * Fired when the row grouping model changes.
+//    */
+//   rowGroupingModelChange: { params: GridRowGroupingModel };
+// }
+//
+// // eslint-disable-next-line @typescript-eslint/no-unused-vars
+// export interface GridColDefPremium<R extends GridValidRowModel = any, V = any, F = V> {
+//   /**
+//    * Function that transforms a complex cell value into a key that be used for grouping the rows.
+//    * @param {GridGroupingValueGetterParams} params Object containing parameters for the getter.
+//    * @returns {GridKeyValue | null | undefined} The cell key.
+//    */
+//   groupingValueGetter?: (
+//     params: GridGroupingValueGetterParams<V, R>,
+//   ) => GridKeyValue | null | undefined;
+// }
+//
+// declare module '@mui/x-data-grid-pro' {
+//   export interface GridColDef<R extends GridValidRowModel = any, V = any, F = V>
+//     extends GridColDefPremium<R, V, F> {}
+//
+//   // TODO: Remove explicit augmentation of pro package
+//   interface GridControlledStateEventLookup
+//     extends GridControlledStateEventLookupPro,
+//       GridControlledStateEventLookupPremium {}
+// }

package/legacy/typeOverloads/reexports.js

@@ -0,0 +1,6 @@
+export { useGridApiContext } from '../hooks/utils/useGridApiContext';
+export { useGridApiRef } from '../hooks/utils/useGridApiRef';
+export { useGridRootProps } from '../hooks/utils/useGridRootProps';
+/**
+ * The full grid API.
+ */

package/legacy/utils/releaseInfo.js

@@ -0,0 +1,15 @@
+import { ponyfillGlobal } from '@mui/utils';
+export var getReleaseInfo = function getReleaseInfo() {
+  var releaseInfo = "MTY1MjM5MjgwMDAwMA==";
+
+  if (process.env.NODE_ENV !== 'production') {
+    // A simple hack to set the value in the test environment (has no build step).
+    // eslint-disable-next-line no-useless-concat
+    if (releaseInfo === '__RELEASE' + '_INFO__') {
+      // eslint-disable-next-line no-underscore-dangle
+      return ponyfillGlobal.__MUI_RELEASE_INFO__;
+    }
+  }
+
+  return releaseInfo;
+};

package/models/dataGridPremiumProps.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { GridCallbackDetails, GridValidRowModel } from '@mui/x-data-grid-pro';
+import { GridExperimentalProFeatures, DataGridProPropsWithDefaultValue, DataGridProPropsWithoutDefaultValue, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPropsWithComplexDefaultValueBeforeProcessing } from '@mui/x-data-grid-pro/internals';
+import type { GridRowGroupingModel } from '../hooks/features/rowGrouping';
+import { GridInitialStatePremium } from './gridStatePremium';
+import { GridApiPremium } from './gridApiPremium';
+export interface GridExperimentalPremiumFeatures extends GridExperimentalProFeatures {
+}
+/**
+ * The props users can give to the `DataGridProProps` component.
+ */
+export interface DataGridPremiumProps<R extends GridValidRowModel = any> extends Omit<Partial<DataGridPremiumPropsWithDefaultValue> & DataGridPropsWithComplexDefaultValueBeforeProcessing & DataGridPremiumPropsWithoutDefaultValue<R>, DataGridPremiumForcedPropsKey> {
+    /**
+     * Features under development.
+     * For each feature, if the flag is not explicitly set to `true`, the feature will be fully disabled and any property / method call will not have any effect.
+     */
+    experimentalFeatures?: Partial<GridExperimentalPremiumFeatures>;
+}
+/**
+ * The props of the `DataGridPremium` component after the pre-processing phase.
+ */
+export interface DataGridPremiumProcessedProps extends DataGridPremiumPropsWithDefaultValue, DataGridPropsWithComplexDefaultValueAfterProcessing, DataGridPremiumPropsWithoutDefaultValue {
+}
+export declare type DataGridPremiumForcedPropsKey = 'signature';
+/**
+ * The `DataGridPremium` options with a default value overridable through props
+ * None of the entry of this interface should be optional, they all have default values and `DataGridProps` already applies a `Partial<DataGridSimpleOptions>` for the public interface
+ * The controlled model do not have a default value at the prop processing level, so they must be defined in `DataGridOtherProps`
+ */
+export interface DataGridPremiumPropsWithDefaultValue extends DataGridProPropsWithDefaultValue {
+    /**
+     * If `true`, the row grouping is disabled.
+     * @default false
+     */
+    disableRowGrouping: boolean;
+    /**
+     * If `single`, all column we are grouping by will be represented in the same grouping the same column.
+     * If `multiple`, each column we are grouping by will be represented in its own column.
+     * @default 'single'
+     */
+    rowGroupingColumnMode: 'single' | 'multiple';
+}
+export interface DataGridPremiumPropsWithoutDefaultValue<R extends GridValidRowModel = any> extends Omit<DataGridProPropsWithoutDefaultValue<R>, 'initialState' | 'apiRef'> {
+    /**
+     * The ref object that allows grid manipulation. Can be instantiated with [[useGridApiRef()]].
+     */
+    apiRef?: React.MutableRefObject<GridApiPremium>;
+    /**
+     * The initial state of the DataGridPremium.
+     * The data in it will be set in the state on initialization but will not be controlled.
+     * If one of the data in `initialState` is also being controlled, then the control state wins.
+     */
+    initialState?: GridInitialStatePremium;
+    /**
+     * Set the row grouping model of the grid.
+     */
+    rowGroupingModel?: GridRowGroupingModel;
+    /**
+     * Callback fired when the row grouping model changes.
+     * @param {GridRowGroupingModel} model Columns used as grouping criteria.
+     * @param {GridCallbackDetails} details Additional details for this callback.
+     */
+    onRowGroupingModelChange?: (model: GridRowGroupingModel, details: GridCallbackDetails) => void;
+}

package/models/dataGridPremiumProps.js

@@ -0,0 +1 @@
+export {};