@lemon-fe/kits 0.1.136 → 1.0.0-0

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

@@ -0,0 +1,565 @@
+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, Constants, ModuleNames, ModuleRegistry, Optional } from '@ag-grid-community/core';
+
+var MenuItemMapper = /*#__PURE__*/function (_BeanStub) {
+  _inherits(MenuItemMapper, _BeanStub);
+
+  var _super = _createSuper(MenuItemMapper);
+
+  function MenuItemMapper() {
+    _classCallCheck(this, MenuItemMapper);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(MenuItemMapper, [{
+    key: "mapWithStockItems",
+    value: function mapWithStockItems(originalList, column) {
+      var _this = this;
+
+      if (!originalList) {
+        return [];
+      }
+
+      var resultList = [];
+      originalList.forEach(function (menuItemOrString) {
+        var result;
+
+        if (typeof menuItemOrString === 'string') {
+          result = _this.getStockMenuItem(menuItemOrString, column);
+        } else {
+          result = menuItemOrString;
+        } // if no mapping, can happen when module is not loaded but user tries to use module anyway
+
+
+        if (!result) {
+          return;
+        }
+
+        var resultDef = result;
+        var subMenu = resultDef.subMenu;
+
+        if (subMenu && subMenu instanceof Array) {
+          resultDef.subMenu = _this.mapWithStockItems(resultDef.subMenu, column);
+        }
+
+        if (result != null) {
+          resultList.push(result);
+        }
+      });
+      return resultList;
+    }
+  }, {
+    key: "getStockMenuItem",
+    value: function getStockMenuItem(key, column) {
+      var _this2 = this;
+
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+      var skipHeaderOnAutoSize = this.gridOptionsWrapper.isSkipHeaderOnAutoSize();
+
+      switch (key) {
+        case 'pinSubMenu':
+          return {
+            name: localeTextFunc('pinColumn', 'Pin Column'),
+            icon: _.createIconNoSpan('menuPin', this.gridOptionsWrapper, null),
+            subMenu: ['pinLeft', 'pinRight', 'clearPinned']
+          };
+
+        case 'pinLeft':
+          return {
+            name: localeTextFunc('pinLeft', 'Pin Left'),
+            action: function action() {
+              return _this2.columnModel.setColumnPinned(column, Constants.PINNED_LEFT, 'contextMenu');
+            },
+            checked: !!column && column.isPinnedLeft()
+          };
+
+        case 'pinRight':
+          return {
+            name: localeTextFunc('pinRight', 'Pin Right'),
+            action: function action() {
+              return _this2.columnModel.setColumnPinned(column, Constants.PINNED_RIGHT, 'contextMenu');
+            },
+            checked: !!column && column.isPinnedRight()
+          };
+
+        case 'clearPinned':
+          return {
+            name: localeTextFunc('noPin', 'No Pin'),
+            action: function action() {
+              return _this2.columnModel.setColumnPinned(column, null, 'contextMenu');
+            },
+            checked: !!column && !column.isPinned()
+          };
+
+        case 'valueAggSubMenu':
+          if (ModuleRegistry.assertRegistered(ModuleNames.RowGroupingModule, 'Aggregation from Menu')) {
+            return {
+              name: localeTextFunc('valueAggregation', 'Value Aggregation'),
+              icon: _.createIconNoSpan('menuValue', this.gridOptionsWrapper, null),
+              subMenu: this.createAggregationSubMenu(column)
+            };
+          } else {
+            return null;
+          }
+
+        case 'autoSizeThis':
+          return {
+            name: localeTextFunc('autosizeThiscolumn', 'Autosize This Column'),
+            action: function action() {
+              return _this2.columnModel.autoSizeColumn(column, skipHeaderOnAutoSize, 'contextMenu');
+            }
+          };
+
+        case 'autoSizeAll':
+          return {
+            name: localeTextFunc('autosizeAllColumns', 'Autosize All Columns'),
+            action: function action() {
+              return _this2.columnModel.autoSizeAllColumns(skipHeaderOnAutoSize, 'contextMenu');
+            }
+          };
+
+        case 'rowGroup':
+          return {
+            name: localeTextFunc('groupBy', 'Group by') + ' ' + _.escapeString(this.columnModel.getDisplayNameForColumn(column, 'header')),
+            action: function action() {
+              return _this2.columnModel.addRowGroupColumn(column, 'contextMenu');
+            },
+            icon: _.createIconNoSpan('menuAddRowGroup', this.gridOptionsWrapper, null)
+          };
+
+        case 'rowUnGroup':
+          return {
+            name: localeTextFunc('ungroupBy', 'Un-Group by') + ' ' + _.escapeString(this.columnModel.getDisplayNameForColumn(column, 'header')),
+            action: function action() {
+              return _this2.columnModel.removeRowGroupColumn(column, 'contextMenu');
+            },
+            icon: _.createIconNoSpan('menuRemoveRowGroup', this.gridOptionsWrapper, null)
+          };
+
+        case 'resetColumns':
+          return {
+            name: localeTextFunc('resetColumns', 'Reset Columns'),
+            action: function action() {
+              return _this2.columnModel.resetColumnState('contextMenu');
+            }
+          };
+
+        case 'expandAll':
+          return {
+            name: localeTextFunc('expandAll', 'Expand All'),
+            action: function action() {
+              return _this2.gridApi.expandAll();
+            }
+          };
+
+        case 'contractAll':
+          return {
+            name: localeTextFunc('collapseAll', 'Collapse All'),
+            action: function action() {
+              return _this2.gridApi.collapseAll();
+            }
+          };
+
+        case 'copy':
+          if (ModuleRegistry.assertRegistered(ModuleNames.ClipboardModule, 'Copy from Menu')) {
+            return {
+              name: localeTextFunc('copy', 'Copy'),
+              shortcut: localeTextFunc('ctrlC', 'Ctrl+C'),
+              icon: _.createIconNoSpan('clipboardCopy', this.gridOptionsWrapper, null),
+              action: function action() {
+                return _this2.clipboardService.copyToClipboard();
+              }
+            };
+          } else {
+            return null;
+          }
+
+        case 'copyWithHeaders':
+          if (ModuleRegistry.assertRegistered(ModuleNames.ClipboardModule, 'Copy with Headers from Menu')) {
+            return {
+              name: localeTextFunc('copyWithHeaders', 'Copy with Headers'),
+              // shortcut: localeTextFunc('ctrlC','Ctrl+C'),
+              icon: _.createIconNoSpan('clipboardCopy', this.gridOptionsWrapper, null),
+              action: function action() {
+                return _this2.clipboardService.copyToClipboard({
+                  includeHeaders: true
+                });
+              }
+            };
+          } else {
+            return null;
+          }
+
+        case 'copyWithGroupHeaders':
+          if (ModuleRegistry.assertRegistered(ModuleNames.ClipboardModule, 'Copy with Group Headers from Menu')) {
+            return {
+              name: localeTextFunc('copyWithGroupHeaders', 'Copy with Group Headers'),
+              // shortcut: localeTextFunc('ctrlC','Ctrl+C'),
+              icon: _.createIconNoSpan('clipboardCopy', this.gridOptionsWrapper, null),
+              action: function action() {
+                return _this2.clipboardService.copyToClipboard({
+                  includeHeaders: true,
+                  includeGroupHeaders: true
+                });
+              }
+            };
+          } else {
+            return null;
+          }
+
+        case 'paste':
+          if (ModuleRegistry.assertRegistered(ModuleNames.ClipboardModule, 'Paste from Clipboard')) {
+            return {
+              name: localeTextFunc('paste', 'Paste'),
+              shortcut: localeTextFunc('ctrlV', 'Ctrl+V'),
+              disabled: true,
+              icon: _.createIconNoSpan('clipboardPaste', this.gridOptionsWrapper, null),
+              action: function action() {
+                return _this2.clipboardService.pasteFromClipboard();
+              }
+            };
+          } else {
+            return null;
+          }
+
+        case 'export':
+          var exportSubMenuItems = [];
+          var csvModuleLoaded = ModuleRegistry.isRegistered(ModuleNames.CsvExportModule);
+          var excelModuleLoaded = ModuleRegistry.isRegistered(ModuleNames.ExcelExportModule);
+
+          if (!this.gridOptionsWrapper.isSuppressCsvExport() && csvModuleLoaded) {
+            exportSubMenuItems.push('csvExport');
+          }
+
+          if (!this.gridOptionsWrapper.isSuppressExcelExport() && excelModuleLoaded) {
+            exportSubMenuItems.push('excelExport');
+          }
+
+          return {
+            name: localeTextFunc('export', 'Export'),
+            subMenu: exportSubMenuItems,
+            icon: _.createIconNoSpan('save', this.gridOptionsWrapper, null)
+          };
+
+        case 'csvExport':
+          return {
+            name: localeTextFunc('csvExport', 'CSV Export'),
+            icon: _.createIconNoSpan('csvExport', this.gridOptionsWrapper, null),
+            action: function action() {
+              return _this2.gridApi.exportDataAsCsv({});
+            }
+          };
+
+        case 'excelExport':
+          return {
+            name: localeTextFunc('excelExport', 'Excel Export'),
+            icon: _.createIconNoSpan('excelExport', this.gridOptionsWrapper, null),
+            action: function action() {
+              return _this2.gridApi.exportDataAsExcel();
+            }
+          };
+
+        case 'separator':
+          return 'separator';
+
+        default:
+          var chartMenuItem = this.getChartItems(key);
+
+          if (chartMenuItem) {
+            return chartMenuItem;
+          } else {
+            console.warn("AG Grid: unknown menu item type ".concat(key));
+            return null;
+          }
+
+      }
+    }
+  }, {
+    key: "getChartItems",
+    value: function getChartItems(key) {
+      var _this3 = this;
+
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+
+      var pivotChartMenuItem = function pivotChartMenuItem(localeKey, defaultText, chartType) {
+        return {
+          name: localeTextFunc(localeKey, defaultText),
+          action: function action() {
+            return _this3.chartService.createPivotChart({
+              chartType: chartType
+            });
+          }
+        };
+      };
+
+      var rangeChartMenuItem = function rangeChartMenuItem(localeKey, defaultText, chartType) {
+        return {
+          name: localeTextFunc(localeKey, defaultText),
+          action: function action() {
+            return _this3.chartService.createChartFromCurrentRange(chartType);
+          }
+        };
+      };
+
+      switch (key) {
+        case 'pivotChart':
+          return {
+            name: localeTextFunc('pivotChart', 'Pivot Chart'),
+            subMenu: ['pivotColumnChart', 'pivotBarChart', 'pivotPieChart', 'pivotLineChart', 'pivotXYChart', 'pivotAreaChart'],
+            icon: _.createIconNoSpan('chart', this.gridOptionsWrapper, null)
+          };
+
+        case 'chartRange':
+          return {
+            name: localeTextFunc('chartRange', 'Chart Range'),
+            subMenu: ['rangeColumnChart', 'rangeBarChart', 'rangePieChart', 'rangeLineChart', 'rangeXYChart', 'rangeAreaChart', 'rangeHistogramChart', 'rangeCombinationChart'],
+            icon: _.createIconNoSpan('chart', this.gridOptionsWrapper, null)
+          };
+
+        case 'pivotColumnChart':
+          return {
+            name: localeTextFunc('columnChart', 'Column'),
+            subMenu: ['pivotGroupedColumn', 'pivotStackedColumn', 'pivotNormalizedColumn']
+          };
+
+        case 'pivotGroupedColumn':
+          return pivotChartMenuItem('groupedColumn', 'Grouped&lrm;', 'groupedColumn');
+
+        case 'pivotStackedColumn':
+          return pivotChartMenuItem('stackedColumn', 'Stacked&lrm;', 'stackedColumn');
+
+        case 'pivotNormalizedColumn':
+          return pivotChartMenuItem('normalizedColumn', '100% Stacked&lrm;', 'normalizedColumn');
+
+        case 'rangeColumnChart':
+          return {
+            name: localeTextFunc('columnChart', 'Column'),
+            subMenu: ['rangeGroupedColumn', 'rangeStackedColumn', 'rangeNormalizedColumn']
+          };
+
+        case 'rangeGroupedColumn':
+          return rangeChartMenuItem('groupedColumn', 'Grouped&lrm;', 'groupedColumn');
+
+        case 'rangeStackedColumn':
+          return rangeChartMenuItem('stackedColumn', 'Stacked&lrm;', 'stackedColumn');
+
+        case 'rangeNormalizedColumn':
+          return rangeChartMenuItem('normalizedColumn', '100% Stacked&lrm;', 'normalizedColumn');
+
+        case 'pivotBarChart':
+          return {
+            name: localeTextFunc('barChart', 'Bar'),
+            subMenu: ['pivotGroupedBar', 'pivotStackedBar', 'pivotNormalizedBar']
+          };
+
+        case 'pivotGroupedBar':
+          return pivotChartMenuItem('groupedBar', 'Grouped&lrm;', 'groupedBar');
+
+        case 'pivotStackedBar':
+          return pivotChartMenuItem('stackedBar', 'Stacked&lrm;', 'stackedBar');
+
+        case 'pivotNormalizedBar':
+          return pivotChartMenuItem('normalizedBar', '100% Stacked&lrm;', 'normalizedBar');
+
+        case 'rangeBarChart':
+          return {
+            name: localeTextFunc('barChart', 'Bar'),
+            subMenu: ['rangeGroupedBar', 'rangeStackedBar', 'rangeNormalizedBar']
+          };
+
+        case 'rangeGroupedBar':
+          return rangeChartMenuItem('groupedBar', 'Grouped&lrm;', 'groupedBar');
+
+        case 'rangeStackedBar':
+          return rangeChartMenuItem('stackedBar', 'Stacked&lrm;', 'stackedBar');
+
+        case 'rangeNormalizedBar':
+          return rangeChartMenuItem('normalizedBar', '100% Stacked&lrm;', 'normalizedBar');
+
+        case 'pivotPieChart':
+          return {
+            name: localeTextFunc('pieChart', 'Pie'),
+            subMenu: ['pivotPie', 'pivotDoughnut']
+          };
+
+        case 'pivotPie':
+          return pivotChartMenuItem('pie', 'Pie&lrm;', 'pie');
+
+        case 'pivotDoughnut':
+          return pivotChartMenuItem('doughnut', 'Doughnut&lrm;', 'doughnut');
+
+        case 'rangePieChart':
+          return {
+            name: localeTextFunc('pieChart', 'Pie'),
+            subMenu: ['rangePie', 'rangeDoughnut']
+          };
+
+        case 'rangePie':
+          return rangeChartMenuItem('pie', 'Pie&lrm;', 'pie');
+
+        case 'rangeDoughnut':
+          return rangeChartMenuItem('doughnut', 'Doughnut&lrm;', 'doughnut');
+
+        case 'pivotLineChart':
+          return pivotChartMenuItem('line', 'Line&lrm;', 'line');
+
+        case 'rangeLineChart':
+          return rangeChartMenuItem('line', 'Line&lrm;', 'line');
+
+        case 'pivotXYChart':
+          return {
+            name: localeTextFunc('xyChart', 'X Y (Scatter)'),
+            subMenu: ['pivotScatter', 'pivotBubble']
+          };
+
+        case 'pivotScatter':
+          return pivotChartMenuItem('scatter', 'Scatter&lrm;', 'scatter');
+
+        case 'pivotBubble':
+          return pivotChartMenuItem('bubble', 'Bubble&lrm;', 'bubble');
+
+        case 'rangeXYChart':
+          return {
+            name: localeTextFunc('xyChart', 'X Y (Scatter)'),
+            subMenu: ['rangeScatter', 'rangeBubble']
+          };
+
+        case 'rangeScatter':
+          return rangeChartMenuItem('scatter', 'Scatter&lrm;', 'scatter');
+
+        case 'rangeBubble':
+          return rangeChartMenuItem('bubble', 'Bubble&lrm;', 'bubble');
+
+        case 'pivotAreaChart':
+          return {
+            name: localeTextFunc('areaChart', 'Area'),
+            subMenu: ['pivotArea', 'pivotStackedArea', 'pivotNormalizedArea']
+          };
+
+        case 'pivotArea':
+          return pivotChartMenuItem('area', 'Area&lrm;', 'area');
+
+        case 'pivotStackedArea':
+          return pivotChartMenuItem('stackedArea', 'Stacked&lrm;', 'stackedArea');
+
+        case 'pivotNormalizedArea':
+          return pivotChartMenuItem('normalizedArea', '100% Stacked&lrm;', 'normalizedArea');
+
+        case 'rangeAreaChart':
+          return {
+            name: localeTextFunc('areaChart', 'Area'),
+            subMenu: ['rangeArea', 'rangeStackedArea', 'rangeNormalizedArea']
+          };
+
+        case 'rangeArea':
+          return rangeChartMenuItem('area', 'Area&lrm;', 'area');
+
+        case 'rangeStackedArea':
+          return rangeChartMenuItem('stackedArea', 'Stacked&lrm;', 'stackedArea');
+
+        case 'rangeNormalizedArea':
+          return rangeChartMenuItem('normalizedArea', '100% Stacked&lrm;', 'normalizedArea');
+
+        case 'rangeHistogramChart':
+          return rangeChartMenuItem('histogramChart', 'Histogram&lrm;', 'histogram');
+
+        case 'rangeColumnLineCombo':
+          return rangeChartMenuItem('columnLineCombo', 'Column & Line&lrm;', 'columnLineCombo');
+
+        case 'rangeAreaColumnCombo':
+          return rangeChartMenuItem('AreaColumnCombo', 'Area & Column&lrm;', 'areaColumnCombo');
+
+        case 'rangeCombinationChart':
+          return {
+            name: localeTextFunc('combinationChart', 'Combination'),
+            subMenu: ['rangeColumnLineCombo', 'rangeAreaColumnCombo']
+          };
+
+        default:
+          return null;
+      }
+    }
+  }, {
+    key: "createAggregationSubMenu",
+    value: function createAggregationSubMenu(column) {
+      var _this4 = this;
+
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+      var columnToUse;
+
+      if (column.isPrimary()) {
+        columnToUse = column;
+      } else {
+        var pivotValueColumn = column.getColDef().pivotValueColumn;
+        columnToUse = _.exists(pivotValueColumn) ? pivotValueColumn : undefined;
+      }
+
+      var result = [];
+
+      if (columnToUse) {
+        var columnIsAlreadyAggValue = columnToUse.isValueActive();
+        var funcNames = this.aggFuncService.getFuncNames(columnToUse);
+        funcNames.forEach(function (funcName) {
+          result.push({
+            name: localeTextFunc(funcName, funcName),
+            action: function action() {
+              _this4.columnModel.setColumnAggFunc(columnToUse, funcName, 'contextMenu');
+
+              _this4.columnModel.addValueColumn(columnToUse, 'contextMenu');
+            },
+            checked: columnIsAlreadyAggValue && columnToUse.getAggFunc() === funcName
+          });
+        });
+      }
+
+      return result;
+    }
+  }]);
+
+  return MenuItemMapper;
+}(BeanStub);
+
+__decorate([Autowired('columnModel')], MenuItemMapper.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('gridApi')], MenuItemMapper.prototype, 'gridApi', void 0);
+
+__decorate([Optional('clipboardService')], MenuItemMapper.prototype, 'clipboardService', void 0);
+
+__decorate([Optional('aggFuncService')], MenuItemMapper.prototype, 'aggFuncService', void 0);
+
+__decorate([Optional('chartService')], MenuItemMapper.prototype, 'chartService', void 0);
+
+MenuItemMapper = __decorate([Bean('menuItemMapper')], MenuItemMapper);
+export { MenuItemMapper };

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

