@lemon-fe/components 0.1.154 → 1.1.0-alpha.0

package/es/data-grid/modules/row-grouping/rowGrouping/aggregationStage.js

@@ -0,0 +1,285 @@
+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, _toPropertyKey(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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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
+    // + api.refreshClientSideRowModel('aggregate')
+    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.getGroupRowAggFunc();
+      var changedPathActive = params.changedPath && params.changedPath.isActive();
+      if (noValueColumns && noUserAgg && changedPathActive) {
+        return;
+      }
+      var aggDetails = this.createAggDetails(params);
+      this.recursivelyCreateAggData(aggDetails);
+    }
+  }, {
+    key: "getGroupRowAggFunc",
+    value: function getGroupRowAggFunc() {
+      var getGroupRowAgg = this.gridOptionsService.getCallback('getGroupRowAgg');
+      if (getGroupRowAgg) {
+        return getGroupRowAgg;
+      }
+      // this is the deprecated way, so provide a proxy to make it compatible
+      var groupRowAggNodes = this.gridOptionsService.get('groupRowAggNodes');
+      if (groupRowAggNodes) {
+        return function (params) {
+          return groupRowAggNodes(params.nodes);
+        };
+      }
+    }
+  }, {
+    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: "isSuppressAggFilteredOnly",
+    value: function isSuppressAggFilteredOnly() {
+      var isGroupAggFiltering = this.gridOptionsService.getGroupAggFiltering() !== undefined;
+      return isGroupAggFiltering || this.gridOptionsService.is('suppressAggFilteredOnly');
+    }
+  }, {
+    key: "recursivelyCreateAggData",
+    value: function recursivelyCreateAggData(aggDetails) {
+      var _this = this;
+      // update prop, in case changed since last time
+      this.filteredOnly = !this.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.gridOptionsService.is('suppressAggAtRootLevel');
+          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.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 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.gridOptionsService.context
+      }; // 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/data-grid/modules/row-grouping/rowGrouping/batchRemover.d.ts

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

package/es/data-grid/modules/row-grouping/rowGrouping/batchRemover.js

@@ -0,0 +1,77 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var BatchRemover = /*#__PURE__*/function () {
+  function BatchRemover() {
+    _classCallCheck(this, BatchRemover);
+    this.allSets = {};
+    this.allParents = [];
+  }
+  _createClass(BatchRemover, [{
+    key: "removeFromChildrenAfterGroup",
+    value: function removeFromChildrenAfterGroup(parent, child) {
+      var set = this.getSet(parent);
+      set.removeFromChildrenAfterGroup[child.id] = true;
+    }
+  }, {
+    key: "isRemoveFromAllLeafChildren",
+    value: function isRemoveFromAllLeafChildren(parent, child) {
+      var set = this.getSet(parent);
+      return !!set.removeFromAllLeafChildren[child.id];
+    }
+  }, {
+    key: "preventRemoveFromAllLeafChildren",
+    value: function preventRemoveFromAllLeafChildren(parent, child) {
+      var set = this.getSet(parent);
+      delete set.removeFromAllLeafChildren[child.id];
+    }
+  }, {
+    key: "removeFromAllLeafChildren",
+    value: function removeFromAllLeafChildren(parent, child) {
+      var set = this.getSet(parent);
+      set.removeFromAllLeafChildren[child.id] = true;
+    }
+  }, {
+    key: "getSet",
+    value: function getSet(parent) {
+      if (!this.allSets[parent.id]) {
+        this.allSets[parent.id] = {
+          removeFromAllLeafChildren: {},
+          removeFromChildrenAfterGroup: {}
+        };
+        this.allParents.push(parent);
+      }
+      return this.allSets[parent.id];
+    }
+  }, {
+    key: "getAllParents",
+    value: function getAllParents() {
+      return this.allParents;
+    }
+  }, {
+    key: "flush",
+    value: function flush() {
+      var _this = this;
+      this.allParents.forEach(function (parent) {
+        var nodeDetails = _this.allSets[parent.id];
+        parent.childrenAfterGroup = parent.childrenAfterGroup.filter(function (child) {
+          return !nodeDetails.removeFromChildrenAfterGroup[child.id];
+        });
+        parent.allLeafChildren = parent.allLeafChildren.filter(function (child) {
+          return !nodeDetails.removeFromAllLeafChildren[child.id];
+        });
+        parent.updateHasChildren();
+        if (parent.sibling) {
+          parent.sibling.childrenAfterGroup = parent.childrenAfterGroup;
+          parent.sibling.allLeafChildren = parent.allLeafChildren;
+        }
+      });
+      this.allSets = {};
+      this.allParents.length = 0;
+    }
+  }]);
+  return BatchRemover;
+}();

package/es/data-grid/modules/row-grouping/rowGrouping/columnDropZones/baseDropZonePanel.d.ts

@@ -0,0 +1,75 @@
+import { Column, ColumnEventType, Component, Context, DragAndDropService, EventService, GridOptionsService, LoggerFactory } from "@ag-grid-community/core";
+export interface BaseDropZonePanelParams {
+    dragAndDropIcon: string;
+    emptyMessage: string;
+    title: string;
+    icon: HTMLElement;
+}
+export interface BaseDropZonePanelBeans {
+    gridOptionsService: GridOptionsService;
+    eventService: EventService;
+    context: Context;
+    loggerFactory: LoggerFactory;
+    dragAndDropService: DragAndDropService;
+}
+export declare type TDropZone = 'rowGroup' | 'pivot' | 'aggregation';
+export declare abstract class BaseDropZonePanel extends Component {
+    private horizontal;
+    private dropZonePurpose;
+    private colModel;
+    private static STATE_NOT_DRAGGING;
+    private static STATE_NEW_COLUMNS_IN;
+    private static STATE_REARRANGE_COLUMNS;
+    private state;
+    private dropTarget;
+    private potentialDndColumns;
+    private guiDestroyFunctions;
+    private params;
+    private beans;
+    private childColumnComponents;
+    private insertIndex;
+    private eColumnDropList;
+    private positionableFeature;
+    private resizeEnabled;
+    protected abstract isColumnDroppable(column: Column): boolean;
+    protected abstract updateColumns(columns: Column[]): void;
+    protected abstract getExistingColumns(): Column[];
+    protected abstract getIconName(): string;
+    protected abstract getAriaLabel(): string;
+    private readonly focusService;
+    constructor(horizontal: boolean, dropZonePurpose: TDropZone);
+    isHorizontal(): boolean;
+    toggleResizable(resizable: boolean): void;
+    setBeans(beans: BaseDropZonePanelBeans): void;
+    protected destroy(): void;
+    private destroyGui;
+    init(params: BaseDropZonePanelParams): void;
+    private handleKeyDown;
+    private addElementClasses;
+    private setupDropTarget;
+    private isInterestedIn;
+    private checkInsertIndex;
+    private getNewInsertIndex;
+    private checkDragStartedBySelf;
+    private onDragging;
+    private onDragEnter;
+    setColumnsVisible(columns: Column[] | null | undefined, visible: boolean, source?: ColumnEventType): void;
+    protected isPotentialDndColumns(): boolean;
+    private isRowGroupPanel;
+    private onDragLeave;
+    private onDragStop;
+    private removeColumns;
+    private addColumns;
+    private rearrangeColumns;
+    refreshGui(): void;
+    private getFocusedItem;
+    private restoreFocus;
+    private getNonGhostColumns;
+    private addColumnsToGui;
+    private addAriaLabelsToComponents;
+    private createColumnComponent;
+    private addIconAndTitleToGui;
+    private isExistingColumnsEmpty;
+    private addEmptyMessageToGui;
+    private addArrow;
+}