@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/column-tool-panel/columnToolPanel/toolPanelContextMenu.js

@@ -0,0 +1,322 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+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 { AgMenuItemComponent, AgMenuList, Autowired, Column, Component, PostConstruct, ProvidedColumnGroup, _ } from '@ag-grid-community/core';
+export var ToolPanelContextMenu = /*#__PURE__*/function (_Component) {
+  _inherits(ToolPanelContextMenu, _Component);
+
+  var _super = _createSuper(ToolPanelContextMenu);
+
+  function ToolPanelContextMenu(column, mouseEvent, parentEl) {
+    var _this;
+
+    _classCallCheck(this, ToolPanelContextMenu);
+
+    _this = _super.call(this,
+    /* html */
+    "<div class=\"ag-menu\"></div>");
+    _this.column = column;
+    _this.mouseEvent = mouseEvent;
+    _this.parentEl = parentEl;
+    _this.displayName = null;
+    return _this;
+  }
+
+  _createClass(ToolPanelContextMenu, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      this.initializeProperties(this.column);
+      this.buildMenuItemMap();
+
+      if (this.column instanceof Column) {
+        this.displayName = this.columnModel.getDisplayNameForColumn(this.column, 'columnToolPanel');
+      } else {
+        this.displayName = this.columnModel.getDisplayNameForProvidedColumnGroup(null, this.column, 'columnToolPanel');
+      }
+
+      if (this.isActive()) {
+        this.mouseEvent.preventDefault();
+        this.displayContextMenu();
+      }
+    }
+  }, {
+    key: "initializeProperties",
+    value: function initializeProperties(column) {
+      if (column instanceof ProvidedColumnGroup) {
+        this.columns = column.getLeafColumns();
+      } else {
+        this.columns = [column];
+      }
+
+      this.allowGrouping = this.columns.some(function (col) {
+        return col.isPrimary() && col.isAllowRowGroup();
+      });
+      this.allowValues = this.columns.some(function (col) {
+        return col.isPrimary() && col.isAllowValue();
+      });
+      this.allowPivoting = this.columnModel.isPivotMode() && this.columns.some(function (col) {
+        return col.isPrimary() && col.isAllowPivot();
+      });
+    }
+  }, {
+    key: "buildMenuItemMap",
+    value: function buildMenuItemMap() {
+      var _this2 = this;
+
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+      this.menuItemMap = new Map();
+      this.menuItemMap.set('rowGroup', {
+        allowedFunction: function allowedFunction(col) {
+          return col.isPrimary() && col.isAllowRowGroup();
+        },
+        activeFunction: function activeFunction(col) {
+          return col.isRowGroupActive();
+        },
+        activateLabel: function activateLabel() {
+          return "".concat(localeTextFunc('groupBy', 'Group by'), " ").concat(_this2.displayName);
+        },
+        deactivateLabel: function deactivateLabel() {
+          return "".concat(localeTextFunc('ungroupBy', 'Un-Group by'), " ").concat(_this2.displayName);
+        },
+        activateFunction: function activateFunction() {
+          var groupedColumns = _this2.columnModel.getRowGroupColumns();
+
+          _this2.columnModel.setRowGroupColumns(_this2.addColumnsToList(groupedColumns), 'toolPanelUi');
+        },
+        deActivateFunction: function deActivateFunction() {
+          var groupedColumns = _this2.columnModel.getRowGroupColumns();
+
+          _this2.columnModel.setRowGroupColumns(_this2.removeColumnsFromList(groupedColumns), 'toolPanelUi');
+        },
+        addIcon: 'menuAddRowGroup',
+        removeIcon: 'menuRemoveRowGroup'
+      });
+      this.menuItemMap.set('value', {
+        allowedFunction: function allowedFunction(col) {
+          return col.isPrimary() && col.isAllowValue();
+        },
+        activeFunction: function activeFunction(col) {
+          return col.isValueActive();
+        },
+        activateLabel: function activateLabel() {
+          return localeTextFunc('addToValues', "Add ".concat(_this2.displayName, " to values"), [_this2.displayName]);
+        },
+        deactivateLabel: function deactivateLabel() {
+          return localeTextFunc('removeFromValues', "Remove ".concat(_this2.displayName, " from values"), [_this2.displayName]);
+        },
+        activateFunction: function activateFunction() {
+          var valueColumns = _this2.columnModel.getValueColumns();
+
+          _this2.columnModel.setValueColumns(_this2.addColumnsToList(valueColumns), 'toolPanelUi');
+        },
+        deActivateFunction: function deActivateFunction() {
+          var valueColumns = _this2.columnModel.getValueColumns();
+
+          _this2.columnModel.setValueColumns(_this2.removeColumnsFromList(valueColumns), 'toolPanelUi');
+        },
+        addIcon: 'valuePanel',
+        removeIcon: 'valuePanel'
+      });
+      this.menuItemMap.set('pivot', {
+        allowedFunction: function allowedFunction(col) {
+          return _this2.columnModel.isPivotMode() && col.isPrimary() && col.isAllowPivot();
+        },
+        activeFunction: function activeFunction(col) {
+          return col.isPivotActive();
+        },
+        activateLabel: function activateLabel() {
+          return localeTextFunc('addToLabels', "Add ".concat(_this2.displayName, " to labels"), [_this2.displayName]);
+        },
+        deactivateLabel: function deactivateLabel() {
+          return localeTextFunc('removeFromLabels', "Remove ".concat(_this2.displayName, " from labels"), [_this2.displayName]);
+        },
+        activateFunction: function activateFunction() {
+          var pivotColumns = _this2.columnModel.getPivotColumns();
+
+          _this2.columnModel.setPivotColumns(_this2.addColumnsToList(pivotColumns), 'toolPanelUi');
+        },
+        deActivateFunction: function deActivateFunction() {
+          var pivotColumns = _this2.columnModel.getPivotColumns();
+
+          _this2.columnModel.setPivotColumns(_this2.removeColumnsFromList(pivotColumns), 'toolPanelUi');
+        },
+        addIcon: 'pivotPanel',
+        removeIcon: 'pivotPanel'
+      });
+    }
+  }, {
+    key: "addColumnsToList",
+    value: function addColumnsToList(columnList) {
+      return _toConsumableArray(columnList).concat(this.columns.filter(function (col) {
+        return columnList.indexOf(col) === -1;
+      }));
+    }
+  }, {
+    key: "removeColumnsFromList",
+    value: function removeColumnsFromList(columnList) {
+      var _this3 = this;
+
+      return columnList.filter(function (col) {
+        return _this3.columns.indexOf(col) === -1;
+      });
+    }
+  }, {
+    key: "displayContextMenu",
+    value: function displayContextMenu() {
+      var _this4 = this;
+
+      var eGui = this.getGui();
+      var menuList = this.createBean(new AgMenuList());
+      var menuItemsMapped = this.getMappedMenuItems();
+      var localeTextFunc = this.gridOptionsWrapper.getLocaleTextFunc();
+
+      var hideFunc = function hideFunc() {};
+
+      eGui.appendChild(menuList.getGui());
+      menuList.addMenuItems(menuItemsMapped);
+      menuList.addManagedListener(menuList, AgMenuItemComponent.EVENT_MENU_ITEM_SELECTED, function () {
+        _this4.parentEl.focus();
+
+        hideFunc();
+      });
+      var addPopupRes = this.popupService.addPopup({
+        modal: true,
+        eChild: eGui,
+        closeOnEsc: true,
+        afterGuiAttached: function afterGuiAttached() {
+          return _this4.focusService.focusInto(menuList.getGui());
+        },
+        ariaLabel: localeTextFunc('ariaLabelContextMenu', 'Context Menu'),
+        closedCallback: function closedCallback(e) {
+          if (e instanceof KeyboardEvent) {
+            _this4.parentEl.focus();
+          }
+
+          _this4.destroyBean(menuList);
+        }
+      });
+
+      if (addPopupRes) {
+        hideFunc = addPopupRes.hideFunc;
+      }
+
+      this.popupService.positionPopupUnderMouseEvent({
+        type: 'columnContextMenu',
+        mouseEvent: this.mouseEvent,
+        ePopup: eGui
+      });
+    }
+  }, {
+    key: "isActive",
+    value: function isActive() {
+      return this.allowGrouping || this.allowValues || this.allowPivoting;
+    }
+  }, {
+    key: "getMappedMenuItems",
+    value: function getMappedMenuItems() {
+      var _this5 = this;
+
+      var ret = [];
+
+      var _iterator = _createForOfIteratorHelper(this.menuItemMap.values()),
+          _step;
+
+      try {
+        var _loop = function _loop() {
+          var val = _step.value;
+
+          var isInactive = _this5.columns.some(function (col) {
+            return val.allowedFunction(col) && !val.activeFunction(col);
+          });
+
+          var isActive = _this5.columns.some(function (col) {
+            return val.allowedFunction(col) && val.activeFunction(col);
+          });
+
+          if (isInactive) {
+            ret.push({
+              name: val.activateLabel(_this5.displayName),
+              icon: _.createIconNoSpan(val.addIcon, _this5.gridOptionsWrapper, null),
+              action: function action() {
+                return val.activateFunction();
+              }
+            });
+          }
+
+          if (isActive) {
+            ret.push({
+              name: val.deactivateLabel(_this5.displayName),
+              icon: _.createIconNoSpan(val.removeIcon, _this5.gridOptionsWrapper, null),
+              action: function action() {
+                return val.deActivateFunction();
+              }
+            });
+          }
+        };
+
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _loop();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      return ret;
+    }
+  }]);
+
+  return ToolPanelContextMenu;
+}(Component);
+
+__decorate([Autowired('columnModel')], ToolPanelContextMenu.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('popupService')], ToolPanelContextMenu.prototype, 'popupService', void 0);
+
+__decorate([Autowired('focusService')], ToolPanelContextMenu.prototype, 'focusService', void 0);
+
+__decorate([PostConstruct], ToolPanelContextMenu.prototype, 'postConstruct', null);

