@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/row-grouping/rowGrouping/aggFuncService.js

@@ -0,0 +1,303 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
+    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+var AggFuncService_1;
+import { Bean, BeanStub, PostConstruct, _ } from '@ag-grid-community/core'; // @ts-ignore
+
+var AGBigInt = typeof BigInt === 'undefined' ? null : BigInt;
+
+var AggFuncService = AggFuncService_1 = /*#__PURE__*/function (_BeanStub) {
+  _inherits(AggFuncService, _BeanStub);
+
+  var _super = _createSuper(AggFuncService);
+
+  function AggFuncService() {
+    var _this;
+
+    _classCallCheck(this, AggFuncService);
+
+    _this = _super.apply(this, arguments);
+    _this.aggFuncsMap = {};
+    _this.initialised = false;
+    return _this;
+  }
+
+  _createClass(AggFuncService, [{
+    key: "init",
+    value: function init() {
+      if (this.initialised) {
+        return;
+      }
+
+      this.initialiseWithDefaultAggregations();
+      this.addAggFuncs(this.gridOptionsWrapper.getAggFuncs());
+    }
+  }, {
+    key: "initialiseWithDefaultAggregations",
+    value: function initialiseWithDefaultAggregations() {
+      this.aggFuncsMap[AggFuncService_1.AGG_SUM] = aggSum;
+      this.aggFuncsMap[AggFuncService_1.AGG_FIRST] = aggFirst;
+      this.aggFuncsMap[AggFuncService_1.AGG_LAST] = aggLast;
+      this.aggFuncsMap[AggFuncService_1.AGG_MIN] = aggMin;
+      this.aggFuncsMap[AggFuncService_1.AGG_MAX] = aggMax;
+      this.aggFuncsMap[AggFuncService_1.AGG_COUNT] = aggCount;
+      this.aggFuncsMap[AggFuncService_1.AGG_AVG] = aggAvg;
+      this.initialised = true;
+    }
+  }, {
+    key: "isAggFuncPossible",
+    value: function isAggFuncPossible(column, func) {
+      var allKeys = this.getFuncNames(column);
+
+      var allowed = _.includes(allKeys, func);
+
+      var funcExists = _.exists(this.aggFuncsMap[func]);
+
+      return allowed && funcExists;
+    }
+  }, {
+    key: "getDefaultAggFunc",
+    value: function getDefaultAggFunc(column) {
+      var defaultAgg = column.getColDef().defaultAggFunc;
+
+      if (_.exists(defaultAgg) && this.isAggFuncPossible(column, defaultAgg)) {
+        return defaultAgg;
+      }
+
+      if (this.isAggFuncPossible(column, AggFuncService_1.AGG_SUM)) {
+        return AggFuncService_1.AGG_SUM;
+      }
+
+      var allKeys = this.getFuncNames(column);
+      return _.existsAndNotEmpty(allKeys) ? allKeys[0] : null;
+    }
+  }, {
+    key: "addAggFuncs",
+    value: function addAggFuncs(aggFuncs) {
+      _.iterateObject(aggFuncs, this.addAggFunc.bind(this));
+    }
+  }, {
+    key: "addAggFunc",
+    value: function addAggFunc(key, aggFunc) {
+      this.init();
+      this.aggFuncsMap[key] = aggFunc;
+    }
+  }, {
+    key: "getAggFunc",
+    value: function getAggFunc(name) {
+      this.init();
+      return this.aggFuncsMap[name];
+    }
+  }, {
+    key: "getFuncNames",
+    value: function getFuncNames(column) {
+      var userAllowedFuncs = column.getColDef().allowedAggFuncs;
+      return userAllowedFuncs == null ? Object.keys(this.aggFuncsMap).sort() : userAllowedFuncs;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.aggFuncsMap = {};
+    }
+  }]);
+
+  return AggFuncService;
+}(BeanStub);
+
+AggFuncService.AGG_SUM = 'sum';
+AggFuncService.AGG_FIRST = 'first';
+AggFuncService.AGG_LAST = 'last';
+AggFuncService.AGG_MIN = 'min';
+AggFuncService.AGG_MAX = 'max';
+AggFuncService.AGG_COUNT = 'count';
+AggFuncService.AGG_AVG = 'avg';
+
+__decorate([PostConstruct], AggFuncService.prototype, "init", null);
+
+AggFuncService = AggFuncService_1 = __decorate([Bean('aggFuncService')], AggFuncService);
+export { AggFuncService };
+
+function aggSum(params) {
+  var values = params.values;
+  var result = null; // the logic ensures that we never combine bigint arithmetic with numbers, but TS is hard to please
+  // for optimum performance, we use a for loop here rather than calling any helper methods or using functional code
+
+  for (var i = 0; i < values.length; i++) {
+    var value = values[i];
+
+    if (typeof value === 'number') {
+      if (result === null) {
+        result = value;
+      } else {
+        if (AGBigInt) {
+          result += typeof result === 'number' ? value : AGBigInt(value);
+        } else {
+          result += value;
+        }
+      }
+    } else if (typeof value === 'bigint') {
+      if (result === null) {
+        result = value;
+      } else {
+        result = (typeof result === 'bigint' ? result : AGBigInt(result)) + value;
+      }
+    }
+  }
+
+  return result;
+}
+
+function aggFirst(params) {
+  return params.values.length > 0 ? params.values[0] : null;
+}
+
+function aggLast(params) {
+  return params.values.length > 0 ? _.last(params.values) : null;
+}
+
+function aggMin(params) {
+  var values = params.values;
+  var result = null; // for optimum performance, we use a for loop here rather than calling any helper methods or using functional code
+
+  for (var i = 0; i < values.length; i++) {
+    var value = values[i];
+
+    if ((typeof value === 'number' || typeof value === 'bigint') && (result === null || result > value)) {
+      result = value;
+    }
+  }
+
+  return result;
+}
+
+function aggMax(params) {
+  var values = params.values;
+  var result = null; // for optimum performance, we use a for loop here rather than calling any helper methods or using functional code
+
+  for (var i = 0; i < values.length; i++) {
+    var value = values[i];
+
+    if ((typeof value === 'number' || typeof value === 'bigint') && (result === null || result < value)) {
+      result = value;
+    }
+  }
+
+  return result;
+}
+
+function aggCount(params) {
+  var values = params.values;
+  var result = 0; // for optimum performance, we use a for loop here rather than calling any helper methods or using functional code
+
+  for (var i = 0; i < values.length; i++) {
+    var value = values[i]; // check if the value is from a group, in which case use the group's count
+
+    result += value != null && typeof value.value === 'number' ? value.value : 1;
+  }
+
+  return result;
+} // the average function is tricky as the multiple levels require weighted averages
+// for the non-leaf node aggregations.
+
+
+function aggAvg(params) {
+  var _a, _b, _c;
+
+  var values = params.values;
+  var sum = 0; // the logic ensures that we never combine bigint arithmetic with numbers, but TS is hard to please
+
+  var count = 0; // for optimum performance, we use a for loop here rather than calling any helper methods or using functional code
+
+  for (var i = 0; i < values.length; i++) {
+    var currentValue = values[i];
+    var valueToAdd = null;
+
+    if (typeof currentValue === 'number' || typeof currentValue === 'bigint') {
+      valueToAdd = currentValue;
+      count++;
+    } else if (currentValue != null && (typeof currentValue.value === 'number' || typeof currentValue.value === 'bigint') && typeof currentValue.count === 'number') {
+      // we are aggregating groups, so we take the aggregated values to calculated a weighted average
+      if (AGBigInt) {
+        valueToAdd = currentValue.value * (typeof currentValue.value === 'number' ? currentValue.count : AGBigInt(currentValue.count));
+      } else {
+        valueToAdd = currentValue.value * currentValue.count;
+      }
+
+      count += currentValue.count;
+    }
+
+    if (typeof valueToAdd === 'number') {
+      if (AGBigInt) {
+        sum += typeof sum === 'number' ? valueToAdd : AGBigInt(valueToAdd);
+      } else {
+        sum += valueToAdd;
+      }
+    } else if (typeof valueToAdd === 'bigint') {
+      sum = (typeof sum === 'bigint' ? sum : AGBigInt(sum)) + valueToAdd;
+    }
+  }
+
+  var value = null; // avoid divide by zero error
+
+  if (count > 0) {
+    if (AGBigInt) {
+      value = sum / (typeof sum === 'number' ? count : AGBigInt(count));
+    } else {
+      value = sum / count;
+    }
+  } // the previous aggregation data
+
+
+  var existingAggData = (_b = (_a = params.rowNode) === null || _a === void 0 ? void 0 : _a.aggData) === null || _b === void 0 ? void 0 : _b[(_c = params.column) === null || _c === void 0 ? void 0 : _c.getColId()];
+
+  if (existingAggData && existingAggData.count === count && existingAggData.value === value) {
+    // the underlying values haven't changed, return the old object to avoid triggering change detection
+    return existingAggData;
+  } // the result will be an object. when this cell is rendered, only the avg is shown.
+  // however when this cell is part of another aggregation, the count is also needed
+  // to create a weighted average for the next level.
+
+
+  return {
+    count: count,
+    value: value,
+    // the grid by default uses toString to render values for an object, so this
+    // is a trick to get the default cellRenderer to display the avg value
+    toString: function toString() {
+      return typeof this.value === 'number' || typeof this.value === 'bigint' ? this.value.toString() : '';
+    },
+    // used for sorting
+    toNumber: function toNumber() {
+      return this.value;
+    }
+  };
+}

