@lemon-fe/kits 0.1.136 → 1.0.0-0

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

@@ -0,0 +1,460 @@
+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 { DragSourceType, Component, Autowired, Events, TouchListener, DragAndDropService, PostConstruct, Column, RefSelector, Optional, VirtualList, KeyCode, _ } from "@ag-grid-community/core";
+export var DropZoneColumnComp = /*#__PURE__*/function (_Component) {
+  _inherits(DropZoneColumnComp, _Component);
+
+  var _super = _createSuper(DropZoneColumnComp);
+
+  function DropZoneColumnComp(column, dragSourceDropTarget, ghost, dropZonePurpose, horizontal) {
+    var _this;
+
+    _classCallCheck(this, DropZoneColumnComp);
+
+    _this = _super.call(this);
+    _this.column = column;
+    _this.dragSourceDropTarget = dragSourceDropTarget;
+    _this.ghost = ghost;
+    _this.dropZonePurpose = dropZonePurpose;
+    _this.horizontal = horizontal;
+    _this.popupShowing = false;
+    return _this;
+  }
+
+  _createClass(DropZoneColumnComp, [{
+    key: "init",
+    value: function init() {
+      var _this2 = this;
+
+      this.setTemplate(DropZoneColumnComp.TEMPLATE);
+      var eGui = this.getGui();
+      var isFunctionsReadOnly = this.gridOptionsWrapper.isFunctionsReadOnly();
+      this.addElementClasses(eGui);
+      this.addElementClasses(this.eDragHandle, 'drag-handle');
+      this.addElementClasses(this.eText, 'text');
+      this.addElementClasses(this.eButton, 'button');
+      this.eDragHandle.appendChild(_.createIconNoSpan('columnDrag', this.gridOptionsWrapper));
+      this.eButton.appendChild(_.createIconNoSpan('cancel', this.gridOptionsWrapper));
+      this.setupSort();
+      this.displayName = this.columnModel.getDisplayNameForColumn(this.column, 'columnDrop');
+      this.setupComponents();
+
+      if (!this.ghost && !isFunctionsReadOnly) {
+        this.addDragSource();
+      }
+
+      this.setupAria();
+      this.addManagedListener(this.column, Column.EVENT_SORT_CHANGED, function () {
+        _this2.setupAria();
+      });
+      this.setupTooltip();
+    }
+  }, {
+    key: "setupAria",
+    value: function setupAria() {
+      var translate = this.gridOptionsWrapper.getLocaleTextFunc();
+
+      var _this$getColumnAndAgg = this.getColumnAndAggFuncName(),
+          name = _this$getColumnAndAgg.name,
+          aggFuncName = _this$getColumnAndAgg.aggFuncName;
+
+      var aggSeparator = translate('ariaDropZoneColumnComponentAggFuncSeperator', ' of ');
+      var sortDirection = {
+        asc: translate('ariaDropZoneColumnComponentSortAscending', 'ascending'),
+        desc: translate('ariaDropZoneColumnComponentSortDescending', 'descending')
+      };
+      var columnSort = this.column.getSort();
+      var isSortSuppressed = this.gridOptionsWrapper.isRowGroupPanelSuppressSort();
+      var ariaInstructions = [[aggFuncName && "".concat(aggFuncName).concat(aggSeparator), name, this.isGroupingZone() && !isSortSuppressed && columnSort && ", ".concat(sortDirection[columnSort])].filter(function (part) {
+        return !!part;
+      }).join('')];
+      var isFunctionsReadOnly = this.gridOptionsWrapper.isFunctionsReadOnly();
+
+      if (this.isAggregationZone() && !isFunctionsReadOnly) {
+        var aggregationMenuAria = translate('ariaDropZoneColumnValueItemDescription', 'Press ENTER to change the aggregation type');
+        ariaInstructions.push(aggregationMenuAria);
+      }
+
+      if (this.isGroupingZone() && this.column.getColDef().sortable && !isSortSuppressed) {
+        var sortProgressAria = translate('ariaDropZoneColumnGroupItemDescription', 'Press ENTER to sort');
+        ariaInstructions.push(sortProgressAria);
+      }
+
+      var deleteAria = translate('ariaDropZoneColumnComponentDescription', 'Press DELETE to remove');
+      ariaInstructions.push(deleteAria);
+
+      _.setAriaLabel(this.getGui(), ariaInstructions.join('. '));
+    }
+  }, {
+    key: "setupTooltip",
+    value: function setupTooltip() {
+      var _this3 = this;
+
+      var refresh = function refresh() {
+        var newTooltipText = _this3.column.getColDef().headerTooltip;
+
+        _this3.setTooltip(newTooltipText);
+      };
+
+      refresh();
+      this.addManagedListener(this.eventService, Events.EVENT_NEW_COLUMNS_LOADED, refresh);
+    }
+  }, {
+    key: "setupSort",
+    value: function setupSort() {
+      var _this4 = this;
+
+      var canSort = this.column.getColDef().sortable;
+      var isGroupingZone = this.isGroupingZone();
+
+      if (!canSort || !isGroupingZone) {
+        return;
+      }
+
+      if (!this.gridOptionsWrapper.isRowGroupPanelSuppressSort()) {
+        this.eSortIndicator.setupSort(this.column, true);
+
+        var performSort = function performSort(event) {
+          event.preventDefault();
+
+          var sortUsingCtrl = _this4.gridOptionsWrapper.isMultiSortKeyCtrl();
+
+          var multiSort = sortUsingCtrl ? event.ctrlKey || event.metaKey : event.shiftKey;
+
+          _this4.sortController.progressSort(_this4.column, multiSort, 'uiColumnSorted');
+        };
+
+        this.addGuiEventListener('click', performSort);
+        this.addGuiEventListener('keydown', function (e) {
+          var isEnter = e.key === KeyCode.ENTER;
+
+          if (isEnter && _this4.isGroupingZone()) {
+            performSort(e);
+          }
+        });
+      }
+    }
+  }, {
+    key: "addDragSource",
+    value: function addDragSource() {
+      var _this5 = this;
+
+      var dragSource = {
+        type: DragSourceType.ToolPanel,
+        eElement: this.eDragHandle,
+        defaultIconName: DragAndDropService.ICON_HIDE,
+        getDragItem: function getDragItem() {
+          return _this5.createDragItem();
+        },
+        dragItemName: this.displayName,
+        dragSourceDropTarget: this.dragSourceDropTarget
+      };
+      this.dragAndDropService.addDragSource(dragSource, true);
+      this.addDestroyFunc(function () {
+        return _this5.dragAndDropService.removeDragSource(dragSource);
+      });
+    }
+  }, {
+    key: "createDragItem",
+    value: function createDragItem() {
+      var visibleState = {};
+      visibleState[this.column.getId()] = this.column.isVisible();
+      return {
+        columns: [this.column],
+        visibleState: visibleState
+      };
+    }
+  }, {
+    key: "setupComponents",
+    value: function setupComponents() {
+      this.setTextValue();
+      this.setupRemove();
+
+      if (this.ghost) {
+        this.addCssClass('ag-column-drop-cell-ghost');
+      }
+
+      if (this.isAggregationZone() && !this.gridOptionsWrapper.isFunctionsReadOnly()) {
+        this.addGuiEventListener('click', this.onShowAggFuncSelection.bind(this));
+      }
+    }
+  }, {
+    key: "setupRemove",
+    value: function setupRemove() {
+      var _this6 = this;
+
+      _.setDisplayed(this.eButton, !this.gridOptionsWrapper.isFunctionsReadOnly());
+
+      var agEvent = {
+        type: DropZoneColumnComp.EVENT_COLUMN_REMOVE
+      };
+      this.addGuiEventListener('keydown', function (e) {
+        var isEnter = e.key === KeyCode.ENTER;
+        var isDelete = e.key === KeyCode.DELETE;
+
+        if (isDelete) {
+          e.preventDefault();
+
+          _this6.dispatchEvent(agEvent);
+        }
+
+        if (isEnter && _this6.isAggregationZone() && !_this6.gridOptionsWrapper.isFunctionsReadOnly()) {
+          e.preventDefault();
+
+          _this6.onShowAggFuncSelection();
+        }
+      });
+      this.addManagedListener(this.eButton, 'click', function (mouseEvent) {
+        _this6.dispatchEvent(agEvent);
+
+        mouseEvent.stopPropagation();
+      });
+      var touchListener = new TouchListener(this.eButton);
+      this.addManagedListener(touchListener, TouchListener.EVENT_TAP, function () {
+        _this6.dispatchEvent(agEvent);
+      });
+      this.addDestroyFunc(touchListener.destroy.bind(touchListener));
+    }
+  }, {
+    key: "getColumnAndAggFuncName",
+    value: function getColumnAndAggFuncName() {
+      var name = this.displayName;
+      var aggFuncName = '';
+
+      if (this.isAggregationZone()) {
+        var aggFunc = this.column.getAggFunc(); // if aggFunc is a string, we can use it, but if it's a function, then we swap with 'func'
+
+        var aggFuncString = typeof aggFunc === 'string' ? aggFunc : 'agg';
+        var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+        aggFuncName = localeTextFunc(aggFuncString, aggFuncString);
+      }
+
+      return {
+        name: name,
+        aggFuncName: aggFuncName
+      };
+    }
+  }, {
+    key: "setTextValue",
+    value: function setTextValue() {
+      var _this$getColumnAndAgg2 = this.getColumnAndAggFuncName(),
+          name = _this$getColumnAndAgg2.name,
+          aggFuncName = _this$getColumnAndAgg2.aggFuncName;
+
+      var displayValue = this.isAggregationZone() ? "".concat(aggFuncName, "(").concat(name, ")") : name;
+
+      var displayValueSanitised = _.escapeString(displayValue);
+
+      this.eText.innerHTML = displayValueSanitised;
+    }
+  }, {
+    key: "onShowAggFuncSelection",
+    value: function onShowAggFuncSelection() {
+      var _this7 = this;
+
+      if (this.popupShowing) {
+        return;
+      }
+
+      this.popupShowing = true;
+      var virtualList = new VirtualList('select-agg-func');
+      var rows = this.aggFuncService.getFuncNames(this.column);
+      var eGui = this.getGui();
+      var virtualListGui = virtualList.getGui();
+      virtualList.setModel({
+        getRow: function getRow(index) {
+          return rows[index];
+        },
+        getRowCount: function getRowCount() {
+          return rows.length;
+        }
+      });
+      this.getContext().createBean(virtualList);
+
+      var ePopup = _.loadTemplate(
+      /* html*/
+      "<div class=\"ag-select-agg-func-popup\"></div>");
+
+      ePopup.style.top = '0px';
+      ePopup.style.left = '0px';
+      ePopup.appendChild(virtualListGui); // ePopup.style.height = this.gridOptionsWrapper.getAggFuncPopupHeight() + 'px';
+
+      ePopup.style.width = "".concat(eGui.clientWidth, "px");
+
+      var popupHiddenFunc = function popupHiddenFunc() {
+        _this7.destroyBean(virtualList);
+
+        _this7.popupShowing = false;
+        eGui.focus();
+      };
+
+      var translate = this.gridOptionsWrapper.getLocaleTextFunc();
+      var addPopupRes = this.popupService.addPopup({
+        modal: true,
+        eChild: ePopup,
+        closeOnEsc: true,
+        closedCallback: popupHiddenFunc,
+        ariaLabel: translate('ariaLabelAggregationFunction', 'Aggregation Function')
+      });
+
+      if (addPopupRes) {
+        virtualList.setComponentCreator(this.createAggSelect.bind(this, addPopupRes.hideFunc));
+      }
+
+      virtualList.addGuiEventListener('keydown', function (e) {
+        if (e.key === KeyCode.ENTER || e.key === KeyCode.SPACE) {
+          var row = virtualList.getLastFocusedRow();
+
+          if (row == null) {
+            return;
+          }
+
+          var comp = virtualList.getComponentAt(row);
+
+          if (comp) {
+            comp.selectItem();
+          }
+        }
+      });
+      this.popupService.positionPopupUnderComponent({
+        type: 'aggFuncSelect',
+        eventSource: eGui,
+        ePopup: ePopup,
+        keepWithinBounds: true,
+        column: this.column
+      });
+      virtualList.refresh();
+      var rowToFocus = rows.findIndex(function (r) {
+        return r === _this7.column.getAggFunc();
+      });
+
+      if (rowToFocus === -1) {
+        rowToFocus = 0;
+      }
+
+      virtualList.focusRow(rowToFocus);
+    }
+  }, {
+    key: "createAggSelect",
+    value: function createAggSelect(hidePopup, value) {
+      var _this8 = this;
+
+      var itemSelected = function itemSelected() {
+        hidePopup();
+
+        if (_this8.gridOptionsWrapper.isFunctionsPassive()) {
+          var event = {
+            type: Events.EVENT_COLUMN_AGG_FUNC_CHANGE_REQUEST,
+            columns: [_this8.column],
+            aggFunc: value
+          };
+
+          _this8.eventService.dispatchEvent(event);
+        } else {
+          _this8.columnModel.setColumnAggFunc(_this8.column, value, "toolPanelDragAndDrop");
+        }
+      };
+
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+      var aggFuncString = value.toString();
+      var aggFuncStringTranslated = localeTextFunc(aggFuncString, aggFuncString);
+      var comp = new AggItemComp(itemSelected, aggFuncStringTranslated);
+      return comp;
+    }
+  }, {
+    key: "addElementClasses",
+    value: function addElementClasses(el, suffix) {
+      suffix = suffix ? "-".concat(suffix) : '';
+      var direction = this.horizontal ? 'horizontal' : 'vertical';
+      el.classList.add("ag-column-drop-cell".concat(suffix), "ag-column-drop-".concat(direction, "-cell").concat(suffix));
+    }
+  }, {
+    key: "isAggregationZone",
+    value: function isAggregationZone() {
+      return this.dropZonePurpose === 'aggregation';
+    }
+  }, {
+    key: "isGroupingZone",
+    value: function isGroupingZone() {
+      return this.dropZonePurpose === 'rowGroup';
+    }
+  }]);
+
+  return DropZoneColumnComp;
+}(Component);
+DropZoneColumnComp.EVENT_COLUMN_REMOVE = 'columnRemove';
+DropZoneColumnComp.TEMPLATE = "<span role=\"option\" tabindex=\"0\">\n          <span ref=\"eDragHandle\" class=\"ag-drag-handle ag-column-drop-cell-drag-handle\" role=\"presentation\"></span>\n          <span ref=\"eText\" class=\"ag-column-drop-cell-text\" aria-hidden=\"true\"></span>\n          <ag-sort-indicator ref=\"eSortIndicator\"></ag-sort-indicator>\n          <span ref=\"eButton\" class=\"ag-column-drop-cell-button\" role=\"presentation\"></span>\n        </span>";
+
+__decorate([Autowired('dragAndDropService')], DropZoneColumnComp.prototype, "dragAndDropService", void 0);
+
+__decorate([Autowired('columnModel')], DropZoneColumnComp.prototype, "columnModel", void 0);
+
+__decorate([Autowired('popupService')], DropZoneColumnComp.prototype, "popupService", void 0);
+
+__decorate([Optional('aggFuncService')], DropZoneColumnComp.prototype, "aggFuncService", void 0);
+
+__decorate([Autowired('sortController')], DropZoneColumnComp.prototype, "sortController", void 0);
+
+__decorate([RefSelector('eText')], DropZoneColumnComp.prototype, "eText", void 0);
+
+__decorate([RefSelector('eDragHandle')], DropZoneColumnComp.prototype, "eDragHandle", void 0);
+
+__decorate([RefSelector('eButton')], DropZoneColumnComp.prototype, "eButton", void 0);
+
+__decorate([RefSelector('eSortIndicator')], DropZoneColumnComp.prototype, "eSortIndicator", void 0);
+
+__decorate([PostConstruct], DropZoneColumnComp.prototype, "init", null);
+
+var AggItemComp = /*#__PURE__*/function (_Component2) {
+  _inherits(AggItemComp, _Component2);
+
+  var _super2 = _createSuper(AggItemComp);
+
+  function AggItemComp(itemSelected, value) {
+    var _this9;
+
+    _classCallCheck(this, AggItemComp);
+
+    _this9 = _super2.call(this,
+    /* html */
+    "<div class=\"ag-select-agg-func-item\"/>");
+    _this9.selectItem = itemSelected;
+    _this9.getGui().innerText = value;
+
+    _this9.addGuiEventListener('click', _this9.selectItem);
+
+    return _this9;
+  }
+
+  return _createClass(AggItemComp);
+}(Component);

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

