@lemon-fe/kits 0.1.136 → 1.0.0-0

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

@@ -0,0 +1,219 @@
+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 { Autowired, Bean, BeanStub, _ } from "@ag-grid-community/core";
+
+var PivotStage = /*#__PURE__*/function (_BeanStub) {
+  _inherits(PivotStage, _BeanStub);
+
+  var _super = _createSuper(PivotStage);
+
+  function PivotStage() {
+    var _this;
+
+    _classCallCheck(this, PivotStage);
+
+    _this = _super.apply(this, arguments);
+    _this.uniqueValues = {};
+    return _this;
+  }
+
+  _createClass(PivotStage, [{
+    key: "execute",
+    value: function execute(params) {
+      var rootNode = params.rowNode;
+      var changedPath = params.changedPath;
+
+      if (this.columnModel.isPivotActive()) {
+        this.executePivotOn(rootNode, changedPath);
+      } else {
+        this.executePivotOff(changedPath);
+      }
+    }
+  }, {
+    key: "executePivotOff",
+    value: function executePivotOff(changedPath) {
+      this.aggregationColumnsHashLastTime = null;
+      this.uniqueValues = {};
+
+      if (this.columnModel.isSecondaryColumnsPresent()) {
+        this.columnModel.setSecondaryColumns(null, "rowModelUpdated");
+
+        if (changedPath) {
+          changedPath.setInactive();
+        }
+      }
+    }
+  }, {
+    key: "executePivotOn",
+    value: function executePivotOn(rootNode, changedPath) {
+      var uniqueValues = this.bucketUpRowNodes(rootNode);
+      var uniqueValuesChanged = this.setUniqueValues(uniqueValues);
+      var aggregationColumns = this.columnModel.getValueColumns();
+      var aggregationColumnsHash = aggregationColumns.map(function (column) {
+        return "".concat(column.getId(), "-").concat(column.getColDef().headerName);
+      }).join('#');
+      var aggregationFuncsHash = aggregationColumns.map(function (column) {
+        return column.getAggFunc().toString();
+      }).join('#');
+      var aggregationColumnsChanged = this.aggregationColumnsHashLastTime !== aggregationColumnsHash;
+      var aggregationFuncsChanged = this.aggregationFuncsHashLastTime !== aggregationFuncsHash;
+      this.aggregationColumnsHashLastTime = aggregationColumnsHash;
+      this.aggregationFuncsHashLastTime = aggregationFuncsHash;
+      var groupColumnsHash = this.columnModel.getRowGroupColumns().map(function (column) {
+        return column.getId();
+      }).join('#');
+      var groupColumnsChanged = groupColumnsHash !== this.groupColumnsHashLastTime;
+      this.groupColumnsHashLastTime = groupColumnsHash;
+
+      if (uniqueValuesChanged || aggregationColumnsChanged || groupColumnsChanged || aggregationFuncsChanged) {
+        var _this$pivotColDefServ = this.pivotColDefService.createPivotColumnDefs(this.uniqueValues),
+            pivotColumnGroupDefs = _this$pivotColDefServ.pivotColumnGroupDefs,
+            pivotColumnDefs = _this$pivotColDefServ.pivotColumnDefs;
+
+        this.pivotColumnDefs = pivotColumnDefs;
+        this.columnModel.setSecondaryColumns(pivotColumnGroupDefs, "rowModelUpdated"); // because the secondary columns have changed, then the aggregation needs to visit the whole
+        // tree again, so we make the changedPath not active, to force aggregation to visit all paths.
+
+        if (changedPath) {
+          changedPath.setInactive();
+        }
+      }
+    }
+  }, {
+    key: "setUniqueValues",
+    value: function setUniqueValues(newValues) {
+      var json1 = JSON.stringify(newValues);
+      var json2 = JSON.stringify(this.uniqueValues);
+      var uniqueValuesChanged = json1 !== json2; // we only continue the below if the unique values are different, as otherwise
+      // the result will be the same as the last time we did it
+
+      if (uniqueValuesChanged) {
+        this.uniqueValues = newValues;
+        return true;
+      } else {
+        return false;
+      }
+    } // returns true if values were different
+
+  }, {
+    key: "bucketUpRowNodes",
+    value: function bucketUpRowNodes(rootNode) {
+      var _this2 = this;
+
+      // accessed from inside inner function
+      var uniqueValues = {}; // finds all leaf groups and calls mapRowNode with it
+
+      var recursivelySearchForLeafNodes = function recursivelySearchForLeafNodes(rowNode) {
+        if (rowNode.leafGroup) {
+          _this2.bucketRowNode(rowNode, uniqueValues);
+        } else {
+          rowNode.childrenAfterFilter.forEach(function (child) {
+            recursivelySearchForLeafNodes(child);
+          });
+        }
+      };
+
+      recursivelySearchForLeafNodes(rootNode);
+      return uniqueValues;
+    }
+  }, {
+    key: "bucketRowNode",
+    value: function bucketRowNode(rowNode, uniqueValues) {
+      var pivotColumns = this.columnModel.getPivotColumns();
+
+      if (pivotColumns.length === 0) {
+        rowNode.childrenMapped = null;
+      } else {
+        rowNode.childrenMapped = this.bucketChildren(rowNode.childrenAfterFilter, pivotColumns, 0, uniqueValues);
+      }
+
+      if (rowNode.sibling) {
+        rowNode.sibling.childrenMapped = rowNode.childrenMapped;
+      }
+    }
+  }, {
+    key: "bucketChildren",
+    value: function bucketChildren(children, pivotColumns, pivotIndex, uniqueValues) {
+      var _this3 = this;
+
+      var mappedChildren = {};
+      var pivotColumn = pivotColumns[pivotIndex]; // map the children out based on the pivot column
+
+      children.forEach(function (child) {
+        var key = _this3.valueService.getKeyForNode(pivotColumn, child);
+
+        if (_.missing(key)) {
+          key = '';
+        }
+
+        if (!uniqueValues[key]) {
+          uniqueValues[key] = {};
+        }
+
+        if (!mappedChildren[key]) {
+          mappedChildren[key] = [];
+        }
+
+        mappedChildren[key].push(child);
+      }); // if it's the last pivot column, return as is, otherwise go one level further in the map
+
+      if (pivotIndex === pivotColumns.length - 1) {
+        return mappedChildren;
+      } else {
+        var result = {};
+
+        _.iterateObject(mappedChildren, function (key, value) {
+          result[key] = _this3.bucketChildren(value, pivotColumns, pivotIndex + 1, uniqueValues[key]);
+        });
+
+        return result;
+      }
+    }
+  }, {
+    key: "getPivotColumnDefs",
+    value: function getPivotColumnDefs() {
+      return this.pivotColumnDefs;
+    }
+  }]);
+
+  return PivotStage;
+}(BeanStub);
+
+__decorate([Autowired('valueService')], PivotStage.prototype, "valueService", void 0);
+
+__decorate([Autowired('columnModel')], PivotStage.prototype, "columnModel", void 0);
+
+__decorate([Autowired('pivotColDefService')], PivotStage.prototype, "pivotColDefService", void 0);
+
+PivotStage = __decorate([Bean('pivotStage')], PivotStage);
+export { PivotStage };

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

