@mui/x-data-grid-premium/esm/hooks/features/aggregation/wrapColumnWithAggregation.js

The Premium plan edition of the MUI X Data Grid Components.

import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
import _extends from "@babel/runtime/helpers/esm/extends";
const _excluded = ["aggregationWrappedProperties"];
import { gridRowNodeSelector } from '@mui/x-data-grid-pro';
import { GridFooterCell } from '@mui/x-data-grid-pro/internals';
import { gridAggregationLookupSelector } from "./gridAggregationSelectors.js";
import { GridAggregationHeader } from "../../../components/GridAggregationHeader.js";
import { gridPivotActiveSelector } from "../pivoting/gridPivotingSelectors.js";
import { jsx as _jsx } from "react/jsx-runtime";
const getAggregationValueWrappedRenderCell = ({
  value: renderCell,
  aggregationRule,
  getCellAggregationResult,
  apiRef
}) => {
  const pivotActive = gridPivotActiveSelector(apiRef);
  const wrappedRenderCell = params => {
    const cellAggregationResult = getCellAggregationResult(params.id, params.field);
    if (cellAggregationResult != null) {
      if (!renderCell) {
        if (cellAggregationResult.position === 'footer') {
          return /*#__PURE__*/_jsx(GridFooterCell, _extends({}, params));
        }
        if (pivotActive && cellAggregationResult.value === 0) {
          return null;
        }
        return params.formattedValue;
      }
      if (pivotActive && cellAggregationResult.value === 0) {
        return null;
      }
      const aggregationMeta = {
        hasCellUnit: aggregationRule.aggregationFunction.hasCellUnit ?? true,
        aggregationFunctionName: aggregationRule.aggregationFunctionName,
        position: cellAggregationResult.position
      };
      return renderCell(_extends({}, params, {
        aggregation: aggregationMeta
      }));
    }
    if (!renderCell) {
      return params.formattedValue;
    }
    return renderCell(params);
  };
  return wrappedRenderCell;
};

/**
 * Add the aggregation method around the header name
 */
const getWrappedRenderHeader = ({
  value: renderHeader,
  aggregationRule
}) => {
  const wrappedRenderHeader = params => {
    // TODO: investigate why colDef is undefined
    if (!params.colDef) {
      return null;
    }
    return /*#__PURE__*/_jsx(GridAggregationHeader, _extends({}, params, {
      aggregation: {
        aggregationRule
      },
      renderHeader: renderHeader
    }));
  };
  if (process.env.NODE_ENV !== "production") wrappedRenderHeader.displayName = "wrappedRenderHeader";
  return wrappedRenderHeader;
};

/**
 * Add a wrapper around each wrappable property of the column to customize the behavior of the aggregation cells.
 */
export const wrapColumnWithAggregationValue = (column, aggregationRule, apiRef) => {
  const getCellAggregationResult = (id, field) => {
    let cellAggregationPosition = null;
    const rowNode = gridRowNodeSelector(apiRef, id);
    if (!rowNode) {
      return null;
    }
    if (rowNode.type === 'group') {
      cellAggregationPosition = 'inline';
    } else if (id.toString().startsWith('auto-generated-group-footer-')) {
      cellAggregationPosition = 'footer';
    }
    if (cellAggregationPosition == null) {
      return null;
    }

    // TODO: Add custom root id
    const groupId = cellAggregationPosition === 'inline' ? id : rowNode.parent ?? '';
    const aggregationResult = gridAggregationLookupSelector(apiRef)?.[groupId]?.[field];
    if (!aggregationResult || aggregationResult.position !== cellAggregationPosition) {
      return null;
    }
    return aggregationResult;
  };
  let didWrapSomeProperty = false;
  const wrappedColumn = _extends({}, column, {
    aggregationWrappedProperties: []
  });
  const wrapColumnProperty = (property, wrapper) => {
    const originalValue = column[property];
    const wrappedProperty = wrapper({
      apiRef,
      value: originalValue,
      colDef: column,
      aggregationRule,
      getCellAggregationResult
    });
    if (wrappedProperty !== originalValue) {
      didWrapSomeProperty = true;
      wrappedColumn[property] = wrappedProperty;
      wrappedColumn.aggregationWrappedProperties.push({
        name: property,
        originalValue,
        wrappedValue: wrappedProperty
      });
    }
  };
  wrapColumnProperty('renderCell', getAggregationValueWrappedRenderCell);
  wrapColumnProperty('renderHeader', getWrappedRenderHeader);
  if (!didWrapSomeProperty) {
    return column;
  }
  return wrappedColumn;
};
const isColumnWrappedWithAggregation = column => {
  return typeof column.aggregationWrappedProperties !== 'undefined';
};

/**
 * Remove the aggregation wrappers around the wrappable properties of the column.
 */
export const unwrapColumnFromAggregation = column => {
  if (!isColumnWrappedWithAggregation(column)) {
    return column;
  }
  const _ref = column,
    {
      aggregationWrappedProperties
    } = _ref,
    unwrappedColumn = _objectWithoutPropertiesLoose(_ref, _excluded);
  aggregationWrappedProperties.forEach(({
    name,
    originalValue,
    wrappedValue
  }) => {
    // The value changed since we wrapped it
    if (wrappedValue !== unwrappedColumn[name]) {
      return;
    }
    unwrappedColumn[name] = originalValue;
  });
  return unwrappedColumn;
};