@mui/x-data-grid-premium 5.11.0

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

@@ -0,0 +1,228 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRowGrouping = exports.rowGroupingStateInitializer = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Divider = _interopRequireDefault(require("@mui/material/Divider"));
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
+
+var _gridRowGroupingUtils = require("./gridRowGroupingUtils");
+
+var _GridRowGroupableColumnMenuItems = require("../../../components/GridRowGroupableColumnMenuItems");
+
+var _GridRowGroupingColumnMenuItems = require("../../../components/GridRowGroupingColumnMenuItems");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const rowGroupingStateInitializer = (state, props) => {
+  var _ref, _props$rowGroupingMod, _props$initialState, _props$initialState$r;
+
+  return (0, _extends2.default)({}, 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
+ */
+
+
+exports.rowGroupingStateInitializer = rowGroupingStateInitializer;
+
+const useGridRowGrouping = (apiRef, props) => {
+  apiRef.current.unstable_updateControlState({
+    stateId: 'rowGrouping',
+    propModel: props.rowGroupingModel,
+    propOnChange: props.onRowGroupingModelChange,
+    stateSelector: _gridRowGroupingSelector.gridRowGroupingModelSelector,
+    changeEvent: 'rowGroupingModelChange'
+  });
+  /**
+   * API METHODS
+   */
+
+  const setRowGroupingModel = React.useCallback(model => {
+    const currentModel = (0, _gridRowGroupingSelector.gridRowGroupingModelSelector)(apiRef);
+
+    if (currentModel !== model) {
+      apiRef.current.setState((0, _gridRowGroupingUtils.mergeStateWithRowGroupingModel)(model));
+      (0, _gridRowGroupingUtils.setStrategyAvailability)(apiRef, props.disableRowGrouping);
+      apiRef.current.forceUpdate();
+    }
+  }, [apiRef, props.disableRowGrouping]);
+  const addRowGroupingCriteria = React.useCallback((field, groupingIndex) => {
+    const currentModel = (0, _gridRowGroupingSelector.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 = (0, _gridRowGroupingSelector.gridRowGroupingModelSelector)(apiRef);
+
+    if (!currentModel.includes(field)) {
+      return;
+    }
+
+    apiRef.current.setRowGroupingModel(currentModel.filter(el => el !== field));
+  }, [apiRef]);
+  const setRowGroupingCriteriaIndex = React.useCallback((field, targetIndex) => {
+    const currentModel = (0, _gridRowGroupingSelector.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
+  };
+  (0, _xDataGridPro.useGridApiMethod)(apiRef, rowGroupingApi, 'GridRowGroupingApi');
+  /**
+   * PRE-PROCESSING
+   */
+
+  const addColumnMenuButtons = React.useCallback((initialValue, columns) => {
+    if (props.disableRowGrouping) {
+      return initialValue;
+    }
+
+    let menuItems;
+
+    if ((0, _gridRowGroupingUtils.isGroupingColumn)(columns.field)) {
+      menuItems = /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridRowGroupingColumnMenuItems.GridRowGroupingColumnMenuItems, {});
+    } else if (columns.groupable) {
+      menuItems = /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridRowGroupableColumnMenuItems.GridRowGroupableColumnMenuItems, {});
+    } else {
+      menuItems = null;
+    }
+
+    if (menuItems == null) {
+      return initialValue;
+    }
+
+    return [...initialValue, /*#__PURE__*/(0, _jsxRuntime.jsx)(_Divider.default, {}), menuItems];
+  }, [props.disableRowGrouping]);
+  const stateExportPreProcessing = React.useCallback(prevState => {
+    if (props.disableRowGrouping) {
+      return prevState;
+    }
+
+    const rowGroupingModelToExport = (0, _gridRowGroupingSelector.gridRowGroupingModelSelector)(apiRef);
+
+    if (rowGroupingModelToExport.length === 0) {
+      return prevState;
+    }
+
+    return (0, _extends2.default)({}, 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((0, _gridRowGroupingUtils.mergeStateWithRowGroupingModel)(rowGroupingModel));
+    }
+
+    return params;
+  }, [apiRef, props.disableRowGrouping]);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'columnMenu', addColumnMenuButtons);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'exportState', stateExportPreProcessing);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'restoreState', stateRestorePreProcessing);
+  /**
+   * EVENTS
+   */
+
+  const handleCellKeyDown = React.useCallback((params, event) => {
+    const cellParams = apiRef.current.getCellParams(params.id, params.field);
+
+    if ((0, _gridRowGroupingUtils.isGroupingColumn)(cellParams.field) && event.key === ' ' && !event.shiftKey) {
+      var _gridFilteredDescenda;
+
+      event.stopPropagation();
+      event.preventDefault();
+      const filteredDescendantCount = (_gridFilteredDescenda = (0, _xDataGridPro.gridFilteredDescendantCountLookupSelector)(apiRef)[params.id]) != null ? _gridFilteredDescenda : 0;
+      const isOnGroupingCell = props.rowGroupingColumnMode === 'single' || (0, _gridRowGroupingUtils.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 = (0, _gridRowGroupingSelector.gridRowGroupingSanitizedModelSelector)(apiRef);
+    const lastGroupingColumnsModelApplied = (0, _gridRowGroupingSelector.gridRowGroupingStateSelector)(apiRef.current.state).unstable_sanitizedModelOnLastRowTreeCreation;
+
+    if (!(0, _internals.isDeepEqual)(lastGroupingColumnsModelApplied, rowGroupingModel)) {
+      apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+        rowGrouping: (0, _extends2.default)({}, state.rowGrouping, {
+          unstable_sanitizedModelOnLastRowTreeCreation: rowGroupingModel
+        })
+      }));
+      apiRef.current.unstable_requestPipeProcessorsApplication('hydrateColumns');
+      (0, _gridRowGroupingUtils.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') === _gridRowGroupingUtils.ROW_GROUPING_STRATEGY) {
+        apiRef.current.publishEvent('activeStrategyProcessorChange', 'rowTreeCreation');
+      }
+    }
+  }, [apiRef, props.disableRowGrouping]);
+  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'cellKeyDown', handleCellKeyDown);
+  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'columnsChange', checkGroupingColumnsModelDiff);
+  (0, _xDataGridPro.useGridApiEventHandler)(apiRef, 'rowGroupingModelChange', checkGroupingColumnsModelDiff);
+  /**
+   * EFFECTS
+   */
+
+  React.useEffect(() => {
+    if (props.rowGroupingModel !== undefined) {
+      apiRef.current.setRowGroupingModel(props.rowGroupingModel);
+    }
+  }, [apiRef, props.rowGroupingModel]);
+};
+
+exports.useGridRowGrouping = useGridRowGrouping;

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