@@ -0,0 +1,16 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { AggregationStage } from './rowGrouping/aggregationStage';
+import { GroupStage } from './rowGrouping/groupStage';
+import { PivotColDefService } from './rowGrouping/pivotColDefService';
+import { PivotStage } from './rowGrouping/pivotStage';
+import { AggFuncService } from './rowGrouping/aggFuncService';
+import { GridHeaderDropZones } from './rowGrouping/columnDropZones/gridHeaderDropZones';
+import { FilterAggregatesStage } from './rowGrouping/filterAggregatesStage';
+export declare const RowGroupingModule: {
+    moduleName: ModuleNames;
+    beans: (typeof AggregationStage | typeof FilterAggregatesStage | typeof GroupStage | typeof PivotColDefService | typeof PivotStage | typeof AggFuncService)[];
+    agStackComponents: {
+        componentName: string;
+        componentClass: typeof GridHeaderDropZones;
+    }[];
+};

package/es/components/DataGrid/modules/row-grouping/rowGroupingModule.js

@@ -0,0 +1,16 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { AggregationStage } from "./rowGrouping/aggregationStage";
+import { GroupStage } from "./rowGrouping/groupStage";
+import { PivotColDefService } from "./rowGrouping/pivotColDefService";
+import { PivotStage } from "./rowGrouping/pivotStage";
+import { AggFuncService } from "./rowGrouping/aggFuncService";
+import { GridHeaderDropZones } from "./rowGrouping/columnDropZones/gridHeaderDropZones";
+import { FilterAggregatesStage } from "./rowGrouping/filterAggregatesStage";
+export var RowGroupingModule = {
+  moduleName: ModuleNames.RowGroupingModule,
+  beans: [AggregationStage, FilterAggregatesStage, GroupStage, PivotColDefService, PivotStage, AggFuncService],
+  agStackComponents: [{
+    componentName: 'AgGridHeaderDropZones',
+    componentClass: GridHeaderDropZones
+  }]
+};

