@lemon-fe/kits 0.1.136 → 1.0.0-0

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

@@ -0,0 +1,24 @@
+import { BeanStub, ColDef, ColGroupDef } from "@ag-grid-community/core";
+export interface PivotColDefServiceResult {
+    pivotColumnGroupDefs: (ColDef | ColGroupDef)[];
+    pivotColumnDefs: ColDef[];
+}
+export declare class PivotColDefService extends BeanStub {
+    static PIVOT_ROW_TOTAL_PREFIX: string;
+    private columnModel;
+    createPivotColumnDefs(uniqueValues: any): PivotColDefServiceResult;
+    private recursiveBuildGroup;
+    private buildMeasureCols;
+    private addExpandablePivotGroups;
+    private addPivotTotalsToGroups;
+    private recursivelyAddPivotTotal;
+    private addRowGroupTotals;
+    private extractColIdsForValueColumn;
+    private createRowGroupTotal;
+    private createColDef;
+    private sameAggFuncs;
+    private headerNameComparator;
+    private merge;
+    private generateColumnGroupId;
+    private generateColumnId;
+}

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

@@ -0,0 +1,478 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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 PivotColDefService_1;
+import { Autowired, Bean, BeanStub, _ } from "@ag-grid-community/core";
+
+var PivotColDefService = PivotColDefService_1 = /*#__PURE__*/function (_BeanStub) {
+  _inherits(PivotColDefService, _BeanStub);
+
+  var _super = _createSuper(PivotColDefService);
+
+  function PivotColDefService() {
+    _classCallCheck(this, PivotColDefService);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(PivotColDefService, [{
+    key: "createPivotColumnDefs",
+    value: function createPivotColumnDefs(uniqueValues) {
+      // this is passed to the columnModel, to configure the columns and groups we show
+      var pivotColumns = this.columnModel.getPivotColumns();
+      var valueColumns = this.columnModel.getValueColumns();
+      var levelsDeep = pivotColumns.length;
+      var pivotColumnGroupDefs = this.recursiveBuildGroup(0, uniqueValues, [], levelsDeep, pivotColumns);
+
+      function extractColDefs(input) {
+        var arr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+        input.forEach(function (def) {
+          if (def.children !== undefined) {
+            extractColDefs(def.children, arr);
+          } else {
+            arr.push(def);
+          }
+        });
+        return arr;
+      }
+
+      var pivotColumnDefs = extractColDefs(pivotColumnGroupDefs); // additional columns that contain the aggregated total for each value column per row
+
+      this.addRowGroupTotals(pivotColumnGroupDefs, pivotColumnDefs, valueColumns); // additional group columns that contain child totals for each collapsed child column / group
+
+      this.addExpandablePivotGroups(pivotColumnGroupDefs, pivotColumnDefs); // additional group columns that contain an aggregated total across all child columns
+
+      this.addPivotTotalsToGroups(pivotColumnGroupDefs, pivotColumnDefs); // we clone, so the colDefs in pivotColumnsGroupDefs and pivotColumnDefs are not shared. this is so that
+      // any changes the user makes (via processSecondaryColumnDefinitions) don't impact the internal aggregations,
+      // as these use the col defs also
+
+      var pivotColumnDefsClone = pivotColumnDefs.map(function (colDef) {
+        return _.cloneObject(colDef);
+      });
+      return {
+        pivotColumnGroupDefs: pivotColumnGroupDefs,
+        pivotColumnDefs: pivotColumnDefsClone
+      };
+    }
+  }, {
+    key: "recursiveBuildGroup",
+    value: function recursiveBuildGroup(index, uniqueValue, pivotKeys, maxDepth, primaryPivotColumns) {
+      var _this = this;
+
+      var measureColumns = this.columnModel.getValueColumns();
+
+      if (index >= maxDepth) {
+        // Base case - build the measure columns
+        return this.buildMeasureCols(pivotKeys);
+      } // sort by either user provided comparator, or our own one
+
+
+      var primaryPivotColumnDefs = primaryPivotColumns[index].getColDef();
+      var comparator = this.headerNameComparator.bind(this, primaryPivotColumnDefs.pivotComparator); // Base case for the compact layout, instead of recursing build the last layer of groups as measure columns instead
+
+      if (measureColumns.length === 1 && this.gridOptionsWrapper.isRemovePivotHeaderRowWhenSingleValueColumn() && index === maxDepth - 1) {
+        var leafCols = [];
+
+        _.iterateObject(uniqueValue, function (key) {
+          var newPivotKeys = [].concat(_toConsumableArray(pivotKeys), [key]);
+          leafCols.push(Object.assign(Object.assign({}, _this.createColDef(measureColumns[0], key, newPivotKeys)), {
+            columnGroupShow: 'open'
+          }));
+        });
+
+        leafCols.sort(comparator);
+        return leafCols;
+      } // Recursive case
+
+
+      var groups = [];
+
+      _.iterateObject(uniqueValue, function (key, value) {
+        var newPivotKeys = [].concat(_toConsumableArray(pivotKeys), [key]);
+        groups.push({
+          children: _this.recursiveBuildGroup(index + 1, value, newPivotKeys, maxDepth, primaryPivotColumns),
+          headerName: key,
+          pivotKeys: newPivotKeys,
+          columnGroupShow: 'open',
+          groupId: _this.generateColumnGroupId(newPivotKeys)
+        });
+      });
+
+      groups.sort(comparator);
+      return groups;
+    }
+  }, {
+    key: "buildMeasureCols",
+    value: function buildMeasureCols(pivotKeys) {
+      var _this2 = this;
+
+      var measureColumns = this.columnModel.getValueColumns();
+
+      if (measureColumns.length === 0) {
+        // if no value columns selected, then we insert one blank column, so the user at least sees columns
+        // rendered. otherwise the grid would render with no columns (just empty groups) which would give the
+        // impression that the grid is broken
+        return [this.createColDef(null, '-', pivotKeys)];
+      }
+
+      return measureColumns.map(function (measureCol) {
+        var columnName = _this2.columnModel.getDisplayNameForColumn(measureCol, 'header');
+
+        return Object.assign(Object.assign({}, _this2.createColDef(measureCol, columnName, pivotKeys)), {
+          columnGroupShow: 'open'
+        });
+      });
+    }
+  }, {
+    key: "addExpandablePivotGroups",
+    value: function addExpandablePivotGroups(pivotColumnGroupDefs, pivotColumnDefs) {
+      var _this3 = this;
+
+      if (this.gridOptionsWrapper.isSuppressExpandablePivotGroups() || this.gridOptionsWrapper.getPivotColumnGroupTotals()) {
+        return;
+      }
+
+      var recursivelyAddSubTotals = function recursivelyAddSubTotals(groupDef, currentPivotColumnDefs, acc) {
+        var group = groupDef;
+
+        if (group.children) {
+          var childAcc = new Map();
+          group.children.forEach(function (grp) {
+            recursivelyAddSubTotals(grp, currentPivotColumnDefs, childAcc);
+          });
+          var firstGroup = !group.children.some(function (child) {
+            return child.children;
+          });
+
+          _this3.columnModel.getValueColumns().forEach(function (valueColumn) {
+            var columnName = _this3.columnModel.getDisplayNameForColumn(valueColumn, 'header');
+
+            var totalColDef = _this3.createColDef(valueColumn, columnName, groupDef.pivotKeys);
+
+            totalColDef.pivotTotalColumnIds = childAcc.get(valueColumn.getColId());
+            totalColDef.columnGroupShow = 'closed';
+            totalColDef.aggFunc = valueColumn.getAggFunc();
+
+            if (!firstGroup) {
+              // add total colDef to group and pivot colDefs array
+              var children = groupDef.children;
+              children.push(totalColDef);
+              currentPivotColumnDefs.push(totalColDef);
+            }
+          });
+
+          _this3.merge(acc, childAcc);
+        } else {
+          var def = groupDef; // check that value column exists, i.e. aggFunc is supplied
+
+          if (!def.pivotValueColumn) {
+            return;
+          }
+
+          var pivotValueColId = def.pivotValueColumn.getColId();
+          var arr = acc.has(pivotValueColId) ? acc.get(pivotValueColId) : [];
+          arr.push(def.colId);
+          acc.set(pivotValueColId, arr);
+        }
+      };
+
+      pivotColumnGroupDefs.forEach(function (groupDef) {
+        recursivelyAddSubTotals(groupDef, pivotColumnDefs, new Map());
+      });
+    }
+  }, {
+    key: "addPivotTotalsToGroups",
+    value: function addPivotTotalsToGroups(pivotColumnGroupDefs, pivotColumnDefs) {
+      var _this4 = this;
+
+      if (!this.gridOptionsWrapper.getPivotColumnGroupTotals()) {
+        return;
+      }
+
+      var insertAfter = this.gridOptionsWrapper.getPivotColumnGroupTotals() === 'after';
+      var valueCols = this.columnModel.getValueColumns();
+      var aggFuncs = valueCols.map(function (valueCol) {
+        return valueCol.getAggFunc();
+      }); // don't add pivot totals if there is less than 1 aggFunc or they are not all the same
+
+      if (!aggFuncs || aggFuncs.length < 1 || !this.sameAggFuncs(aggFuncs)) {
+        // console.warn('AG Grid: aborting adding pivot total columns - value columns require same aggFunc');
+        return;
+      } // arbitrarily select a value column to use as a template for pivot columns
+
+
+      var valueColumn = valueCols[0];
+      pivotColumnGroupDefs.forEach(function (groupDef) {
+        _this4.recursivelyAddPivotTotal(groupDef, pivotColumnDefs, valueColumn, insertAfter);
+      });
+    }
+  }, {
+    key: "recursivelyAddPivotTotal",
+    value: function recursivelyAddPivotTotal(groupDef, pivotColumnDefs, valueColumn, insertAfter) {
+      var _this5 = this;
+
+      var group = groupDef;
+
+      if (!group.children) {
+        var def = groupDef;
+        return def.colId ? [def.colId] : null;
+      }
+
+      var colIds = []; // need to recurse children first to obtain colIds used in the aggregation stage
+
+      group.children.forEach(function (grp) {
+        var childColIds = _this5.recursivelyAddPivotTotal(grp, pivotColumnDefs, valueColumn, insertAfter);
+
+        if (childColIds) {
+          colIds = colIds.concat(childColIds);
+        }
+      }); // only add total colDef if there is more than 1 child node
+
+      if (group.children.length > 1) {
+        var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+        var headerName = localeTextFunc('pivotColumnGroupTotals', 'Total'); //create total colDef using an arbitrary value column as a template
+
+        var totalColDef = this.createColDef(valueColumn, headerName, groupDef.pivotKeys, true);
+        totalColDef.pivotTotalColumnIds = colIds;
+        totalColDef.aggFunc = valueColumn.getAggFunc(); // add total colDef to group and pivot colDefs array
+
+        var children = groupDef.children;
+        insertAfter ? children.push(totalColDef) : children.unshift(totalColDef);
+        pivotColumnDefs.push(totalColDef);
+      }
+
+      return colIds;
+    }
+  }, {
+    key: "addRowGroupTotals",
+    value: function addRowGroupTotals(pivotColumnGroupDefs, pivotColumnDefs, valueColumns) {
+      var _this6 = this;
+
+      if (!this.gridOptionsWrapper.getPivotRowTotals()) {
+        return;
+      }
+
+      var insertAfter = this.gridOptionsWrapper.getPivotRowTotals() === 'after'; // order of row group totals depends on position
+
+      var valueCols = insertAfter ? valueColumns.slice() : valueColumns.slice().reverse();
+
+      var _loop = function _loop(i) {
+        var valueCol = valueCols[i];
+        var colIds = [];
+        pivotColumnGroupDefs.forEach(function (groupDef) {
+          colIds = colIds.concat(_this6.extractColIdsForValueColumn(groupDef, valueCol));
+        });
+        var withGroup = valueCols.length > 1 || !_this6.gridOptionsWrapper.isRemovePivotHeaderRowWhenSingleValueColumn();
+
+        _this6.createRowGroupTotal(pivotColumnGroupDefs, pivotColumnDefs, valueCol, colIds, insertAfter, withGroup);
+      };
+
+      for (var i = 0; i < valueCols.length; i++) {
+        _loop(i);
+      }
+    }
+  }, {
+    key: "extractColIdsForValueColumn",
+    value: function extractColIdsForValueColumn(groupDef, valueColumn) {
+      var _this7 = this;
+
+      var group = groupDef;
+
+      if (!group.children) {
+        var colDef = group;
+        return colDef.pivotValueColumn === valueColumn && colDef.colId ? [colDef.colId] : [];
+      }
+
+      var colIds = [];
+      group.children.forEach(function (grp) {
+        _this7.extractColIdsForValueColumn(grp, valueColumn);
+
+        var childColIds = _this7.extractColIdsForValueColumn(grp, valueColumn);
+
+        colIds = colIds.concat(childColIds);
+      });
+      return colIds;
+    }
+  }, {
+    key: "createRowGroupTotal",
+    value: function createRowGroupTotal(parentChildren, pivotColumnDefs, valueColumn, colIds, insertAfter, addGroup) {
+      var measureColumns = this.columnModel.getValueColumns();
+      var colDef;
+
+      if (measureColumns.length === 0) {
+        colDef = this.createColDef(null, '-', []);
+      } else {
+        var columnName = this.columnModel.getDisplayNameForColumn(valueColumn, 'header');
+        colDef = this.createColDef(valueColumn, columnName, []);
+        colDef.pivotTotalColumnIds = colIds;
+      }
+
+      colDef.colId = PivotColDefService_1.PIVOT_ROW_TOTAL_PREFIX + colDef.colId;
+      pivotColumnDefs.push(colDef);
+      var valueGroup = addGroup ? {
+        children: [colDef],
+        pivotKeys: [],
+        groupId: "".concat(PivotColDefService_1.PIVOT_ROW_TOTAL_PREFIX, "_pivotGroup_").concat(valueColumn.getColId())
+      } : colDef;
+      insertAfter ? parentChildren.push(valueGroup) : parentChildren.unshift(valueGroup);
+    }
+  }, {
+    key: "createColDef",
+    value: function createColDef(valueColumn, headerName, pivotKeys) {
+      var totalColumn = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      var colDef = {}; // This is null when there are no measure columns and we're creating placeholder columns
+
+      if (valueColumn) {
+        var colDefToCopy = valueColumn.getColDef();
+        Object.assign(colDef, colDefToCopy); // even if original column was hidden, we always show the pivot value column, otherwise it would be
+        // very confusing for people thinking the pivot is broken
+
+        colDef.hide = false;
+      }
+
+      colDef.headerName = headerName;
+      colDef.colId = this.generateColumnId(pivotKeys || [], valueColumn && !totalColumn ? valueColumn.getColId() : ''); // pivot columns repeat over field, so it makes sense to use the unique id instead. For example if you want to
+      // assign values to pinned bottom rows using setPinnedBottomRowData the value service will use this colId.
+
+      colDef.field = colDef.colId; // this is to support using pinned rows, normally the data will be extracted from the aggData object using the colId
+      // however pinned rows still access the data object by field, this prevents values with dots from being treated as complex objects
+
+      colDef.valueGetter = function (params) {
+        var _a;
+
+        return (_a = params.data) === null || _a === void 0 ? void 0 : _a[params.colDef.field];
+      };
+
+      colDef.pivotKeys = pivotKeys;
+      colDef.pivotValueColumn = valueColumn;
+
+      if (colDef.filter === true) {
+        colDef.filter = 'agNumberColumnFilter';
+      }
+
+      return colDef;
+    }
+  }, {
+    key: "sameAggFuncs",
+    value: function sameAggFuncs(aggFuncs) {
+      if (aggFuncs.length == 1) {
+        return true;
+      } //check if all aggFunc's match
+
+
+      for (var i = 1; i < aggFuncs.length; i++) {
+        if (aggFuncs[i] !== aggFuncs[0]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }, {
+    key: "headerNameComparator",
+    value: function headerNameComparator(userComparator, a, b) {
+      if (userComparator) {
+        return userComparator(a.headerName, b.headerName);
+      } else {
+        if (a.headerName && !b.headerName) {
+          return 1;
+        } else if (!a.headerName && b.headerName) {
+          return -1;
+        } // slightly naff here - just to satify typescript
+        // really should be &&, but if so ts complains
+        // the above if/else checks would deal with either being falsy, so at this stage if either are falsy, both are
+        // ..still naff though
+
+
+        if (!a.headerName || !b.headerName) {
+          return 0;
+        }
+
+        if (a.headerName < b.headerName) {
+          return -1;
+        }
+
+        if (a.headerName > b.headerName) {
+          return 1;
+        }
+
+        return 0;
+      }
+    }
+  }, {
+    key: "merge",
+    value: function merge(m1, m2) {
+      m2.forEach(function (value, key, map) {
+        var existingList = m1.has(key) ? m1.get(key) : [];
+        var updatedList = [].concat(_toConsumableArray(existingList), _toConsumableArray(value));
+        m1.set(key, updatedList);
+      });
+    }
+  }, {
+    key: "generateColumnGroupId",
+    value: function generateColumnGroupId(pivotKeys) {
+      var pivotCols = this.columnModel.getPivotColumns().map(function (col) {
+        return col.getColId();
+      });
+      return "pivotGroup_".concat(pivotCols.join('-'), "_").concat(pivotKeys.join('-'));
+    }
+  }, {
+    key: "generateColumnId",
+    value: function generateColumnId(pivotKeys, measureColumnId) {
+      var pivotCols = this.columnModel.getPivotColumns().map(function (col) {
+        return col.getColId();
+      });
+      return "pivot_".concat(pivotCols.join('-'), "_").concat(pivotKeys.join('-'), "_").concat(measureColumnId);
+    }
+  }]);
+
+  return PivotColDefService;
+}(BeanStub);
+
+PivotColDefService.PIVOT_ROW_TOTAL_PREFIX = 'PivotRowTotal_';
+
+__decorate([Autowired('columnModel')], PivotColDefService.prototype, "columnModel", void 0);
+
+PivotColDefService = PivotColDefService_1 = __decorate([Bean('pivotColDefService')], PivotColDefService);
+export { PivotColDefService };

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

@@ -0,0 +1,19 @@
+import { BeanStub, ColDef, IRowNodeStage, StageExecuteParams } from "@ag-grid-community/core";
+export declare class PivotStage extends BeanStub implements IRowNodeStage {
+    private valueService;
+    private columnModel;
+    private pivotColDefService;
+    private uniqueValues;
+    private pivotColumnDefs;
+    private aggregationColumnsHashLastTime;
+    private aggregationFuncsHashLastTime;
+    private groupColumnsHashLastTime;
+    execute(params: StageExecuteParams): void;
+    private executePivotOff;
+    private executePivotOn;
+    private setUniqueValues;
+    private bucketUpRowNodes;
+    private bucketRowNode;
+    private bucketChildren;
+    getPivotColumnDefs(): ColDef[];
+}