@mui/x-data-grid-premium
Version:
The Premium plan edition of the MUI X Data Grid Components.
211 lines (208 loc) • 7.77 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD", {
enumerable: true,
get: function () {
return _internals.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
}
});
exports.getGroupingRules = exports.getColDefOverrides = exports.getCellGroupingCriteria = exports.filterRowTreeFromGroupingColumns = exports.areGroupingRulesEqual = void 0;
Object.defineProperty(exports, "getRowGroupingCriteriaFromGroupingField", {
enumerable: true,
get: function () {
return _internals.getRowGroupingCriteriaFromGroupingField;
}
});
exports.getRowGroupingFieldFromGroupingCriteria = void 0;
Object.defineProperty(exports, "isGroupingColumn", {
enumerable: true,
get: function () {
return _internals.isGroupingColumn;
}
});
exports.setStrategyAvailability = exports.mergeStateWithRowGroupingModel = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _internals = require("@mui/x-data-grid-pro/internals");
var _gridRowGroupingSelector = require("./gridRowGroupingSelector");
const getRowGroupingFieldFromGroupingCriteria = groupingCriteria => {
if (groupingCriteria === null) {
return _internals.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD;
}
return `__row_group_by_columns_group_${groupingCriteria}__`;
};
exports.getRowGroupingFieldFromGroupingCriteria = getRowGroupingFieldFromGroupingCriteria;
/**
* When filtering a group, we only want to filter according to the items related to this grouping column.
*/
const shouldApplyFilterItemOnGroup = (columnField, node) => {
if (columnField === _internals.GRID_ROW_GROUPING_SINGLE_GROUPING_FIELD) {
return true;
}
const groupingCriteriaField = (0, _internals.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
*/
const filterRowTreeFromGroupingColumns = params => {
const {
apiRef,
rowTree,
isRowMatchingFilters,
filterModel,
filterValueGetter
} = params;
const filteredRowsLookup = {};
const filteredChildrenCountLookup = {};
const filteredDescendantCountLookup = {};
const filterCache = {};
const filterTreeNode = (node, areAncestorsExpanded, ancestorsResults) => {
const filterResults = {
passingFilterItems: null,
passingQuickFilterValues: null
};
let isPassingFiltering = false;
if (isRowMatchingFilters && node.type !== 'footer') {
const shouldApplyItem = node.type === 'group' && node.isAutoGenerated ? columnField => shouldApplyFilterItemOnGroup(columnField, node) : undefined;
const row = apiRef.current.getRow(node.id);
isRowMatchingFilters(row, shouldApplyItem, filterResults);
} else {
isPassingFiltering = true;
}
let filteredChildrenCount = 0;
let filteredDescendantCount = 0;
if (node.type === 'group') {
node.children.forEach(childId => {
const childNode = rowTree[childId];
const childSubTreeSize = filterTreeNode(childNode, areAncestorsExpanded && !!node.childrenExpanded, [...ancestorsResults, filterResults]);
filteredDescendantCount += childSubTreeSize;
if (childSubTreeSize > 0) {
filteredChildrenCount += 1;
}
});
}
if (isPassingFiltering === false) {
if (node.type === 'group') {
// If node has children - it's passing if at least one child passes filters
isPassingFiltering = filteredDescendantCount > 0;
} else {
const allResults = [...ancestorsResults, filterResults];
isPassingFiltering = (0, _internals.passFilterLogic)(allResults.map(result => result.passingFilterItems), allResults.map(result => result.passingQuickFilterValues), filterModel, filterValueGetter, params.apiRef, filterCache);
}
}
if (!isPassingFiltering) {
filteredRowsLookup[node.id] = false;
}
if (!isPassingFiltering) {
return 0;
}
filteredChildrenCountLookup[node.id] = filteredChildrenCount;
filteredDescendantCountLookup[node.id] = filteredDescendantCount;
if (node.type !== 'group') {
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, []);
}
}
return {
filteredRowsLookup,
filteredChildrenCountLookup,
filteredDescendantCountLookup
};
};
exports.filterRowTreeFromGroupingColumns = filterRowTreeFromGroupingColumns;
const getColDefOverrides = (groupingColDefProp, fields, strategy) => {
if (typeof groupingColDefProp === 'function') {
return groupingColDefProp({
groupingName: strategy ?? _internals.RowGroupingStrategy.Default,
fields
});
}
return groupingColDefProp;
};
exports.getColDefOverrides = getColDefOverrides;
const mergeStateWithRowGroupingModel = rowGroupingModel => state => (0, _extends2.default)({}, state, {
rowGrouping: (0, _extends2.default)({}, state.rowGrouping, {
model: rowGroupingModel
})
});
exports.mergeStateWithRowGroupingModel = mergeStateWithRowGroupingModel;
const setStrategyAvailability = (privateApiRef, disableRowGrouping, dataSource) => {
const strategy = dataSource ? _internals.RowGroupingStrategy.DataSource : _internals.RowGroupingStrategy.Default;
if (privateApiRef.current.getActiveStrategy(_internals.GridStrategyGroup.RowTree) === strategy) {
// If the strategy is already active, we don't need to set it again
return;
}
let isAvailable;
if (disableRowGrouping) {
isAvailable = () => false;
} else {
isAvailable = () => {
const rowGroupingSanitizedModel = (0, _gridRowGroupingSelector.gridRowGroupingSanitizedModelSelector)(privateApiRef);
return rowGroupingSanitizedModel.length > 0;
};
}
privateApiRef.current.setStrategyAvailability(_internals.GridStrategyGroup.RowTree, strategy, isAvailable);
};
exports.setStrategyAvailability = setStrategyAvailability;
const getCellGroupingCriteria = ({
row,
colDef,
groupingRule,
apiRef
}) => {
let key;
if (groupingRule.groupingValueGetter) {
key = groupingRule.groupingValueGetter(row[groupingRule.field], row, colDef, apiRef);
} else {
key = (0, _internals.getRowValue)(row, colDef, apiRef);
}
return {
key,
field: groupingRule.field
};
};
exports.getCellGroupingCriteria = getCellGroupingCriteria;
const getGroupingRules = ({
sanitizedRowGroupingModel,
columnsLookup
}) => sanitizedRowGroupingModel.map(field => ({
field,
groupingValueGetter: columnsLookup[field]?.groupingValueGetter,
groupingValueSetter: columnsLookup[field]?.groupingValueSetter
}));
/**
* Compares two sets of grouping rules to determine if they are equal or not.
*/
exports.getGroupingRules = getGroupingRules;
const areGroupingRulesEqual = (newValue, previousValue) => {
if (previousValue.length !== newValue.length) {
return false;
}
return newValue.every((newRule, newRuleIndex) => {
const previousRule = previousValue[newRuleIndex];
if (previousRule.groupingValueGetter !== newRule.groupingValueGetter) {
return false;
}
if (previousRule.groupingValueSetter !== newRule.groupingValueSetter) {
return false;
}
if (previousRule.field !== newRule.field) {
return false;
}
return true;
});
};
exports.areGroupingRulesEqual = areGroupingRulesEqual;