@mui/x-data-grid-premium 5.13.1 → 5.15.1

package/node/components/GridFooterCell.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GridFooterCell = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _xDataGrid = require("@mui/x-data-grid");
+
+var _styles = require("@mui/material/styles");
+
+var _Box = _interopRequireDefault(require("@mui/material/Box"));
+
+var _material = require("@mui/material");
+
+var _useGridRootProps = require("../hooks/utils/useGridRootProps");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+const _excluded = ["formattedValue", "colDef", "cellMode", "row", "api", "getValue", "id", "value", "rowNode", "field", "focusElementRef", "hasFocus", "tabIndex", "isEditable"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const GridFooterCellRoot = (0, _styles.styled)(_Box.default, {
+  name: 'MuiDataGrid',
+  slot: 'FooterCell',
+  overridesResolver: (_, styles) => styles.footerCell
+})(({
+  theme
+}) => ({
+  fontWeight: theme.typography.fontWeightMedium,
+  color: theme.palette.primary.dark
+}));
+
+const useUtilityClasses = ownerState => {
+  const {
+    classes
+  } = ownerState;
+  const slots = {
+    root: ['footerCell']
+  };
+  return (0, _material.unstable_composeClasses)(slots, _xDataGrid.getDataGridUtilityClass, classes);
+};
+
+const GridFooterCell = props => {
+  const {
+    formattedValue
+  } = props,
+        other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
+  const rootProps = (0, _useGridRootProps.useGridRootProps)();
+  const ownerState = {
+    classes: rootProps.classes
+  };
+  const classes = useUtilityClasses(ownerState);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(GridFooterCellRoot, (0, _extends2.default)({
+    ownerState: ownerState,
+    className: classes.root
+  }, other, {
+    children: formattedValue
+  }));
+};
+
+exports.GridFooterCell = GridFooterCell;

package/node/components/GridGroupingColumnFooterCell.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GridGroupingColumnFooterCell = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var React = _interopRequireWildcard(require("react"));
+
+var _useGridRootProps = require("../hooks/utils/useGridRootProps");
+
+var _GridFooterCell = require("./GridFooterCell");
+
+var _jsxRuntime = require("react/jsx-runtime");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const GridGroupingColumnFooterCell = props => {
+  const {
+    rowNode
+  } = props;
+  const rootProps = (0, _useGridRootProps.useGridRootProps)();
+  let marginLeft;
+
+  if (rowNode.parent == null) {
+    marginLeft = 0;
+  } else if (rootProps.rowGroupingColumnMode === 'multiple') {
+    marginLeft = 2;
+  } else {
+    marginLeft = rowNode.depth * 2;
+  }
+
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_GridFooterCell.GridFooterCell, (0, _extends2.default)({
+    sx: {
+      ml: marginLeft
+    }
+  }, props));
+};
+
+exports.GridGroupingColumnFooterCell = GridGroupingColumnFooterCell;