package/es/components/DataGrid/modules/row-grouping/rowGrouping/aggregationStage.d.ts

@@ -0,0 +1,20 @@
+import { BeanStub, IRowNodeStage, RowNode, Column, StageExecuteParams, IAggFunc } from "@ag-grid-community/core";
+export declare class AggregationStage extends BeanStub implements IRowNodeStage {
+    private columnModel;
+    private valueService;
+    private pivotStage;
+    private aggFuncService;
+    private gridApi;
+    private columnApi;
+    private filteredOnly;
+    execute(params: StageExecuteParams): any;
+    private createAggDetails;
+    private recursivelyCreateAggData;
+    private aggregateRowNode;
+    private aggregateRowNodeUsingValuesAndPivot;
+    private aggregateRowNodeUsingValuesOnly;
+    private getValuesPivotNonLeaf;
+    private getValuesFromMappedSet;
+    private getValuesNormal;
+    aggregateValues(values: any[], aggFuncOrString: string | IAggFunc, column?: Column, rowNode?: RowNode): any;
+}

package/es/components/DataGrid/modules/row-grouping/rowGrouping/aggregationStage.js

@@ -0,0 +1,326 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
+    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+import { Bean, BeanStub, Autowired, _ } from "@ag-grid-community/core";
+
+var AggregationStage = /*#__PURE__*/function (_BeanStub) {
+  _inherits(AggregationStage, _BeanStub);
+
+  var _super = _createSuper(AggregationStage);
+
+  function AggregationStage() {
+    _classCallCheck(this, AggregationStage);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(AggregationStage, [{
+    key: "execute",
+    value: // it's possible to recompute the aggregate without doing the other parts
+    // + gridApi.recomputeAggregates()
+    function execute(params) {
+      // if changed path is active, it means we came from a) change detection or b) transaction update.
+      // for both of these, if no value columns are present, it means there is nothing to aggregate now
+      // and there is no cleanup to be done (as value columns don't change between transactions or change
+      // detections). if no value columns and no changed path, means we have to go through all nodes in
+      // case we need to clean up agg data from before.
+      var noValueColumns = _.missingOrEmpty(this.columnModel.getValueColumns());
+
+      var noUserAgg = !this.gridOptionsWrapper.getGroupRowAggFunc();
+      var changedPathActive = params.changedPath && params.changedPath.isActive();
+
+      if (noValueColumns && noUserAgg && changedPathActive) {
+        return;
+      }
+
+      var aggDetails = this.createAggDetails(params);
+      this.recursivelyCreateAggData(aggDetails);
+    }
+  }, {
+    key: "createAggDetails",
+    value: function createAggDetails(params) {
+      var pivotActive = this.columnModel.isPivotActive();
+      var measureColumns = this.columnModel.getValueColumns();
+      var pivotColumns = pivotActive ? this.columnModel.getPivotColumns() : [];
+      var aggDetails = {
+        changedPath: params.changedPath,
+        valueColumns: measureColumns,
+        pivotColumns: pivotColumns
+      };
+      return aggDetails;
+    }
+  }, {
+    key: "recursivelyCreateAggData",
+    value: function recursivelyCreateAggData(aggDetails) {
+      var _this = this;
+
+      // update prop, in case changed since last time
+      this.filteredOnly = !this.gridOptionsWrapper.isSuppressAggFilteredOnly();
+
+      var callback = function callback(rowNode) {
+        var hasNoChildren = !rowNode.hasChildren();
+
+        if (hasNoChildren) {
+          // this check is needed for TreeData, in case the node is no longer a child,
+          // but it was a child previously.
+          if (rowNode.aggData) {
+            rowNode.setAggData(null);
+          } // never agg data for leaf nodes
+
+
+          return;
+        } //Optionally prevent the aggregation at the root Node
+        //https://ag-grid.atlassian.net/browse/AG-388
+
+
+        var isRootNode = rowNode.level === -1;
+
+        if (isRootNode) {
+          var notPivoting = !_this.columnModel.isPivotMode();
+
+          var suppressAggAtRootLevel = _this.gridOptionsWrapper.isSuppressAggAtRootLevel();
+
+          if (suppressAggAtRootLevel && notPivoting) {
+            return;
+          }
+        }
+
+        _this.aggregateRowNode(rowNode, aggDetails);
+      };
+
+      aggDetails.changedPath.forEachChangedNodeDepthFirst(callback, true);
+    }
+  }, {
+    key: "aggregateRowNode",
+    value: function aggregateRowNode(rowNode, aggDetails) {
+      var measureColumnsMissing = aggDetails.valueColumns.length === 0;
+      var pivotColumnsMissing = aggDetails.pivotColumns.length === 0;
+      var userFunc = this.gridOptionsWrapper.getGroupRowAggFunc();
+      var aggResult;
+
+      if (userFunc) {
+        var params = {
+          nodes: rowNode.childrenAfterFilter
+        };
+        aggResult = userFunc(params);
+      } else if (measureColumnsMissing) {
+        aggResult = null;
+      } else if (pivotColumnsMissing) {
+        aggResult = this.aggregateRowNodeUsingValuesOnly(rowNode, aggDetails);
+      } else {
+        aggResult = this.aggregateRowNodeUsingValuesAndPivot(rowNode);
+      }
+
+      rowNode.setAggData(aggResult); // if we are grouping, then it's possible there is a sibling footer
+      // to the group, so update the data here also if there is one
+
+      if (rowNode.sibling) {
+        rowNode.sibling.setAggData(aggResult);
+      }
+    }
+  }, {
+    key: "aggregateRowNodeUsingValuesAndPivot",
+    value: function aggregateRowNodeUsingValuesAndPivot(rowNode) {
+      var _this2 = this;
+
+      var result = {};
+      var pivotColumnDefs = this.pivotStage.getPivotColumnDefs(); // Step 1: process value columns
+
+      pivotColumnDefs.filter(function (v) {
+        return !_.exists(v.pivotTotalColumnIds);
+      }) // only process pivot value columns
+      .forEach(function (valueColDef) {
+        var keys = valueColDef.pivotKeys || [];
+        var values;
+        var valueColumn = valueColDef.pivotValueColumn;
+        var colId = valueColDef.colId;
+
+        if (rowNode.leafGroup) {
+          // lowest level group, get the values from the mapped set
+          values = _this2.getValuesFromMappedSet(rowNode.childrenMapped, keys, valueColumn);
+        } else {
+          // value columns and pivot columns, non-leaf group
+          values = _this2.getValuesPivotNonLeaf(rowNode, colId);
+        }
+
+        result[colId] = _this2.aggregateValues(values, valueColumn.getAggFunc(), valueColumn, rowNode);
+      }); // Step 2: process total columns
+
+      pivotColumnDefs.filter(function (v) {
+        return _.exists(v.pivotTotalColumnIds);
+      }) // only process pivot total columns
+      .forEach(function (totalColDef) {
+        var aggResults = [];
+        var pivotValueColumn = totalColDef.pivotValueColumn,
+            pivotTotalColumnIds = totalColDef.pivotTotalColumnIds,
+            colId = totalColDef.colId; //retrieve results for colIds associated with this pivot total column
+
+        if (!pivotTotalColumnIds || !pivotTotalColumnIds.length) {
+          return;
+        }
+
+        pivotTotalColumnIds.forEach(function (currentColId) {
+          aggResults.push(result[currentColId]);
+        });
+        result[colId] = _this2.aggregateValues(aggResults, pivotValueColumn.getAggFunc(), pivotValueColumn, rowNode);
+      });
+      return result;
+    }
+  }, {
+    key: "aggregateRowNodeUsingValuesOnly",
+    value: function aggregateRowNodeUsingValuesOnly(rowNode, aggDetails) {
+      var _this3 = this;
+
+      var result = {};
+      var changedValueColumns = aggDetails.changedPath.isActive() ? aggDetails.changedPath.getValueColumnsForNode(rowNode, aggDetails.valueColumns) : aggDetails.valueColumns;
+      var notChangedValueColumns = aggDetails.changedPath.isActive() ? aggDetails.changedPath.getNotValueColumnsForNode(rowNode, aggDetails.valueColumns) : null;
+      var values2d = this.getValuesNormal(rowNode, changedValueColumns);
+      var oldValues = rowNode.aggData;
+      changedValueColumns.forEach(function (valueColumn, index) {
+        result[valueColumn.getId()] = _this3.aggregateValues(values2d[index], valueColumn.getAggFunc(), valueColumn, rowNode);
+      });
+
+      if (notChangedValueColumns && oldValues) {
+        notChangedValueColumns.forEach(function (valueColumn) {
+          result[valueColumn.getId()] = oldValues[valueColumn.getId()];
+        });
+      }
+
+      return result;
+    }
+  }, {
+    key: "getValuesPivotNonLeaf",
+    value: function getValuesPivotNonLeaf(rowNode, colId) {
+      var values = [];
+      rowNode.childrenAfterFilter.forEach(function (node) {
+        var value = node.aggData[colId];
+        values.push(value);
+      });
+      return values;
+    }
+  }, {
+    key: "getValuesFromMappedSet",
+    value: function getValuesFromMappedSet(mappedSet, keys, valueColumn) {
+      var _this4 = this;
+
+      var mapPointer = mappedSet;
+      keys.forEach(function (key) {
+        return mapPointer = mapPointer ? mapPointer[key] : null;
+      });
+
+      if (!mapPointer) {
+        return [];
+      }
+
+      var values = [];
+      mapPointer.forEach(function (rowNode) {
+        var value = _this4.valueService.getValue(valueColumn, rowNode);
+
+        values.push(value);
+      });
+      return values;
+    }
+  }, {
+    key: "getValuesNormal",
+    value: function getValuesNormal(rowNode, valueColumns) {
+      // create 2d array, of all values for all valueColumns
+      var values = [];
+      valueColumns.forEach(function () {
+        return values.push([]);
+      });
+      var valueColumnCount = valueColumns.length;
+      var nodeList = this.filteredOnly ? rowNode.childrenAfterFilter : rowNode.childrenAfterGroup;
+      var rowCount = nodeList.length;
+
+      for (var i = 0; i < rowCount; i++) {
+        var childNode = nodeList[i];
+
+        for (var j = 0; j < valueColumnCount; j++) {
+          var valueColumn = valueColumns[j]; // if the row is a group, then it will only have an agg result value,
+          // which means valueGetter is never used.
+
+          var value = this.valueService.getValue(valueColumn, childNode);
+          values[j].push(value);
+        }
+      }
+
+      return values;
+    }
+  }, {
+    key: "aggregateValues",
+    value: function aggregateValues(values, aggFuncOrString, column, rowNode) {
+      var aggFunc = typeof aggFuncOrString === 'string' ? this.aggFuncService.getAggFunc(aggFuncOrString) : aggFuncOrString;
+
+      if (typeof aggFunc !== 'function') {
+        console.error("AG Grid: unrecognised aggregation function ".concat(aggFuncOrString));
+        return null;
+      }
+
+      var deprecationWarning = function deprecationWarning() {
+        _.doOnce(function () {
+          console.warn('AG Grid: since v24.0, custom aggregation functions take a params object. Please alter your aggregation function to use params.values');
+        }, 'aggregationStage.aggregateValues Deprecation');
+      };
+
+      var aggFuncAny = aggFunc;
+      var params = {
+        values: values,
+        column: column,
+        colDef: column ? column.getColDef() : undefined,
+        rowNode: rowNode,
+        data: rowNode ? rowNode.data : undefined,
+        api: this.gridApi,
+        columnApi: this.columnApi,
+        context: this.gridOptionsWrapper.getContext()
+      }; // the "as any" is needed to allow the deprecation warning messages
+
+      return aggFuncAny(params);
+    }
+  }]);
+
+  return AggregationStage;
+}(BeanStub);
+
+__decorate([Autowired('columnModel')], AggregationStage.prototype, "columnModel", void 0);
+
+__decorate([Autowired('valueService')], AggregationStage.prototype, "valueService", void 0);
+
+__decorate([Autowired('pivotStage')], AggregationStage.prototype, "pivotStage", void 0);
+
+__decorate([Autowired('aggFuncService')], AggregationStage.prototype, "aggFuncService", void 0);
+
+__decorate([Autowired('gridApi')], AggregationStage.prototype, "gridApi", void 0);
+
+__decorate([Autowired('columnApi')], AggregationStage.prototype, "columnApi", void 0);
+
+AggregationStage = __decorate([Bean('aggregationStage')], AggregationStage);
+export { AggregationStage };

package/es/components/DataGrid/modules/row-grouping/rowGrouping/batchRemover.d.ts

@@ -0,0 +1,10 @@
+import { RowNode } from "@ag-grid-community/core";
+export declare class BatchRemover {
+    private allSets;
+    private allParents;
+    removeFromChildrenAfterGroup(parent: RowNode, child: RowNode): void;
+    removeFromAllLeafChildren(parent: RowNode, child: RowNode): void;
+    private getSet;
+    getAllParents(): RowNode[];
+    flush(): void;
+}