@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/menu/menu/enterpriseMenu.js

@@ -0,0 +1,639 @@
+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, Column, Constants, ModuleNames, ModuleRegistry, PostConstruct, AgPromise, TabbedLayout, AgMenuList, AgMenuItemComponent } from '@ag-grid-community/core';
+import { PrimaryColsPanel } from "../../column-tool-panel";
+
+var EnterpriseMenuFactory = /*#__PURE__*/function (_BeanStub) {
+  _inherits(EnterpriseMenuFactory, _BeanStub);
+
+  var _super = _createSuper(EnterpriseMenuFactory);
+
+  function EnterpriseMenuFactory() {
+    _classCallCheck(this, EnterpriseMenuFactory);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(EnterpriseMenuFactory, [{
+    key: "hideActiveMenu",
+    value: function hideActiveMenu() {
+      this.destroyBean(this.activeMenu);
+    }
+  }, {
+    key: "showMenuAfterMouseEvent",
+    value: function showMenuAfterMouseEvent(column, mouseEvent, defaultTab) {
+      var _this = this;
+
+      this.showMenu(column, function (menu) {
+        var ePopup = menu.getGui();
+
+        _this.popupService.positionPopupUnderMouseEvent({
+          type: 'columnMenu',
+          column: column,
+          mouseEvent: mouseEvent,
+          ePopup: ePopup
+        });
+
+        if (defaultTab) {
+          menu.showTab(defaultTab);
+        }
+      }, 'columnMenu', defaultTab, undefined, mouseEvent.target);
+    }
+  }, {
+    key: "showMenuAfterButtonClick",
+    value: function showMenuAfterButtonClick(column, eventSource, containerType, defaultTab, restrictToTabs) {
+      var _this2 = this;
+
+      var multiplier = -1;
+      var alignSide = 'left';
+
+      if (this.gridOptionsWrapper.isEnableRtl()) {
+        multiplier = 1;
+        alignSide = 'right';
+      }
+
+      this.showMenu(column, function (menu) {
+        var ePopup = menu.getGui();
+
+        _this2.popupService.positionPopupUnderComponent({
+          type: containerType,
+          column: column,
+          eventSource: eventSource,
+          ePopup: ePopup,
+          alignSide: alignSide,
+          nudgeX: 9 * multiplier,
+          nudgeY: -23,
+          keepWithinBounds: true
+        });
+
+        if (defaultTab) {
+          menu.showTab(defaultTab);
+        }
+      }, containerType, defaultTab, restrictToTabs, eventSource);
+    }
+  }, {
+    key: "showMenu",
+    value: function showMenu(column, _positionCallback, containerType, defaultTab, restrictToTabs, eventSource) {
+      var _this3 = this;
+
+      var menu = this.createBean(new EnterpriseMenu(column, this.lastSelectedTab, restrictToTabs));
+      var eMenuGui = menu.getGui();
+      var currentHeaderPosition = this.focusService.getFocusedHeader();
+      var currentColumnIndex = this.columnModel.getAllDisplayedColumns().indexOf(column);
+      var anchorToElement = eventSource || this.ctrlsService.getGridBodyCtrl().getGui();
+      var closedFuncs = [];
+      closedFuncs.push(function (e) {
+        _this3.destroyBean(menu);
+
+        column.setMenuVisible(false, 'contextMenu');
+        var isKeyboardEvent = e instanceof KeyboardEvent;
+
+        if (isKeyboardEvent && eventSource) {
+          if (_.isVisible(eventSource)) {
+            var focusableEl = _this3.focusService.findTabbableParent(eventSource);
+
+            if (focusableEl) {
+              if (column) {
+                _this3.headerNavigationService.scrollToColumn(column);
+              }
+
+              focusableEl.focus();
+            }
+          } // if the focusEl is no longer in the DOM, we try to focus
+          // the header that is closest to the previous header position
+          else if (currentHeaderPosition && currentColumnIndex !== -1) {
+            var allColumns = _this3.columnModel.getAllDisplayedColumns();
+
+            var columnToFocus = allColumns[currentColumnIndex] || _.last(allColumns);
+
+            if (columnToFocus) {
+              _this3.focusService.focusHeaderPosition({
+                headerPosition: {
+                  headerRowIndex: currentHeaderPosition.headerRowIndex,
+                  column: columnToFocus
+                }
+              });
+            }
+          }
+        }
+      });
+      var translate = this.gridOptionsWrapper.getLocaleTextFunc(); // need to show filter before positioning, as only after filter
+      // is visible can we find out what the width of it is
+
+      var addPopupRes = this.popupService.addPopup({
+        modal: true,
+        eChild: eMenuGui,
+        closeOnEsc: true,
+        closedCallback: function closedCallback(e) {
+          closedFuncs.forEach(function (f) {
+            return f(e);
+          });
+        },
+        afterGuiAttached: function afterGuiAttached(params) {
+          return menu.afterGuiAttached(Object.assign({}, {
+            container: containerType
+          }, params));
+        },
+        positionCallback: function positionCallback() {
+          return _positionCallback(menu);
+        },
+        anchorToElement: anchorToElement,
+        ariaLabel: translate('ariaLabelColumnMenu', 'Column Menu')
+      });
+
+      if (addPopupRes) {
+        // if user starts showing / hiding columns, or otherwise move the underlying column
+        // for this menu, we want to stop tracking the menu with the column position. otherwise
+        // the menu would move as the user is using the columns tab inside the menu.
+        var stopAnchoringPromise = addPopupRes.stopAnchoringPromise;
+
+        if (stopAnchoringPromise) {
+          stopAnchoringPromise.then(function (stopAnchoringFunc) {
+            column.addEventListener(Column.EVENT_LEFT_CHANGED, stopAnchoringFunc);
+            column.addEventListener(Column.EVENT_VISIBLE_CHANGED, stopAnchoringFunc);
+            closedFuncs.push(function () {
+              column.removeEventListener(Column.EVENT_LEFT_CHANGED, stopAnchoringFunc);
+              column.removeEventListener(Column.EVENT_VISIBLE_CHANGED, stopAnchoringFunc);
+            });
+          });
+        }
+      }
+
+      if (!defaultTab) {
+        menu.showTabBasedOnPreviousSelection(); // reposition the menu because the method above could load
+        // an element that is bigger than enterpriseMenu header.
+
+        _positionCallback(menu);
+      }
+
+      menu.addEventListener(EnterpriseMenu.EVENT_TAB_SELECTED, function (event) {
+        _this3.lastSelectedTab = event.key;
+      });
+      column.setMenuVisible(true, 'contextMenu');
+      this.activeMenu = menu;
+      menu.addEventListener(BeanStub.EVENT_DESTROYED, function () {
+        if (_this3.activeMenu === menu) {
+          _this3.activeMenu = null;
+        }
+      });
+    }
+  }, {
+    key: "isMenuEnabled",
+    value: function isMenuEnabled(column) {
+      return column.getMenuTabs(EnterpriseMenu.TABS_DEFAULT).length > 0;
+    }
+  }]);
+
+  return EnterpriseMenuFactory;
+}(BeanStub);
+
+__decorate([Autowired('popupService')], EnterpriseMenuFactory.prototype, 'popupService', void 0);
+
+__decorate([Autowired('focusService')], EnterpriseMenuFactory.prototype, 'focusService', void 0);
+
+__decorate([Autowired('headerNavigationService')], EnterpriseMenuFactory.prototype, 'headerNavigationService', void 0);
+
+__decorate([Autowired('ctrlsService')], EnterpriseMenuFactory.prototype, 'ctrlsService', void 0);
+
+__decorate([Autowired('columnModel')], EnterpriseMenuFactory.prototype, 'columnModel', void 0);
+
+EnterpriseMenuFactory = __decorate([Bean('menuFactory')], EnterpriseMenuFactory);
+export { EnterpriseMenuFactory };
+export var EnterpriseMenu = /*#__PURE__*/function (_BeanStub2) {
+  _inherits(EnterpriseMenu, _BeanStub2);
+
+  var _super2 = _createSuper(EnterpriseMenu);
+
+  function EnterpriseMenu(column, initialSelection, restrictTo) {
+    var _this4;
+
+    _classCallCheck(this, EnterpriseMenu);
+
+    _this4 = _super2.call(this);
+    _this4.tabFactories = {};
+    _this4.includeChecks = {};
+    _this4.column = column;
+    _this4.initialSelection = initialSelection;
+    _this4.tabFactories[EnterpriseMenu.TAB_GENERAL] = _this4.createMainPanel.bind(_assertThisInitialized(_this4));
+    _this4.tabFactories[EnterpriseMenu.TAB_FILTER] = _this4.createFilterPanel.bind(_assertThisInitialized(_this4));
+    _this4.tabFactories[EnterpriseMenu.TAB_COLUMNS] = _this4.createColumnsPanel.bind(_assertThisInitialized(_this4));
+
+    _this4.includeChecks[EnterpriseMenu.TAB_GENERAL] = function () {
+      return true;
+    };
+
+    _this4.includeChecks[EnterpriseMenu.TAB_FILTER] = function () {
+      return column.isFilterAllowed();
+    };
+
+    _this4.includeChecks[EnterpriseMenu.TAB_COLUMNS] = function () {
+      return true;
+    };
+
+    _this4.restrictTo = restrictTo;
+    return _this4;
+  }
+
+  _createClass(EnterpriseMenu, [{
+    key: "init",
+    value: function init() {
+      var _this5 = this;
+
+      var tabs = this.getTabsToCreate().map(function (name) {
+        return _this5.createTab(name);
+      });
+      this.tabbedLayout = new TabbedLayout({
+        items: tabs,
+        cssClass: 'ag-menu',
+        onActiveItemClicked: this.onHidePopup.bind(this),
+        onItemClicked: this.onTabItemClicked.bind(this)
+      });
+      this.createBean(this.tabbedLayout);
+
+      if (this.mainMenuList) {
+        this.mainMenuList.setParentComponent(this.tabbedLayout);
+      }
+    }
+  }, {
+    key: "getTabsToCreate",
+    value: function getTabsToCreate() {
+      var _this6 = this;
+
+      if (this.restrictTo) {
+        return this.restrictTo;
+      }
+
+      return this.column.getMenuTabs(EnterpriseMenu.TABS_DEFAULT).filter(function (tabName) {
+        return _this6.isValidMenuTabItem(tabName);
+      }).filter(function (tabName) {
+        return _this6.isNotSuppressed(tabName);
+      }).filter(function (tabName) {
+        return _this6.isModuleLoaded(tabName);
+      });
+    }
+  }, {
+    key: "isModuleLoaded",
+    value: function isModuleLoaded(menuTabName) {
+      if (menuTabName === EnterpriseMenu.TAB_COLUMNS) {
+        return ModuleRegistry.isRegistered(ModuleNames.ColumnToolPanelModule);
+      }
+
+      return true;
+    }
+  }, {
+    key: "isValidMenuTabItem",
+    value: function isValidMenuTabItem(menuTabName) {
+      var isValid = true;
+      var itemsToConsider = EnterpriseMenu.TABS_DEFAULT;
+
+      if (this.restrictTo != null) {
+        isValid = this.restrictTo.indexOf(menuTabName) > -1;
+        itemsToConsider = this.restrictTo;
+      }
+
+      isValid = isValid && EnterpriseMenu.TABS_DEFAULT.indexOf(menuTabName) > -1;
+
+      if (!isValid) {
+        console.warn("AG Grid: Trying to render an invalid menu item '".concat(menuTabName, "'. Check that your 'menuTabs' contains one of [").concat(itemsToConsider, "]"));
+      }
+
+      return isValid;
+    }
+  }, {
+    key: "isNotSuppressed",
+    value: function isNotSuppressed(menuTabName) {
+      return this.includeChecks[menuTabName]();
+    }
+  }, {
+    key: "createTab",
+    value: function createTab(name) {
+      return this.tabFactories[name]();
+    }
+  }, {
+    key: "showTabBasedOnPreviousSelection",
+    value: function showTabBasedOnPreviousSelection() {
+      // show the tab the user was on last time they had a menu open
+      this.showTab(this.initialSelection);
+    }
+  }, {
+    key: "showTab",
+    value: function showTab(toShow) {
+      if (this.tabItemColumns && toShow === EnterpriseMenu.TAB_COLUMNS) {
+        this.tabbedLayout.showItem(this.tabItemColumns);
+      } else if (this.tabItemFilter && toShow === EnterpriseMenu.TAB_FILTER) {
+        this.tabbedLayout.showItem(this.tabItemFilter);
+      } else if (this.tabItemGeneral && toShow === EnterpriseMenu.TAB_GENERAL) {
+        this.tabbedLayout.showItem(this.tabItemGeneral);
+      } else {
+        this.tabbedLayout.showFirstItem();
+      }
+    }
+  }, {
+    key: "onTabItemClicked",
+    value: function onTabItemClicked(event) {
+      var key = null;
+
+      switch (event.item) {
+        case this.tabItemColumns:
+          key = EnterpriseMenu.TAB_COLUMNS;
+          break;
+
+        case this.tabItemFilter:
+          key = EnterpriseMenu.TAB_FILTER;
+          break;
+
+        case this.tabItemGeneral:
+          key = EnterpriseMenu.TAB_GENERAL;
+          break;
+      }
+
+      if (key) {
+        this.activateTab(key);
+      }
+    }
+  }, {
+    key: "activateTab",
+    value: function activateTab(tab) {
+      var ev = {
+        type: EnterpriseMenu.EVENT_TAB_SELECTED,
+        key: tab
+      };
+      this.dispatchEvent(ev);
+    }
+  }, {
+    key: "getMenuItems",
+    value: function getMenuItems() {
+      var defaultMenuOptions = this.getDefaultMenuOptions();
+      var result;
+      var userFunc = this.gridOptionsWrapper.getMainMenuItemsFunc();
+
+      if (userFunc) {
+        result = userFunc({
+          column: this.column,
+          defaultItems: defaultMenuOptions
+        });
+      } else {
+        result = defaultMenuOptions;
+      } // GUI looks weird when two separators are side by side. this can happen accidentally
+      // if we remove items from the menu then two separators can edit up adjacent.
+
+
+      _.removeRepeatsFromArray(result, EnterpriseMenu.MENU_ITEM_SEPARATOR);
+
+      return result;
+    }
+  }, {
+    key: "getDefaultMenuOptions",
+    value: function getDefaultMenuOptions() {
+      var result = [];
+      var allowPinning = !this.column.getColDef().lockPinned;
+      var rowGroupCount = this.columnModel.getRowGroupColumns().length;
+      var doingGrouping = rowGroupCount > 0;
+      var groupedByThisColumn = this.columnModel.getRowGroupColumns().indexOf(this.column) >= 0;
+      var allowValue = this.column.isAllowValue();
+      var allowRowGroup = this.column.isAllowRowGroup();
+      var isPrimary = this.column.isPrimary();
+      var pivotModeOn = this.columnModel.isPivotMode();
+      var isInMemoryRowModel = this.rowModel.getType() === Constants.ROW_MODEL_TYPE_CLIENT_SIDE;
+      var usingTreeData = this.gridOptionsWrapper.isTreeData();
+      var allowValueAgg = // if primary, then only allow aggValue if grouping and it's a value columns
+      isPrimary && doingGrouping && allowValue || // secondary columns can always have aggValue, as it means it's a pivot value column
+      !isPrimary;
+
+      if (allowPinning) {
+        result.push('pinSubMenu');
+      }
+
+      if (allowValueAgg) {
+        result.push('valueAggSubMenu');
+      }
+
+      if (allowPinning || allowValueAgg) {
+        result.push(EnterpriseMenu.MENU_ITEM_SEPARATOR);
+      }
+
+      result.push('autoSizeThis');
+      result.push('autoSizeAll');
+      result.push(EnterpriseMenu.MENU_ITEM_SEPARATOR);
+
+      if (allowRowGroup && this.column.isPrimary()) {
+        if (groupedByThisColumn) {
+          result.push('rowUnGroup');
+        } else {
+          result.push('rowGroup');
+        }
+      }
+
+      result.push(EnterpriseMenu.MENU_ITEM_SEPARATOR);
+      result.push('resetColumns'); // only add grouping expand/collapse if grouping in the InMemoryRowModel
+      // if pivoting, we only have expandable groups if grouping by 2 or more columns
+      // as the lowest level group is not expandable while pivoting.
+      // if not pivoting, then any active row group can be expanded.
+
+      var allowExpandAndContract = isInMemoryRowModel && (usingTreeData || rowGroupCount > (pivotModeOn ? 1 : 0));
+
+      if (allowExpandAndContract) {
+        result.push('expandAll');
+        result.push('contractAll');
+      }
+
+      return result;
+    }
+  }, {
+    key: "createMainPanel",
+    value: function createMainPanel() {
+      this.mainMenuList = this.createManagedBean(new AgMenuList());
+      var menuItems = this.getMenuItems();
+      var menuItemsMapped = this.menuItemMapper.mapWithStockItems(menuItems, this.column);
+      this.mainMenuList.addMenuItems(menuItemsMapped);
+      this.mainMenuList.addEventListener(AgMenuItemComponent.EVENT_MENU_ITEM_SELECTED, this.onHidePopup.bind(this));
+      this.tabItemGeneral = {
+        title: _.createIconNoSpan('menu', this.gridOptionsWrapper, this.column),
+        titleLabel: EnterpriseMenu.TAB_GENERAL.replace('MenuTab', ''),
+        bodyPromise: AgPromise.resolve(this.mainMenuList.getGui()),
+        name: EnterpriseMenu.TAB_GENERAL
+      };
+      return this.tabItemGeneral;
+    }
+  }, {
+    key: "onHidePopup",
+    value: function onHidePopup(event) {
+      var keyboardEvent;
+
+      if (event && event.event && event.event instanceof KeyboardEvent) {
+        keyboardEvent = event.event;
+      }
+
+      this.hidePopupFunc(keyboardEvent && {
+        keyboardEvent: keyboardEvent
+      }); // this method only gets called when the menu was closed by selection an option
+      // in this case we highlight the cell that was previously highlighted
+
+      var focusedCell = this.focusService.getFocusedCell();
+      var eDocument = this.gridOptionsWrapper.getDocument();
+
+      if (eDocument.activeElement === eDocument.body && focusedCell) {
+        var rowIndex = focusedCell.rowIndex,
+            rowPinned = focusedCell.rowPinned,
+            column = focusedCell.column;
+        this.focusService.setFocusedCell({
+          rowIndex: rowIndex,
+          column: column,
+          rowPinned: rowPinned,
+          forceBrowserFocus: true,
+          preventScrollOnBrowserFocus: true
+        });
+      }
+    }
+  }, {
+    key: "createFilterPanel",
+    value: function createFilterPanel() {
+      var _a;
+
+      var filterWrapper = this.filterManager.getOrCreateFilterWrapper(this.column, 'COLUMN_MENU');
+
+      if (!filterWrapper) {
+        throw new Error('AG Grid - Unable to instantiate filter');
+      }
+
+      var afterFilterAttachedCallback = function afterFilterAttachedCallback(params) {
+        var _a;
+
+        if (!((_a = filterWrapper) === null || _a === void 0 ? void 0 : _a.filterPromise)) {
+          return;
+        } // slightly odd block this - this promise will always have been resolved by the time it gets here, so won't be
+        // async (_unless_ in react or similar, but if so why not encountered before now?).
+        // I'd suggest a future improvement would be to remove/replace this promise as this block just wont work if it is
+        // async and is confusing if you don't have this context
+
+
+        filterWrapper.filterPromise.then(function (filter) {
+          if (filter && filter.afterGuiAttached) {
+            filter.afterGuiAttached(params);
+          }
+        });
+      };
+
+      this.tabItemFilter = {
+        title: _.createIconNoSpan('filter', this.gridOptionsWrapper, this.column),
+        titleLabel: EnterpriseMenu.TAB_FILTER.replace('MenuTab', ''),
+        bodyPromise: (_a = filterWrapper) === null || _a === void 0 ? void 0 : _a.guiPromise,
+        afterAttachedCallback: afterFilterAttachedCallback,
+        name: EnterpriseMenu.TAB_FILTER
+      };
+      return this.tabItemFilter;
+    }
+  }, {
+    key: "createColumnsPanel",
+    value: function createColumnsPanel() {
+      var eWrapperDiv = document.createElement('div');
+      eWrapperDiv.classList.add('ag-menu-column-select-wrapper');
+      this.columnSelectPanel = this.createManagedBean(new PrimaryColsPanel());
+      var columnsMenuParams = this.column.getColDef().columnsMenuParams;
+
+      if (!columnsMenuParams) {
+        columnsMenuParams = {};
+      }
+
+      this.columnSelectPanel.init(false, {
+        suppressColumnMove: false,
+        suppressValues: false,
+        suppressPivots: false,
+        suppressRowGroups: false,
+        suppressPivotMode: false,
+        contractColumnSelection: !!columnsMenuParams.contractColumnSelection,
+        suppressColumnExpandAll: !!columnsMenuParams.suppressColumnExpandAll,
+        suppressColumnFilter: !!columnsMenuParams.suppressColumnFilter,
+        suppressColumnSelectAll: !!columnsMenuParams.suppressColumnSelectAll,
+        suppressSyncLayoutWithGrid: !!columnsMenuParams.suppressSyncLayoutWithGrid,
+        api: this.gridApi,
+        columnApi: this.columnApi,
+        context: this.gridOptionsWrapper.getContext()
+      }, 'columnMenu');
+      var columnSelectPanelGui = this.columnSelectPanel.getGui();
+      columnSelectPanelGui.classList.add('ag-menu-column-select');
+      eWrapperDiv.appendChild(columnSelectPanelGui);
+      this.tabItemColumns = {
+        title: _.createIconNoSpan('columns', this.gridOptionsWrapper, this.column),
+        titleLabel: EnterpriseMenu.TAB_COLUMNS.replace('MenuTab', ''),
+        bodyPromise: AgPromise.resolve(eWrapperDiv),
+        name: EnterpriseMenu.TAB_COLUMNS
+      };
+      return this.tabItemColumns;
+    }
+  }, {
+    key: "afterGuiAttached",
+    value: function afterGuiAttached(params) {
+      var container = params.container,
+          hidePopup = params.hidePopup;
+      this.tabbedLayout.setAfterAttachedParams({
+        container: container,
+        hidePopup: hidePopup
+      });
+
+      if (hidePopup) {
+        this.hidePopupFunc = hidePopup;
+        this.addDestroyFunc(hidePopup);
+      }
+    }
+  }, {
+    key: "getGui",
+    value: function getGui() {
+      return this.tabbedLayout.getGui();
+    }
+  }]);
+
+  return EnterpriseMenu;
+}(BeanStub);
+EnterpriseMenu.EVENT_TAB_SELECTED = 'tabSelected';
+EnterpriseMenu.TAB_FILTER = 'filterMenuTab';
+EnterpriseMenu.TAB_GENERAL = 'generalMenuTab';
+EnterpriseMenu.TAB_COLUMNS = 'columnsMenuTab';
+EnterpriseMenu.TABS_DEFAULT = [EnterpriseMenu.TAB_GENERAL, EnterpriseMenu.TAB_FILTER, EnterpriseMenu.TAB_COLUMNS];
+EnterpriseMenu.MENU_ITEM_SEPARATOR = 'separator';
+
+__decorate([Autowired('columnModel')], EnterpriseMenu.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('filterManager')], EnterpriseMenu.prototype, 'filterManager', void 0);
+
+__decorate([Autowired('gridApi')], EnterpriseMenu.prototype, 'gridApi', void 0);
+
+__decorate([Autowired('columnApi')], EnterpriseMenu.prototype, 'columnApi', void 0);
+
+__decorate([Autowired('menuItemMapper')], EnterpriseMenu.prototype, 'menuItemMapper', void 0);
+
+__decorate([Autowired('rowModel')], EnterpriseMenu.prototype, 'rowModel', void 0);
+
+__decorate([Autowired('focusService')], EnterpriseMenu.prototype, 'focusService', void 0);
+
+__decorate([PostConstruct], EnterpriseMenu.prototype, 'init', null);

package/es/components/DataGrid/modules/menu/menu/menuItemMapper.d.ts

@@ -0,0 +1,15 @@
+import { BeanStub, Column, MenuItemDef } from '@ag-grid-community/core';
+export declare class MenuItemMapper extends BeanStub {
+  private columnModel;
+  private gridApi;
+  private clipboardService;
+  private aggFuncService;
+  private chartService;
+  mapWithStockItems(
+    originalList: (MenuItemDef | string)[],
+    column: Column | null,
+  ): (MenuItemDef | string)[];
+  private getStockMenuItem;
+  private getChartItems;
+  private createAggregationSubMenu;
+}