@@ -0,0 +1,223 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRowGroupingPreProcessors = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
+
+var _createGroupingColDef = require("./createGroupingColDef");
+
+var _gridRowGroupingUtils = require("./gridRowGroupingUtils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 = (0, _gridRowGroupingSelector.gridRowGroupingModelSelector)(apiRef).filter(field => !!columnsState.lookup[field]);
+
+    if (rowGroupingModel.length === 0) {
+      return [];
+    }
+
+    switch (props.rowGroupingColumnMode) {
+      case 'single':
+        {
+          return [(0, _createGroupingColDef.createGroupingColDefForAllGroupingCriteria)({
+            apiRef,
+            rowGroupingModel,
+            colDefOverride: (0, _gridRowGroupingUtils.getColDefOverrides)(groupingColDefProp, rowGroupingModel),
+            columnsLookup: columnsState.lookup
+          })];
+        }
+
+      case 'multiple':
+        {
+          return rowGroupingModel.map(groupingCriteria => (0, _createGroupingColDef.createGroupingColDefForOneGroupingCriteria)({
+            groupingCriteria,
+            colDefOverride: (0, _gridRowGroupingUtils.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 (!(0, _gridRowGroupingUtils.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 = (0, _gridRowGroupingSelector.gridRowGroupingSanitizedModelSelector)(apiRef);
+    const columnsLookup = (0, _xDataGridPro.gridColumnLookupSelector)(apiRef);
+    apiRef.current.setState(state => (0, _extends2.default)({}, state, {
+      rowGrouping: (0, _extends2.default)({}, 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 (0, _internals.buildRowTree)((0, _extends2.default)({}, params, {
+      rows,
+      defaultGroupingExpansionDepth: props.defaultGroupingExpansionDepth,
+      isGroupExpandedByDefault: props.isGroupExpandedByDefault,
+      groupingName: _gridRowGroupingUtils.ROW_GROUPING_STRATEGY
+    }));
+  }, [apiRef, props.defaultGroupingExpansionDepth, props.isGroupExpandedByDefault]);
+  const filterRows = React.useCallback(params => {
+    const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
+    return (0, _gridRowGroupingUtils.filterRowTreeFromGroupingColumns)({
+      rowTree,
+      isRowMatchingFilters: params.isRowMatchingFilters
+    });
+  }, [apiRef]);
+  const sortRows = React.useCallback(params => {
+    const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
+    const rowIds = (0, _xDataGridPro.gridRowIdsSelector)(apiRef);
+    return (0, _internals.sortRowTree)({
+      rowTree,
+      rowIds,
+      sortRowList: params.sortRowList,
+      disableChildrenSorting: false
+    });
+  }, [apiRef]);
+  (0, _internals.useGridRegisterPipeProcessor)(apiRef, 'hydrateColumns', updateGroupingColumn);
+  (0, _internals.useGridRegisterStrategyProcessor)(apiRef, _gridRowGroupingUtils.ROW_GROUPING_STRATEGY, 'rowTreeCreation', createRowTree);
+  (0, _internals.useGridRegisterStrategyProcessor)(apiRef, _gridRowGroupingUtils.ROW_GROUPING_STRATEGY, 'filtering', filterRows);
+  (0, _internals.useGridRegisterStrategyProcessor)(apiRef, _gridRowGroupingUtils.ROW_GROUPING_STRATEGY, 'sorting', sortRows);
+  /**
+   * 1ST RENDER
+   */
+
+  (0, _xDataGridPro.useFirstRender)(() => {
+    (0, _gridRowGroupingUtils.setStrategyAvailability)(apiRef, props.disableRowGrouping);
+  });
+  /**
+   * EFFECTS
+   */
+
+  const isFirstRender = React.useRef(true);
+  React.useEffect(() => {
+    if (!isFirstRender.current) {
+      (0, _gridRowGroupingUtils.setStrategyAvailability)(apiRef, props.disableRowGrouping);
+    } else {
+      isFirstRender.current = false;
+    }
+  }, [apiRef, props.disableRowGrouping]);
+};
+
+exports.useGridRowGroupingPreProcessors = useGridRowGroupingPreProcessors;

package/node/hooks/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _features = require("./features");
+
+Object.keys(_features).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _features[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _features[key];
+    }
+  });
+});
+
+var _utils = require("./utils");
+
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});

package/node/hooks/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _useKeepGroupedColumnsHidden = require("./useKeepGroupedColumnsHidden");
+
+Object.keys(_useKeepGroupedColumnsHidden).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useKeepGroupedColumnsHidden[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useKeepGroupedColumnsHidden[key];
+    }
+  });
+});