package/node/hooks/features/aggregation/createAggregationLookup.js

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAggregationLookup = void 0;
+
+var _xDataGridPro = require("@mui/x-data-grid-pro");
+
+var _gridAggregationUtils = require("./gridAggregationUtils");
+
+var _gridAggregationSelectors = require("./gridAggregationSelectors");
+
+const getAggregationCellValue = ({
+  apiRef,
+  groupId,
+  field,
+  aggregationFunction,
+  aggregationRowsScope
+}) => {
+  const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
+  const filteredRowsLookup = (0, _xDataGridPro.gridFilteredRowsLookupSelector)(apiRef);
+  let rowIds; // TODO: Add custom root id
+
+  if (groupId === '') {
+    rowIds = (0, _xDataGridPro.gridRowIdsSelector)(apiRef).filter(rowId => !rowTree[rowId].isAutoGenerated);
+  } else {
+    rowIds = apiRef.current.getRowGroupChildren({
+      groupId
+    });
+  }
+
+  const values = [];
+  rowIds.forEach(rowId => {
+    if (aggregationRowsScope === 'filtered' && filteredRowsLookup[rowId] === false) {
+      return;
+    }
+
+    values.push(apiRef.current.getCellValue(rowId, field));
+  });
+  return aggregationFunction.apply({
+    values
+  });
+};
+
+const getGroupAggregatedValue = ({
+  groupId,
+  apiRef,
+  aggregationRowsScope,
+  aggregatedFields,
+  aggregationRules,
+  position
+}) => {
+  const groupAggregationLookup = {};
+
+  for (let j = 0; j < aggregatedFields.length; j += 1) {
+    const aggregatedField = aggregatedFields[j];
+    const columnAggregationRules = aggregationRules[aggregatedField];
+    groupAggregationLookup[aggregatedField] = {
+      position,
+      value: getAggregationCellValue({
+        apiRef,
+        groupId,
+        field: aggregatedField,
+        aggregationFunction: columnAggregationRules.aggregationFunction,
+        aggregationRowsScope
+      })
+    };
+  }
+
+  return groupAggregationLookup;
+};
+
+const createAggregationLookup = ({
+  apiRef,
+  aggregationFunctions,
+  aggregationRowsScope,
+  getAggregationPosition
+}) => {
+  const aggregationRules = (0, _gridAggregationUtils.getAggregationRules)({
+    columnsLookup: (0, _xDataGridPro.gridColumnLookupSelector)(apiRef),
+    aggregationModel: (0, _gridAggregationSelectors.gridAggregationModelSelector)(apiRef),
+    aggregationFunctions
+  });
+  const aggregatedFields = Object.keys(aggregationRules);
+
+  if (aggregatedFields.length === 0) {
+    return {};
+  }
+
+  const aggregationLookup = {};
+  const rowIds = (0, _xDataGridPro.gridRowIdsSelector)(apiRef);
+  const rowTree = (0, _xDataGridPro.gridRowTreeSelector)(apiRef);
+
+  for (let i = 0; i < rowIds.length; i += 1) {
+    var _node$children;
+
+    const rowId = rowIds[i];
+    const node = rowTree[rowId];
+    const hasChildren = (_node$children = node.children) == null ? void 0 : _node$children.some(childId => {
+      var _rowTree$childId$posi;
+
+      return ((_rowTree$childId$posi = rowTree[childId].position) != null ? _rowTree$childId$posi : 'body') === 'body';
+    });
+
+    if (hasChildren) {
+      const position = getAggregationPosition(node);
+
+      if (position != null) {
+        aggregationLookup[rowId] = getGroupAggregatedValue({
+          groupId: rowId,
+          apiRef,
+          aggregatedFields,
+          aggregationRowsScope,
+          aggregationRules,
+          position
+        });
+      }
+    }
+  } // TODO: Add custom root id
+
+
+  const position = getAggregationPosition(null);
+
+  if (position != null) {
+    aggregationLookup[''] = getGroupAggregatedValue({
+      groupId: '',
+      apiRef,
+      aggregatedFields,
+      aggregationRowsScope,
+      aggregationRules,
+      position
+    });
+  }
+
+  return aggregationLookup;
+};
+
+exports.createAggregationLookup = createAggregationLookup;

package/node/hooks/features/aggregation/gridAggregationFunctions.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GRID_AGGREGATION_FUNCTIONS = void 0;
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+const sumAgg = {
+  apply: ({
+    values
+  }) => {
+    let sum = 0;
+
+    for (let i = 0; i < values.length; i += 1) {
+      const value = values[i];
+
+      if (value != null) {
+        sum += value;
+      }
+    }
+
+    return sum;
+  },
+  columnTypes: ['number']
+};
+const avgAgg = {
+  apply: params => {
+    if (params.values.length === 0) {
+      return null;
+    }
+
+    const sum = sumAgg.apply(params);
+    return sum / params.values.length;
+  },
+  columnTypes: ['number']
+};
+const minAgg = {
+  apply: ({
+    values
+  }) => {
+    if (values.length === 0) {
+      return null;
+    }
+
+    let min = +Infinity;
+
+    for (let i = 0; i < values.length; i += 1) {
+      const value = values[i];
+
+      if (value != null && value < min) {
+        min = value;
+      }
+    }
+
+    return min;
+  },
+  columnTypes: ['number', 'date', 'dateTime']
+};
+const maxAgg = {
+  apply: ({
+    values
+  }) => {
+    if (values.length === 0) {
+      return null;
+    }
+
+    let max = -Infinity;
+
+    for (let i = 0; i < values.length; i += 1) {
+      const value = values[i];
+
+      if (value != null && value > max) {
+        max = value;
+      }
+    }
+
+    return max;
+  },
+  columnTypes: ['number', 'date', 'dateTime']
+};
+const sizeAgg = {
+  apply: ({
+    values
+  }) => {
+    return values.length;
+  },
+  valueFormatter: params => {
+    if (params.value == null || !(0, _internals.isNumber)(params.value)) {
+      return params.value;
+    }
+
+    return params.value.toLocaleString();
+  },
+  hasCellUnit: false
+};
+const GRID_AGGREGATION_FUNCTIONS = {
+  sum: sumAgg,
+  avg: avgAgg,
+  min: minAgg,
+  max: maxAgg,
+  size: sizeAgg
+};
+exports.GRID_AGGREGATION_FUNCTIONS = GRID_AGGREGATION_FUNCTIONS;

