@mui/x-data-grid-premium
Version:
The Premium plan edition of the MUI X Data Grid Components.
270 lines (269 loc) • 10.4 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.isPivotingAvailable = exports.getPivotedData = exports.getInitialColumns = exports.defaultGetPivotDerivedColumns = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _xDataGridPro = require("@mui/x-data-grid-pro");
var _internals = require("@mui/x-data-grid-pro/internals");
var _rowGrouping = require("../rowGrouping");
const columnGroupIdSeparator = '>->';
const isPivotingAvailable = props => {
return !props.disablePivoting;
};
exports.isPivotingAvailable = isPivotingAvailable;
const defaultGetPivotDerivedColumns = (column, getLocaleText) => {
if (column.type === 'date') {
const field = column.field;
return [{
// String column type to avoid formatting the value as 2,025 instead of 2025
field: `${field}-year`,
headerName: `${column.headerName} ${getLocaleText('pivotYearColumnHeaderName')}`,
valueGetter: (value, row) => new Date(row[field]).getFullYear()
}, {
field: `${field}-quarter`,
headerName: `${column.headerName} ${getLocaleText('pivotQuarterColumnHeaderName')}`,
valueGetter: (value, row) => `Q${Math.floor(new Date(row[field]).getMonth() / 3) + 1}`
}];
}
return undefined;
};
exports.defaultGetPivotDerivedColumns = defaultGetPivotDerivedColumns;
const getInitialColumns = (originalColumns, getPivotDerivedColumns, getLocaleText) => {
const initialColumns = new Map();
for (let i = 0; i < originalColumns.length; i += 1) {
const originalColumn = originalColumns[i];
const column = (0, _extends2.default)({}, (0, _internals.getDefaultColTypeDef)(originalColumn.type), originalColumn);
const field = column.field;
if (!(0, _rowGrouping.isGroupingColumn)(field)) {
initialColumns.set(field, column);
const derivedColumns = getPivotDerivedColumns?.(column, getLocaleText);
if (derivedColumns) {
derivedColumns.forEach(col => initialColumns.set(col.field, col));
}
}
}
return initialColumns;
};
exports.getInitialColumns = getInitialColumns;
function sortColumnGroups(columnGroups, pivotModelColumns, depth = 0) {
if (depth > pivotModelColumns.length - 1) {
return;
}
const sort = pivotModelColumns[depth].sort;
columnGroups.sort((a, b) => {
if ((0, _xDataGridPro.isLeaf)(a) || (0, _xDataGridPro.isLeaf)(b)) {
return 0;
}
if (a.children) {
sortColumnGroups(a.children, pivotModelColumns, depth + 1);
}
if (b.children) {
sortColumnGroups(b.children, pivotModelColumns, depth + 1);
}
if (sort === undefined) {
return 0;
}
return (sort === 'asc' ? 1 : -1) * (0, _xDataGridPro.gridStringOrNumberComparator)(a.headerName, b.headerName, {}, {});
});
}
const getPivotedData = ({
rows,
columns,
pivotModel,
apiRef,
pivotingColDef
}) => {
const visibleColumns = pivotModel.columns.filter(column => !column.hidden);
const visibleRows = pivotModel.rows.filter(row => !row.hidden);
const visibleValues = pivotModel.values.filter(value => !value.hidden);
let pivotColumns = [];
const columnVisibilityModel = {};
const pivotColumnsIncludedInPivotValues = [];
const initialColumns = new Map();
for (const column of columns.values()) {
if (!(0, _rowGrouping.isGroupingColumn)(column.field)) {
initialColumns.set(column.field, column);
const pivotValueIndex = visibleValues.findIndex(({
field
}) => field === column.field);
const isVisiblePivotValueField = pivotValueIndex !== -1;
const columnToAdd = (0, _extends2.default)({}, column, {
aggregable: false,
groupable: false,
hideable: false,
editable: false,
disableReorder: true
});
if (isVisiblePivotValueField) {
// Store columns that are used as pivot values in a temporary array to keep them in the same order as in pivotModel.values, not in the order of the initial columns.
// `pivotColumnsIncludedInPivotValues` is concatenated to pivotColumns later.
pivotColumnsIncludedInPivotValues[pivotValueIndex] = columnToAdd;
} else {
pivotColumns.push(columnToAdd);
}
columnVisibilityModel[column.field] = false;
}
}
pivotColumns = pivotColumns.concat(pivotColumnsIncludedInPivotValues);
const getAttributesFromInitialColumn = field => {
const initialColumn = initialColumns.get(field);
if (!initialColumn) {
return undefined;
}
const attributes = {
width: initialColumn.width,
minWidth: initialColumn.minWidth,
maxWidth: initialColumn.maxWidth,
valueFormatter: initialColumn.valueFormatter,
headerName: initialColumn.headerName,
renderCell: initialColumn.renderCell,
display: initialColumn.display
};
return attributes;
};
const aggregationModel = {};
const columnGroupingModel = [];
const columnGroupingModelLookup = new Map();
let newRows = [];
if (visibleColumns.length === 0) {
newRows = rows;
visibleValues.forEach(pivotValue => {
aggregationModel[pivotValue.field] = pivotValue.aggFunc;
delete columnVisibilityModel[pivotValue.field];
});
} else {
for (let i = 0; i < rows.length; i += 1) {
const row = rows[i];
const newRow = (0, _extends2.default)({}, row);
const columnGroupPath = [];
visibleColumns.forEach(({
field: colGroupField
}, depth) => {
const column = initialColumns.get(colGroupField);
if (!column) {
return;
}
let colValue = apiRef.current.getRowValue(row, column) ?? '(No value)';
if (column.type === 'singleSelect') {
const singleSelectColumn = column;
if (singleSelectColumn.getOptionLabel) {
colValue = singleSelectColumn.getOptionLabel(colValue);
}
}
columnGroupPath.push(String(colValue));
const groupId = columnGroupPath.join(columnGroupIdSeparator);
if (!columnGroupingModelLookup.has(groupId)) {
const columnGroup = {
groupId,
headerName: String(colValue),
children: []
};
columnGroupingModelLookup.set(groupId, columnGroup);
if (depth === 0) {
columnGroupingModel.push(columnGroup);
} else {
const parentGroupId = columnGroupPath.slice(0, -1).join(columnGroupIdSeparator);
const parentGroup = columnGroupingModelLookup.get(parentGroupId);
if (parentGroup) {
parentGroup.children.push(columnGroup);
}
}
}
const isLastColumnGroupLevel = depth === visibleColumns.length - 1;
if (isLastColumnGroupLevel) {
visibleValues.forEach(pivotValue => {
const valueField = pivotValue.field;
const originalColumn = initialColumns.get(valueField);
if (!originalColumn) {
return;
}
const valueKey = `${columnGroupPath.join(columnGroupIdSeparator)}${columnGroupIdSeparator}${valueField}`;
newRow[valueKey] = apiRef.current.getRowValue(row, originalColumn);
});
}
});
newRows.push(newRow);
}
sortColumnGroups(columnGroupingModel, visibleColumns);
}
function createColumns(columnGroups, depth = 0) {
for (let i = 0; i < columnGroups.length; i += 1) {
const columnGroup = columnGroups[i];
if ((0, _xDataGridPro.isLeaf)(columnGroup)) {
continue;
}
const isLastColumnGroupLevel = depth === visibleColumns.length - 1;
if (isLastColumnGroupLevel) {
if (visibleValues.length === 0) {
// If there are no visible values, there are no actual columns added to the data grid, which leads to column groups not being visible.
// Adding an empty column to each column group ensures that the column groups are visible.
const emptyColumnField = `${columnGroup.groupId}${columnGroupIdSeparator}empty`;
const emptyColumn = {
field: emptyColumnField,
headerName: '',
sortable: false,
filterable: false,
groupable: false,
aggregable: false,
hideable: false,
disableColumnMenu: true
};
pivotColumns.push(emptyColumn);
if (columnGroup) {
columnGroup.children.push({
field: emptyColumnField
});
}
} else {
visibleValues.forEach(pivotValue => {
const valueField = pivotValue.field;
const mapValueKey = `${columnGroup.groupId}${columnGroupIdSeparator}${valueField}`;
const overrides = typeof pivotingColDef === 'function' ? pivotingColDef(valueField, columnGroup.groupId.split(columnGroupIdSeparator)) : pivotingColDef;
const column = (0, _extends2.default)({
headerName: String(valueField)
}, getAttributesFromInitialColumn(pivotValue.field), overrides, {
field: mapValueKey,
aggregable: false,
groupable: false,
filterable: false,
hideable: false,
editable: false,
disableReorder: true,
availableAggregationFunctions: [pivotValue.aggFunc]
});
pivotColumns.push(column);
aggregationModel[mapValueKey] = pivotValue.aggFunc;
if (columnGroup) {
columnGroup.children.push({
field: mapValueKey
});
}
});
}
} else {
createColumns(columnGroup.children, depth + 1);
}
}
}
createColumns(columnGroupingModel);
return {
rows: visibleRows.length > 0 ? newRows : [],
columns: pivotColumns,
rowGroupingModel: visibleRows.map(row => row.field),
aggregationModel,
getAggregationPosition: groupNode => groupNode.depth === -1 ? 'footer' : 'inline',
columnVisibilityModel,
columnGroupingModel,
groupingColDef: {
filterable: false,
aggregable: false,
hideable: false
},
headerFilters: false,
disableAggregation: false,
disableRowGrouping: false
};
};
exports.getPivotedData = getPivotedData;