package/node/hooks/utils/useGridApiContext.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiContext = void 0;
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+const useGridApiContext = _xDataGridPro.useGridApiContext;
+exports.useGridApiContext = useGridApiContext;

package/node/hooks/utils/useGridApiRef.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridApiRef = void 0;
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+const useGridApiRef = _xDataGridPro.useGridApiRef;
+exports.useGridApiRef = useGridApiRef;

package/node/hooks/utils/useGridRootProps.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useGridRootProps = void 0;
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+const useGridRootProps = _xDataGridPro.useGridRootProps;
+exports.useGridRootProps = useGridRootProps;

package/node/hooks/utils/useKeepGroupedColumnsHidden.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useKeepGroupedColumnsHidden = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const updateColumnVisibilityModel = (columnVisibilityModel, rowGroupingModel, prevRowGroupingModel) => {
+  const newColumnVisibilityModel = (0, _extends2.default)({}, columnVisibilityModel);
+  rowGroupingModel == null ? void 0 : rowGroupingModel.forEach(field => {
+    if (!(prevRowGroupingModel != null && prevRowGroupingModel.includes(field))) {
+      newColumnVisibilityModel[field] = false;
+    }
+  });
+  prevRowGroupingModel == null ? void 0 : prevRowGroupingModel.forEach(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`
+ */
+
+
+const useKeepGroupedColumnsHidden = props => {
+  var _props$rowGroupingMod, _props$initialState, _props$initialState$r;
+
+  const initialProps = React.useRef(props);
+  const 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(() => {
+    props.apiRef.current.subscribeEvent(_xDataGridPro.GridEvents.rowGroupingModelChange, newModel => {
+      const columnVisibilityModel = updateColumnVisibilityModel((0, _xDataGridPro.gridColumnVisibilityModelSelector)(props.apiRef), newModel, rowGroupingModel.current);
+      props.apiRef.current.setColumnVisibilityModel(columnVisibilityModel);
+      rowGroupingModel.current = newModel;
+    });
+  }, [props.apiRef]);
+  return React.useMemo(() => {
+    var _invariantInitialStat;
+
+    const invariantInitialState = initialProps.current.initialState;
+    const columnVisibilityModel = updateColumnVisibilityModel(invariantInitialState == null ? void 0 : (_invariantInitialStat = invariantInitialState.columns) == null ? void 0 : _invariantInitialStat.columnVisibilityModel, rowGroupingModel.current, undefined);
+    return (0, _extends2.default)({}, invariantInitialState, {
+      columns: (0, _extends2.default)({}, invariantInitialState == null ? void 0 : invariantInitialState.columns, {
+        columnVisibilityModel
+      })
+    });
+  }, []);
+};
+
+exports.useKeepGroupedColumnsHidden = useKeepGroupedColumnsHidden;