package/node/hooks/features/aggregation/gridAggregationInterfaces.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/node/hooks/features/aggregation/gridAggregationSelectors.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gridAggregationStateSelector = exports.gridAggregationModelSelector = exports.gridAggregationLookupSelector = void 0;
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+const gridAggregationStateSelector = state => state.aggregation;
+
+exports.gridAggregationStateSelector = gridAggregationStateSelector;
+const gridAggregationModelSelector = (0, _internals.createSelector)(gridAggregationStateSelector, aggregationState => aggregationState.model);
+exports.gridAggregationModelSelector = gridAggregationModelSelector;
+const gridAggregationLookupSelector = (0, _internals.createSelector)(gridAggregationStateSelector, aggregationState => aggregationState.lookup);
+exports.gridAggregationLookupSelector = gridAggregationLookupSelector;

package/node/hooks/features/aggregation/gridAggregationUtils.js

@@ -0,0 +1,223 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeStateWithAggregationModel = exports.hasAggregationRulesChanged = exports.getAvailableAggregationFunctions = exports.getAggregationRules = exports.getAggregationFunctionLabel = exports.getAggregationFooterRowIdFromGroupId = exports.canColumnHaveAggregationFunction = exports.addFooterRows = exports.GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _material = require("@mui/material");
+
+var _internals = require("@mui/x-data-grid-pro/internals");
+
+const GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = 'auto-generated-group-footer-root';
+exports.GRID_AGGREGATION_ROOT_FOOTER_ROW_ID = GRID_AGGREGATION_ROOT_FOOTER_ROW_ID;
+
+const getAggregationFooterRowIdFromGroupId = groupId => {
+  if (groupId == null) {
+    return GRID_AGGREGATION_ROOT_FOOTER_ROW_ID;
+  }
+
+  return `auto-generated-group-footer-${groupId}`;
+};
+
+exports.getAggregationFooterRowIdFromGroupId = getAggregationFooterRowIdFromGroupId;
+
+const canColumnHaveAggregationFunction = ({
+  column,
+  aggregationFunctionName,
+  aggregationFunction
+}) => {
+  if (!column || !column.aggregable) {
+    return false;
+  }
+
+  if (!aggregationFunction) {
+    return false;
+  }
+
+  if (column.availableAggregationFunctions != null) {
+    return column.availableAggregationFunctions.includes(aggregationFunctionName);
+  }
+
+  if (!aggregationFunction.columnTypes) {
+    return true;
+  }
+
+  return aggregationFunction.columnTypes.includes(column.type);
+};
+
+exports.canColumnHaveAggregationFunction = canColumnHaveAggregationFunction;
+
+const getAvailableAggregationFunctions = ({
+  aggregationFunctions,
+  column
+}) => Object.keys(aggregationFunctions).filter(aggregationFunctionName => canColumnHaveAggregationFunction({
+  column,
+  aggregationFunctionName,
+  aggregationFunction: aggregationFunctions[aggregationFunctionName]
+}));
+
+exports.getAvailableAggregationFunctions = getAvailableAggregationFunctions;
+
+const mergeStateWithAggregationModel = aggregationModel => state => (0, _extends2.default)({}, state, {
+  aggregation: (0, _extends2.default)({}, state.aggregation, {
+    model: aggregationModel
+  })
+});
+
+exports.mergeStateWithAggregationModel = mergeStateWithAggregationModel;
+
+const getAggregationRules = ({
+  columnsLookup,
+  aggregationModel,
+  aggregationFunctions
+}) => {
+  const aggregationRules = {};
+  Object.entries(aggregationModel).forEach(([field, columnItem]) => {
+    if (columnsLookup[field] && canColumnHaveAggregationFunction({
+      column: columnsLookup[field],
+      aggregationFunctionName: columnItem,
+      aggregationFunction: aggregationFunctions[columnItem]
+    })) {
+      aggregationRules[field] = {
+        aggregationFunctionName: columnItem,
+        aggregationFunction: aggregationFunctions[columnItem]
+      };
+    }
+  });
+  return aggregationRules;
+};
+/**
+ * Add a footer for each group that has at least one column with an aggregated value.
+ */
+
+
+exports.getAggregationRules = getAggregationRules;
+
+const addFooterRows = ({
+  groupingParams,
+  aggregationRules,
+  getAggregationPosition,
+  apiRef
+}) => {
+  if (Object.keys(aggregationRules).length === 0) {
+    return groupingParams;
+  }
+
+  const ids = [...groupingParams.ids];
+  const idRowsLookup = (0, _extends2.default)({}, groupingParams.idRowsLookup);
+  const tree = (0, _extends2.default)({}, groupingParams.tree);
+
+  const addGroupFooter = groupNode => {
+    var _groupNode$id;
+
+    const groupId = (_groupNode$id = groupNode == null ? void 0 : groupNode.id) != null ? _groupNode$id : null;
+
+    if (getAggregationPosition(groupNode) !== 'footer') {
+      return;
+    }
+
+    const footerId = getAggregationFooterRowIdFromGroupId(groupId);
+    ids.push(footerId);
+    idRowsLookup[footerId] = {};
+    tree[footerId] = {
+      id: footerId,
+      isAutoGenerated: true,
+      parent: groupId,
+      depth: groupNode ? groupNode.depth + 1 : 0,
+      groupingKey: null,
+      groupingField: null,
+      position: 'footer'
+    };
+
+    if (groupId != null) {
+      tree[groupId] = (0, _extends2.default)({}, tree[groupId], {
+        footerId
+      });
+    }
+  }; // If the tree is flat, we don't need to loop through the rows
+
+
+  if (groupingParams.treeDepth > 1) {
+    groupingParams.ids.forEach(parentId => {
+      const parentNode = tree[parentId];
+
+      if (parentNode.depth === groupingParams.treeDepth - 1) {
+        return;
+      }
+
+      addGroupFooter(parentNode);
+    });
+  }
+
+  let newGroupingParams = (0, _extends2.default)({}, groupingParams, {
+    tree,
+    idRowsLookup,
+    ids
+  });
+
+  if (getAggregationPosition(null) === 'footer') {
+    newGroupingParams = (0, _internals.addPinnedRow)({
+      groupingParams: newGroupingParams,
+      rowModel: {},
+      rowId: getAggregationFooterRowIdFromGroupId(null),
+      position: 'bottom',
+      apiRef
+    });
+  }
+
+  return (0, _extends2.default)({}, groupingParams, newGroupingParams);
+};
+/**
+ * Compares two sets of aggregation rules to determine if they are equal or not.
+ */
+
+
+exports.addFooterRows = addFooterRows;
+
+const hasAggregationRulesChanged = (previousValue, newValue) => {
+  const previousFields = Object.keys(previousValue != null ? previousValue : {});
+  const newFields = Object.keys(newValue);
+
+  if (!(0, _internals.isDeepEqual)(previousFields, newFields)) {
+    return true;
+  }
+
+  return newFields.some(field => {
+    const previousRule = previousValue == null ? void 0 : previousValue[field];
+    const newRule = newValue[field];
+
+    if ((previousRule == null ? void 0 : previousRule.aggregationFunction) !== (newRule == null ? void 0 : newRule.aggregationFunction)) {
+      return true;
+    }
+
+    if ((previousRule == null ? void 0 : previousRule.aggregationFunctionName) !== (newRule == null ? void 0 : newRule.aggregationFunctionName)) {
+      return true;
+    }
+
+    return false;
+  });
+};
+
+exports.hasAggregationRulesChanged = hasAggregationRulesChanged;
+
+const getAggregationFunctionLabel = ({
+  apiRef,
+  aggregationRule
+}) => {
+  if (aggregationRule.aggregationFunction.label != null) {
+    return aggregationRule.aggregationFunction.label;
+  }
+
+  try {
+    return apiRef.current.getLocaleText(`aggregationFunctionLabel${(0, _material.capitalize)(aggregationRule.aggregationFunctionName)}`);
+  } catch (e) {
+    return aggregationRule.aggregationFunctionName;
+  }
+};
+
+exports.getAggregationFunctionLabel = getAggregationFunctionLabel;

