@mui/x-data-grid-premium/legacy/hooks/features/rowGrouping/useGridRowGroupingPreProcessors.js

The Premium plan edition of the data grid component (MUI X).

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]);
};