@@ -0,0 +1,8 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { EnterpriseMenuFactory } from './menu/enterpriseMenu';
+import { ContextMenuFactory } from './menu/contextMenu';
+import { MenuItemMapper } from './menu/menuItemMapper';
+export declare const MenuModule: {
+    moduleName: ModuleNames;
+    beans: (typeof EnterpriseMenuFactory | typeof ContextMenuFactory | typeof MenuItemMapper)[];
+};

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

@@ -0,0 +1,8 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { EnterpriseMenuFactory } from "./menu/enterpriseMenu";
+import { ContextMenuFactory } from "./menu/contextMenu";
+import { MenuItemMapper } from "./menu/menuItemMapper";
+export var MenuModule = {
+  moduleName: ModuleNames.MenuModule,
+  beans: [EnterpriseMenuFactory, ContextMenuFactory, MenuItemMapper]
+};

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

@@ -0,0 +1,4 @@
+export { RowGroupingModule } from './rowGroupingModule';
+export { RowGroupDropZonePanel } from './rowGrouping/columnDropZones/rowGroupDropZonePanel';
+export { ValuesDropZonePanel } from './rowGrouping/columnDropZones/valueDropZonePanel';
+export { PivotDropZonePanel } from './rowGrouping/columnDropZones/pivotDropZonePanel';

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