package/es/components/DataGrid/modules/column-tool-panel/columnsToolPanelModule.d.ts

@@ -0,0 +1,24 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { PrimaryColsHeaderPanel } from './columnToolPanel/primaryColsHeaderPanel';
+import { PrimaryColsListPanel } from './columnToolPanel/primaryColsListPanel';
+import { ColumnToolPanel } from './columnToolPanel/columnToolPanel';
+import { PrimaryColsPanel } from './columnToolPanel/primaryColsPanel';
+import { ModelItemUtils } from './columnToolPanel/modelItemUtils';
+export declare const ColumnsToolPanelModule: {
+    moduleName: ModuleNames;
+    beans: (typeof ModelItemUtils)[];
+    agStackComponents: ({
+        componentName: string;
+        componentClass: typeof PrimaryColsHeaderPanel;
+    } | {
+        componentName: string;
+        componentClass: typeof PrimaryColsListPanel;
+    } | {
+        componentName: string;
+        componentClass: typeof PrimaryColsPanel;
+    })[];
+    userComponents: {
+        componentName: string;
+        componentClass: typeof ColumnToolPanel;
+    }[];
+};

package/es/components/DataGrid/modules/column-tool-panel/columnsToolPanelModule.js

@@ -0,0 +1,24 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { PrimaryColsHeaderPanel } from "./columnToolPanel/primaryColsHeaderPanel";
+import { PrimaryColsListPanel } from "./columnToolPanel/primaryColsListPanel";
+import { ColumnToolPanel } from "./columnToolPanel/columnToolPanel";
+import { PrimaryColsPanel } from "./columnToolPanel/primaryColsPanel";
+import { ModelItemUtils } from "./columnToolPanel/modelItemUtils";
+export var ColumnsToolPanelModule = {
+  moduleName: ModuleNames.ColumnToolPanelModule,
+  beans: [ModelItemUtils],
+  agStackComponents: [{
+    componentName: 'AgPrimaryColsHeader',
+    componentClass: PrimaryColsHeaderPanel
+  }, {
+    componentName: 'AgPrimaryColsList',
+    componentClass: PrimaryColsListPanel
+  }, {
+    componentName: 'AgPrimaryCols',
+    componentClass: PrimaryColsPanel
+  }],
+  userComponents: [{
+    componentName: 'agColumnsToolPanel',
+    componentClass: ColumnToolPanel
+  }]
+};