package/es/components/DataGrid/modules/server-side-row-model/index.d.ts

@@ -0,0 +1 @@
+export { ServerSideRowModelModule } from './serverSideRowModelModule';

package/es/components/DataGrid/modules/server-side-row-model/index.js

@@ -0,0 +1 @@
+export { ServerSideRowModelModule } from "./serverSideRowModelModule";

package/es/components/DataGrid/modules/server-side-row-model/serverSideRowModel/blocks/blockUtils.d.ts

@@ -0,0 +1,47 @@
+import { RowBounds, BeanStub, Column, RowNode, NumberSequence } from '@ag-grid-community/core';
+export declare class BlockUtils extends BeanStub {
+  private valueService;
+  private columnModel;
+  private nodeManager;
+  private beans;
+  private rowHeight;
+  private usingTreeData;
+  private usingMasterDetail;
+  private postConstruct;
+  createRowNode(params: {
+    group: boolean;
+    leafGroup: boolean;
+    level: number;
+    parent: RowNode;
+    field: string;
+    rowGroupColumn: Column;
+    rowHeight?: number;
+  }): RowNode;
+  destroyRowNodes(rowNodes: RowNode[]): void;
+  destroyRowNode(rowNode: RowNode, preserveStore?: boolean): void;
+  private setTreeGroupInfo;
+  private setRowGroupInfo;
+  private setMasterDetailInfo;
+  updateDataIntoRowNode(rowNode: RowNode, data: any): void;
+  setDataIntoRowNode(
+    rowNode: RowNode,
+    data: any,
+    defaultId: string,
+    cachedRowHeight: number | undefined,
+  ): void;
+  private setChildCountIntoRowNode;
+  private setGroupDataIntoRowNode;
+  clearDisplayIndex(rowNode: RowNode): void;
+  setDisplayIndex(
+    rowNode: RowNode,
+    displayIndexSeq: NumberSequence,
+    nextRowTop: {
+      value: number;
+    },
+  ): void;
+  binarySearchForDisplayIndex(displayRowIndex: number, rowNodes: RowNode[]): RowNode | undefined;
+  extractRowBounds(rowNode: RowNode, index: number): RowBounds | undefined;
+  getIndexAtPixel(rowNode: RowNode, pixel: number): number | null;
+  createNodeIdPrefix(parentRowNode: RowNode): string | undefined;
+  checkOpenByDefault(rowNode: RowNode): void;
+}