@@ -0,0 +1,11 @@
+import { Component } from "@ag-grid-community/core";
+export declare class GridHeaderDropZones extends Component {
+    private columnModel;
+    private rowGroupComp;
+    private pivotComp;
+    constructor();
+    private postConstruct;
+    private createNorthPanel;
+    private onDropPanelVisible;
+    private onRowGroupChanged;
+}

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

@@ -0,0 +1,108 @@
+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, Component, Constants, Events, PostConstruct, _ } from "@ag-grid-community/core";
+import { RowGroupDropZonePanel } from "./rowGroupDropZonePanel";
+import { PivotDropZonePanel } from "./pivotDropZonePanel";
+export var GridHeaderDropZones = /*#__PURE__*/function (_Component) {
+  _inherits(GridHeaderDropZones, _Component);
+
+  var _super = _createSuper(GridHeaderDropZones);
+
+  function GridHeaderDropZones() {
+    _classCallCheck(this, GridHeaderDropZones);
+
+    return _super.call(this);
+  }
+
+  _createClass(GridHeaderDropZones, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      this.setGui(this.createNorthPanel());
+      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_ROW_GROUP_CHANGED, this.onRowGroupChanged.bind(this));
+      this.addManagedListener(this.eventService, Events.EVENT_NEW_COLUMNS_LOADED, this.onRowGroupChanged.bind(this));
+      this.addManagedListener(this.gridOptionsWrapper, 'rowGroupPanelShow', this.onRowGroupChanged.bind(this));
+      this.onRowGroupChanged();
+    }
+  }, {
+    key: "createNorthPanel",
+    value: function createNorthPanel() {
+      var topPanelGui = document.createElement('div');
+      var dropPanelVisibleListener = this.onDropPanelVisible.bind(this);
+      topPanelGui.classList.add('ag-column-drop-wrapper');
+
+      _.setAriaRole(topPanelGui, 'presentation');
+
+      this.rowGroupComp = new RowGroupDropZonePanel(true);
+      this.createManagedBean(this.rowGroupComp);
+      this.pivotComp = new PivotDropZonePanel(true);
+      this.createManagedBean(this.pivotComp);
+      topPanelGui.appendChild(this.rowGroupComp.getGui());
+      topPanelGui.appendChild(this.pivotComp.getGui());
+      this.addManagedListener(this.rowGroupComp, Component.EVENT_DISPLAYED_CHANGED, dropPanelVisibleListener);
+      this.addManagedListener(this.pivotComp, Component.EVENT_DISPLAYED_CHANGED, dropPanelVisibleListener);
+      this.onDropPanelVisible();
+      return topPanelGui;
+    }
+  }, {
+    key: "onDropPanelVisible",
+    value: function onDropPanelVisible() {
+      var bothDisplayed = this.rowGroupComp.isDisplayed() && this.pivotComp.isDisplayed();
+      this.rowGroupComp.addOrRemoveCssClass('ag-column-drop-horizontal-half-width', bothDisplayed);
+      this.pivotComp.addOrRemoveCssClass('ag-column-drop-horizontal-half-width', bothDisplayed);
+    }
+  }, {
+    key: "onRowGroupChanged",
+    value: function onRowGroupChanged() {
+      if (!this.rowGroupComp) {
+        return;
+      }
+
+      var rowGroupPanelShow = this.gridOptionsWrapper.getRowGroupPanelShow();
+
+      if (rowGroupPanelShow === Constants.ALWAYS) {
+        this.rowGroupComp.setDisplayed(true);
+      } else if (rowGroupPanelShow === Constants.ONLY_WHEN_GROUPING) {
+        var grouping = !this.columnModel.isRowGroupEmpty();
+        this.rowGroupComp.setDisplayed(grouping);
+      } else {
+        this.rowGroupComp.setDisplayed(false);
+      }
+    }
+  }]);
+
+  return GridHeaderDropZones;
+}(Component);
+
+__decorate([Autowired('columnModel')], GridHeaderDropZones.prototype, "columnModel", void 0);
+
+__decorate([PostConstruct], GridHeaderDropZones.prototype, "postConstruct", null);

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

@@ -0,0 +1,17 @@
+import { Column, ITooltipParams, WithoutGridCommon } from "@ag-grid-community/core";
+import { BaseDropZonePanel } from "./baseDropZonePanel";
+export declare class PivotDropZonePanel extends BaseDropZonePanel {
+    private columnModel;
+    private loggerFactory;
+    private dragAndDropService;
+    constructor(horizontal: boolean);
+    private passBeansUp;
+    protected getAriaLabel(): string;
+    getTooltipParams(): WithoutGridCommon<ITooltipParams>;
+    private refresh;
+    private checkVisibility;
+    protected isColumnDroppable(column: Column): boolean;
+    protected updateColumns(columns: Column[]): void;
+    protected getIconName(): string;
+    protected getExistingColumns(): Column[];
+}