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

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

import _extends from "@babel/runtime/helpers/esm/extends";
import { gridRowGroupingSanitizedModelSelector } from './gridRowGroupingSelector';
export const GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD = '__row_group_by_columns_group__';
export const ROW_GROUPING_STRATEGY = 'grouping-columns';
export const getRowGroupingFieldFromGroupingCriteria = groupingCriteria => {
  if (groupingCriteria === null) {
    return GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
  }

  return `__row_group_by_columns_group_${groupingCriteria}__`;
};
export const getRowGroupingCriteriaFromGroupingField = groupingColDefField => {
  const match = groupingColDefField.match(/^__row_group_by_columns_group_(.*)__$/);

  if (!match) {
    return null;
  }

  return match[1];
};
export const isGroupingColumn = field => field === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD || getRowGroupingCriteriaFromGroupingField(field) !== null;

/**
 * When filtering a group, we only want to filter according to the items related to this grouping column.
 */
const shouldApplyFilterItemOnGroup = (columnField, node) => {
  if (columnField === GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
    return true;
  }

  const groupingCriteriaField = getRowGroupingCriteriaFromGroupingField(columnField);
  return groupingCriteriaField === node.groupingField;
};
/**
 * A leaf is visible if it passed the filter
 * A group is visible if all the following criteria are met:
 * - One of its children is passing the filter
 * - It is passing the filter
 */


export const filterRowTreeFromGroupingColumns = params => {
  const {
    rowTree,
    isRowMatchingFilters
  } = params;
  const visibleRowsLookup = {};
  const filteredRowsLookup = {};
  const filteredDescendantCountLookup = {};

  const filterTreeNode = (node, areAncestorsPassingChildren, areAncestorsExpanded) => {
    var _node$children, _node$children2;

    let isMatchingFilters;

    if (!isRowMatchingFilters) {
      isMatchingFilters = true;
    } else {
      const shouldApplyItem = node.isAutoGenerated ? columnField => shouldApplyFilterItemOnGroup(columnField, node) : undefined;
      isMatchingFilters = isRowMatchingFilters(node.id, shouldApplyItem);
    }

    let filteredDescendantCount = 0;
    (_node$children = node.children) == null ? void 0 : _node$children.forEach(childId => {
      const childNode = rowTree[childId];
      const childSubTreeSize = filterTreeNode(childNode, areAncestorsPassingChildren && isMatchingFilters, areAncestorsExpanded && !!node.childrenExpanded);
      filteredDescendantCount += childSubTreeSize;
    });
    let shouldPassFilters;

    if (!areAncestorsPassingChildren) {
      shouldPassFilters = false;
    } else if ((_node$children2 = node.children) != null && _node$children2.length) {
      shouldPassFilters = isMatchingFilters && filteredDescendantCount > 0;
    } else {
      shouldPassFilters = isMatchingFilters;
    }

    visibleRowsLookup[node.id] = shouldPassFilters && areAncestorsExpanded;
    filteredRowsLookup[node.id] = shouldPassFilters;

    if (!shouldPassFilters) {
      return 0;
    }

    filteredDescendantCountLookup[node.id] = filteredDescendantCount;

    if (!node.children) {
      return filteredDescendantCount + 1;
    }

    return filteredDescendantCount;
  };

  const nodes = Object.values(rowTree);

  for (let i = 0; i < nodes.length; i += 1) {
    const node = nodes[i];

    if (node.depth === 0) {
      filterTreeNode(node, true, true);
    }
  }

  return {
    visibleRowsLookup,
    filteredRowsLookup,
    filteredDescendantCountLookup
  };
};
export const getColDefOverrides = (groupingColDefProp, fields) => {
  if (typeof groupingColDefProp === 'function') {
    return groupingColDefProp({
      groupingName: ROW_GROUPING_STRATEGY,
      fields
    });
  }

  return groupingColDefProp;
};
export const mergeStateWithRowGroupingModel = rowGroupingModel => state => _extends({}, state, {
  rowGrouping: _extends({}, state.rowGrouping, {
    model: rowGroupingModel
  })
});
export const setStrategyAvailability = (apiRef, disableRowGrouping) => {
  let isAvailable;

  if (disableRowGrouping) {
    isAvailable = () => false;
  } else {
    isAvailable = () => {
      const rowGroupingSanitizedModel = gridRowGroupingSanitizedModelSelector(apiRef);
      return rowGroupingSanitizedModel.length > 0;
    };
  }

  apiRef.current.unstable_setStrategyAvailability('rowTree', ROW_GROUPING_STRATEGY, isAvailable);
};