package/node/hooks/features/aggregation/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  GRID_AGGREGATION_ROOT_FOOTER_ROW_ID: true,
+  getAggregationFooterRowIdFromGroupId: true
+};
+Object.defineProperty(exports, "GRID_AGGREGATION_ROOT_FOOTER_ROW_ID", {
+  enumerable: true,
+  get: function () {
+    return _gridAggregationUtils.GRID_AGGREGATION_ROOT_FOOTER_ROW_ID;
+  }
+});
+Object.defineProperty(exports, "getAggregationFooterRowIdFromGroupId", {
+  enumerable: true,
+  get: function () {
+    return _gridAggregationUtils.getAggregationFooterRowIdFromGroupId;
+  }
+});
+
+var _gridAggregationInterfaces = require("./gridAggregationInterfaces");
+
+Object.keys(_gridAggregationInterfaces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridAggregationInterfaces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridAggregationInterfaces[key];
+    }
+  });
+});
+
+var _gridAggregationSelectors = require("./gridAggregationSelectors");
+
+Object.keys(_gridAggregationSelectors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridAggregationSelectors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridAggregationSelectors[key];
+    }
+  });
+});
+
+var _gridAggregationFunctions = require("./gridAggregationFunctions");
+
+Object.keys(_gridAggregationFunctions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _gridAggregationFunctions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _gridAggregationFunctions[key];
+    }
+  });
+});
+
+var _gridAggregationUtils = require("./gridAggregationUtils");