@@ -0,0 +1,4 @@
+export { RowGroupingModule } from "./rowGroupingModule";
+export { RowGroupDropZonePanel } from "./rowGrouping/columnDropZones/rowGroupDropZonePanel";
+export { ValuesDropZonePanel } from "./rowGrouping/columnDropZones/valueDropZonePanel";
+export { PivotDropZonePanel } from "./rowGrouping/columnDropZones/pivotDropZonePanel";

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

@@ -0,0 +1,23 @@
+import { BeanStub, Column, IAggFunc, IAggFuncService } from '@ag-grid-community/core';
+export declare class AggFuncService extends BeanStub implements IAggFuncService {
+    private static AGG_SUM;
+    private static AGG_FIRST;
+    private static AGG_LAST;
+    private static AGG_MIN;
+    private static AGG_MAX;
+    private static AGG_COUNT;
+    private static AGG_AVG;
+    private aggFuncsMap;
+    private initialised;
+    private init;
+    private initialiseWithDefaultAggregations;
+    private isAggFuncPossible;
+    getDefaultAggFunc(column: Column): string | null;
+    addAggFuncs(aggFuncs?: {
+        [key: string]: IAggFunc;
+    }): void;
+    addAggFunc(key: string, aggFunc: IAggFunc): void;
+    getAggFunc(name: string): IAggFunc;
+    getFuncNames(column: Column): string[];
+    clear(): void;
+}