package/es/components/DataGrid/modules/column-tool-panel/index.d.ts

@@ -0,0 +1,2 @@
+export { ColumnsToolPanelModule } from './columnsToolPanelModule';
+export { PrimaryColsPanel } from './columnToolPanel/primaryColsPanel';

package/es/components/DataGrid/modules/column-tool-panel/index.js

@@ -0,0 +1,3 @@
+export { ColumnsToolPanelModule } from "./columnsToolPanelModule"; // used by the enterprise column menu
+
+export { PrimaryColsPanel } from "./columnToolPanel/primaryColsPanel";

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

@@ -0,0 +1 @@
+export { MenuModule } from './menuModule';

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

@@ -0,0 +1 @@
+export { MenuModule } from "./menuModule";

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

@@ -0,0 +1,26 @@
+import { BeanStub, Column, IContextMenuFactory, RowNode } from '@ag-grid-community/core';
+export declare class ContextMenuFactory extends BeanStub implements IContextMenuFactory {
+  private popupService;
+  private rangeService;
+  private ctrlsService;
+  private columnModel;
+  private activeMenu;
+  hideActiveMenu(): void;
+  private getMenuItems;
+  onContextMenu(
+    mouseEvent: MouseEvent | null,
+    touchEvent: TouchEvent | null,
+    rowNode: RowNode | null,
+    column: Column | null,
+    value: any,
+    anchorToElement: HTMLElement,
+  ): void;
+  private blockMiddleClickScrollsIfNeeded;
+  showMenu(
+    node: RowNode | null,
+    column: Column | null,
+    value: any,
+    mouseEvent: MouseEvent | Touch,
+    anchorToElement: HTMLElement,
+  ): boolean;
+}