@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/side-bar/sideBar/sideBarButtonsComp.js

@@ -0,0 +1,115 @@
+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, PostConstruct, PreDestroy, _, KeyCode } from '@ag-grid-community/core';
+import { SideBarButtonComp } from "./sideBarButtonComp";
+export var SideBarButtonsComp = /*#__PURE__*/function (_Component) {
+  _inherits(SideBarButtonsComp, _Component);
+
+  var _super = _createSuper(SideBarButtonsComp);
+
+  function SideBarButtonsComp() {
+    var _this;
+
+    _classCallCheck(this, SideBarButtonsComp);
+
+    _this = _super.call(this, SideBarButtonsComp.TEMPLATE);
+    _this.buttonComps = [];
+    return _this;
+  }
+
+  _createClass(SideBarButtonsComp, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      this.addManagedListener(this.getFocusableElement(), 'keydown', this.handleKeyDown.bind(this));
+    }
+  }, {
+    key: "handleKeyDown",
+    value: function handleKeyDown(e) {
+      if (e.key !== KeyCode.TAB || !e.shiftKey) {
+        return;
+      }
+
+      var lastColumn = _.last(this.columnModel.getAllDisplayedColumns());
+
+      if (this.focusService.focusGridView(lastColumn, true)) {
+        e.preventDefault();
+      }
+    }
+  }, {
+    key: "setToolPanelDefs",
+    value: function setToolPanelDefs(toolPanelDefs) {
+      toolPanelDefs.forEach(this.addButtonComp.bind(this));
+    }
+  }, {
+    key: "setActiveButton",
+    value: function setActiveButton(id) {
+      this.buttonComps.forEach(function (comp) {
+        comp.setSelected(id === comp.getToolPanelId());
+      });
+    }
+  }, {
+    key: "addButtonComp",
+    value: function addButtonComp(def) {
+      var _this2 = this;
+
+      var buttonComp = this.createBean(new SideBarButtonComp(def));
+      this.buttonComps.push(buttonComp);
+      this.appendChild(buttonComp);
+      buttonComp.addEventListener(SideBarButtonComp.EVENT_TOGGLE_BUTTON_CLICKED, function () {
+        _this2.dispatchEvent({
+          type: SideBarButtonsComp.EVENT_SIDE_BAR_BUTTON_CLICKED,
+          toolPanelId: def.id
+        });
+      });
+    }
+  }, {
+    key: "clearButtons",
+    value: function clearButtons() {
+      this.buttonComps = this.destroyBeans(this.buttonComps);
+
+      _.clearElement(this.getGui());
+    }
+  }]);
+
+  return SideBarButtonsComp;
+}(Component);
+SideBarButtonsComp.EVENT_SIDE_BAR_BUTTON_CLICKED = 'sideBarButtonClicked';
+SideBarButtonsComp.TEMPLATE = "<div class=\"ag-side-buttons\" role=\"tablist\"></div>";
+
+__decorate([Autowired('focusService')], SideBarButtonsComp.prototype, 'focusService', void 0);
+
+__decorate([Autowired('columnModel')], SideBarButtonsComp.prototype, 'columnModel', void 0);
+
+__decorate([PostConstruct], SideBarButtonsComp.prototype, 'postConstruct', null);
+
+__decorate([PreDestroy], SideBarButtonsComp.prototype, 'clearButtons', null);

package/es/components/DataGrid/modules/side-bar/sideBar/sideBarComp.d.ts

@@ -0,0 +1,29 @@
+import { Component, IComponent, ISideBar, IToolPanel } from '@ag-grid-community/core';
+export interface IToolPanelChildComp extends IComponent<any> {
+  refresh(): void;
+}
+export declare class SideBarComp extends Component implements ISideBar {
+  private gridApi;
+  private focusService;
+  private sideBarButtonsComp;
+  private toolPanelWrappers;
+  private static readonly TEMPLATE;
+  constructor();
+  private postConstruct;
+  protected onTabKeyDown(e: KeyboardEvent): void;
+  protected handleKeyDown(e: KeyboardEvent): void;
+  private onToolPanelButtonClicked;
+  private clearDownUi;
+  private setSideBarDef;
+  setSideBarPosition(position?: 'left' | 'right'): this;
+  private setupToolPanels;
+  refresh(): void;
+  openToolPanel(key: string | undefined): void;
+  getToolPanelInstance(key: string): IToolPanel | undefined;
+  private raiseToolPanelVisibleEvent;
+  close(): void;
+  isToolPanelShowing(): boolean;
+  openedItem(): string | null;
+  private destroyToolPanelWrappers;
+  protected destroy(): void;
+}

package/es/components/DataGrid/modules/side-bar/sideBar/sideBarComp.js

@@ -0,0 +1,353 @@
+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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+
+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 { _, Component, Events, ModuleNames, ModuleRegistry, PostConstruct, RefSelector, Autowired, ManagedFocusFeature, KeyCode } from '@ag-grid-community/core';
+import { SideBarButtonsComp } from "./sideBarButtonsComp";
+import { ToolPanelWrapper } from "./toolPanelWrapper";
+export var SideBarComp = /*#__PURE__*/function (_Component) {
+  _inherits(SideBarComp, _Component);
+
+  var _super = _createSuper(SideBarComp);
+
+  function SideBarComp() {
+    var _this;
+
+    _classCallCheck(this, SideBarComp);
+
+    _this = _super.call(this, SideBarComp.TEMPLATE);
+    _this.toolPanelWrappers = [];
+    return _this;
+  }
+
+  _createClass(SideBarComp, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      var _this2 = this;
+
+      this.sideBarButtonsComp.addEventListener(SideBarButtonsComp.EVENT_SIDE_BAR_BUTTON_CLICKED, this.onToolPanelButtonClicked.bind(this));
+      this.setSideBarDef();
+      this.gridOptionsWrapper.addEventListener('sideBar', function () {
+        _this2.clearDownUi();
+
+        _this2.setSideBarDef();
+      });
+      this.gridApi.registerSideBarComp(this);
+      this.createManagedBean(new ManagedFocusFeature(this.getFocusableElement(), {
+        onTabKeyDown: this.onTabKeyDown.bind(this),
+        handleKeyDown: this.handleKeyDown.bind(this)
+      }));
+    }
+  }, {
+    key: "onTabKeyDown",
+    value: function onTabKeyDown(e) {
+      if (e.defaultPrevented) {
+        return;
+      }
+
+      var focusService = this.focusService,
+          sideBarButtonsComp = this.sideBarButtonsComp;
+      var eGui = this.getGui();
+      var sideBarGui = sideBarButtonsComp.getGui();
+      var eDocument = this.gridOptionsWrapper.getDocument();
+      var activeElement = eDocument.activeElement;
+      var openPanel = eGui.querySelector('.ag-tool-panel-wrapper:not(.ag-hidden)');
+
+      if (!openPanel) {
+        return;
+      }
+
+      if (sideBarGui.contains(activeElement)) {
+        if (focusService.focusInto(openPanel, e.shiftKey)) {
+          e.preventDefault();
+        }
+      } else {
+        if (!focusService.isFocusUnderManagedComponent(openPanel) && e.shiftKey) {
+          var firstFocusableEl = focusService.findFocusableElements(openPanel)[0];
+
+          var _eDocument = this.gridOptionsWrapper.getDocument();
+
+          if (_eDocument.activeElement === firstFocusableEl) {
+            var selectedButton = sideBarGui.querySelector('.ag-selected button');
+
+            if (selectedButton) {
+              e.preventDefault();
+              selectedButton.focus();
+            }
+          }
+        }
+      }
+    }
+  }, {
+    key: "handleKeyDown",
+    value: function handleKeyDown(e) {
+      var eDocument = this.gridOptionsWrapper.getDocument();
+
+      if (!this.sideBarButtonsComp.getGui().contains(eDocument.activeElement)) {
+        return;
+      }
+
+      var sideBarGui = this.sideBarButtonsComp.getGui();
+      var buttons = Array.prototype.slice.call(sideBarGui.querySelectorAll('.ag-side-button'));
+      var currentButton = eDocument.activeElement;
+      var currentPos = buttons.findIndex(function (button) {
+        return button.contains(currentButton);
+      });
+      var nextPos = null;
+
+      switch (e.key) {
+        case KeyCode.LEFT:
+        case KeyCode.UP:
+          nextPos = Math.max(0, currentPos - 1);
+          break;
+
+        case KeyCode.RIGHT:
+        case KeyCode.DOWN:
+          nextPos = Math.min(currentPos + 1, buttons.length - 1);
+          break;
+      }
+
+      if (nextPos === null) {
+        return;
+      }
+
+      var innerButton = buttons[nextPos].querySelector('button');
+
+      if (innerButton) {
+        innerButton.focus();
+        e.preventDefault();
+      }
+    }
+  }, {
+    key: "onToolPanelButtonClicked",
+    value: function onToolPanelButtonClicked(event) {
+      var id = event.toolPanelId;
+      var openedItem = this.openedItem(); // if item was already open, we close it
+
+      if (openedItem === id) {
+        this.openToolPanel(undefined); // passing undefined closes
+      } else {
+        this.openToolPanel(id);
+      }
+    }
+  }, {
+    key: "clearDownUi",
+    value: function clearDownUi() {
+      this.sideBarButtonsComp.clearButtons();
+      this.destroyToolPanelWrappers();
+    }
+  }, {
+    key: "setSideBarDef",
+    value: function setSideBarDef() {
+      // initially hide side bar
+      this.setDisplayed(false);
+      var sideBar = this.gridOptionsWrapper.getSideBar();
+      var sideBarExists = !!sideBar && !!sideBar.toolPanels;
+
+      if (!sideBarExists) {
+        return;
+      }
+
+      var shouldDisplaySideBar = sideBarExists && !sideBar.hiddenByDefault;
+      this.setDisplayed(shouldDisplaySideBar);
+      var toolPanelDefs = sideBar.toolPanels;
+      this.sideBarButtonsComp.setToolPanelDefs(toolPanelDefs);
+      this.setupToolPanels(toolPanelDefs);
+      this.setSideBarPosition(sideBar.position);
+
+      if (!sideBar.hiddenByDefault) {
+        this.openToolPanel(sideBar.defaultToolPanel);
+      }
+    }
+  }, {
+    key: "setSideBarPosition",
+    value: function setSideBarPosition(position) {
+      if (!position) {
+        position = 'right';
+      }
+
+      var isLeft = position === 'left';
+      var resizerSide = isLeft ? 'right' : 'left';
+      this.addOrRemoveCssClass('ag-side-bar-left', isLeft);
+      this.addOrRemoveCssClass('ag-side-bar-right', !isLeft);
+      this.toolPanelWrappers.forEach(function (wrapper) {
+        wrapper.setResizerSizerSide(resizerSide);
+      });
+      return this;
+    }
+  }, {
+    key: "setupToolPanels",
+    value: function setupToolPanels(defs) {
+      var _this3 = this;
+
+      defs.forEach(function (def) {
+        if (def.id == null) {
+          console.warn("AG Grid: please review all your toolPanel components, it seems like at least one of them doesn't have an id");
+          return;
+        } // helpers, in case user doesn't have the right module loaded
+
+
+        if (def.toolPanel === 'agColumnsToolPanel') {
+          var moduleMissing = !ModuleRegistry.assertRegistered(ModuleNames.ColumnToolPanelModule, 'Column Tool Panel');
+
+          if (moduleMissing) {
+            return;
+          }
+        }
+
+        if (def.toolPanel === 'agFiltersToolPanel') {
+          var _moduleMissing = !ModuleRegistry.assertRegistered(ModuleNames.FiltersToolPanelModule, 'Filters Tool Panel');
+
+          if (_moduleMissing) {
+            return;
+          }
+        }
+
+        var wrapper = new ToolPanelWrapper();
+
+        _this3.getContext().createBean(wrapper);
+
+        wrapper.setToolPanelDef(def);
+        wrapper.setDisplayed(false);
+
+        _this3.getGui().appendChild(wrapper.getGui());
+
+        _this3.toolPanelWrappers.push(wrapper);
+      });
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      this.toolPanelWrappers.forEach(function (wrapper) {
+        return wrapper.refresh();
+      });
+    }
+  }, {
+    key: "openToolPanel",
+    value: function openToolPanel(key) {
+      var currentlyOpenedKey = this.openedItem();
+
+      if (currentlyOpenedKey === key) {
+        return;
+      }
+
+      this.toolPanelWrappers.forEach(function (wrapper) {
+        var show = key === wrapper.getToolPanelId();
+        wrapper.setDisplayed(show);
+      });
+      var newlyOpenedKey = this.openedItem();
+      var openToolPanelChanged = currentlyOpenedKey !== newlyOpenedKey;
+
+      if (openToolPanelChanged) {
+        this.sideBarButtonsComp.setActiveButton(key);
+        this.raiseToolPanelVisibleEvent(key);
+      }
+    }
+  }, {
+    key: "getToolPanelInstance",
+    value: function getToolPanelInstance(key) {
+      var toolPanelWrapper = this.toolPanelWrappers.filter(function (toolPanel) {
+        return toolPanel.getToolPanelId() === key;
+      })[0];
+
+      if (!toolPanelWrapper) {
+        console.warn("AG Grid: unable to lookup Tool Panel as invalid key supplied: ".concat(key));
+        return;
+      }
+
+      return toolPanelWrapper.getToolPanelInstance();
+    }
+  }, {
+    key: "raiseToolPanelVisibleEvent",
+    value: function raiseToolPanelVisibleEvent(key) {
+      var event = {
+        type: Events.EVENT_TOOL_PANEL_VISIBLE_CHANGED,
+        source: key
+      };
+      this.eventService.dispatchEvent(event);
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      this.openToolPanel(undefined);
+    }
+  }, {
+    key: "isToolPanelShowing",
+    value: function isToolPanelShowing() {
+      return !!this.openedItem();
+    }
+  }, {
+    key: "openedItem",
+    value: function openedItem() {
+      var activeToolPanel = null;
+      this.toolPanelWrappers.forEach(function (wrapper) {
+        if (wrapper.isDisplayed()) {
+          activeToolPanel = wrapper.getToolPanelId();
+        }
+      });
+      return activeToolPanel;
+    }
+  }, {
+    key: "destroyToolPanelWrappers",
+    value: function destroyToolPanelWrappers() {
+      var _this4 = this;
+
+      this.toolPanelWrappers.forEach(function (wrapper) {
+        _.removeFromParent(wrapper.getGui());
+
+        _this4.destroyBean(wrapper);
+      });
+      this.toolPanelWrappers.length = 0;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.destroyToolPanelWrappers();
+
+      _get(_getPrototypeOf(SideBarComp.prototype), "destroy", this).call(this);
+    }
+  }]);
+
+  return SideBarComp;
+}(Component);
+SideBarComp.TEMPLATE = "<div class=\"ag-side-bar ag-unselectable\">\n            <ag-side-bar-buttons ref=\"sideBarButtons\"></ag-side-bar-buttons>\n        </div>";
+
+__decorate([Autowired('gridApi')], SideBarComp.prototype, 'gridApi', void 0);
+
+__decorate([Autowired('focusService')], SideBarComp.prototype, 'focusService', void 0);
+
+__decorate([RefSelector('sideBarButtons')], SideBarComp.prototype, 'sideBarButtonsComp', void 0);
+
+__decorate([PostConstruct], SideBarComp.prototype, 'postConstruct', null);

package/es/components/DataGrid/modules/side-bar/sideBar/toolPanelWrapper.d.ts

@@ -0,0 +1,17 @@
+import { Component, IToolPanelComp, ToolPanelDef } from '@ag-grid-community/core';
+export declare class ToolPanelWrapper extends Component {
+  private userComponentFactory;
+  private static TEMPLATE;
+  private toolPanelCompInstance;
+  private toolPanelId;
+  private resizeBar;
+  private width;
+  constructor();
+  private setupResize;
+  getToolPanelId(): string;
+  setToolPanelDef(toolPanelDef: ToolPanelDef): void;
+  private setToolPanelComponent;
+  getToolPanelInstance(): IToolPanelComp;
+  setResizerSizerSide(side: 'right' | 'left'): void;
+  refresh(): void;
+}

package/es/components/DataGrid/modules/side-bar/sideBar/toolPanelWrapper.js

@@ -0,0 +1,128 @@
+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, PostConstruct } from '@ag-grid-community/core';
+import { HorizontalResizeComp } from "./horizontalResizeComp";
+export var ToolPanelWrapper = /*#__PURE__*/function (_Component) {
+  _inherits(ToolPanelWrapper, _Component);
+
+  var _super = _createSuper(ToolPanelWrapper);
+
+  function ToolPanelWrapper() {
+    _classCallCheck(this, ToolPanelWrapper);
+
+    return _super.call(this, ToolPanelWrapper.TEMPLATE);
+  }
+
+  _createClass(ToolPanelWrapper, [{
+    key: "setupResize",
+    value: function setupResize() {
+      var eGui = this.getGui();
+      var resizeBar = this.resizeBar = this.createManagedBean(new HorizontalResizeComp());
+      resizeBar.setElementToResize(eGui);
+      this.appendChild(resizeBar);
+    }
+  }, {
+    key: "getToolPanelId",
+    value: function getToolPanelId() {
+      return this.toolPanelId;
+    }
+  }, {
+    key: "setToolPanelDef",
+    value: function setToolPanelDef(toolPanelDef) {
+      var id = toolPanelDef.id,
+          minWidth = toolPanelDef.minWidth,
+          maxWidth = toolPanelDef.maxWidth,
+          width = toolPanelDef.width;
+      this.toolPanelId = id;
+      this.width = width;
+      var params = {};
+      var compDetails = this.userComponentFactory.getToolPanelCompDetails(toolPanelDef, params);
+      var componentPromise = compDetails.newAgStackInstance();
+
+      if (componentPromise == null) {
+        console.warn("AG Grid: error processing tool panel component ".concat(id, ". You need to specify either 'toolPanel' or 'toolPanelFramework'"));
+        return;
+      }
+
+      componentPromise.then(this.setToolPanelComponent.bind(this));
+
+      if (minWidth != null) {
+        this.resizeBar.setMinWidth(minWidth);
+      }
+
+      if (maxWidth != null) {
+        this.resizeBar.setMaxWidth(maxWidth);
+      }
+    }
+  }, {
+    key: "setToolPanelComponent",
+    value: function setToolPanelComponent(compInstance) {
+      var _this = this;
+
+      this.toolPanelCompInstance = compInstance;
+      this.appendChild(compInstance.getGui());
+      this.addDestroyFunc(function () {
+        _this.destroyBean(compInstance);
+      });
+
+      if (this.width) {
+        this.getGui().style.width = "".concat(this.width, "px");
+      }
+    }
+  }, {
+    key: "getToolPanelInstance",
+    value: function getToolPanelInstance() {
+      return this.toolPanelCompInstance;
+    }
+  }, {
+    key: "setResizerSizerSide",
+    value: function setResizerSizerSide(side) {
+      var isRtl = this.gridOptionsWrapper.isEnableRtl();
+      var isLeft = side === 'left';
+      var inverted = isRtl ? isLeft : !isLeft;
+      this.resizeBar.setInverted(inverted);
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      this.toolPanelCompInstance.refresh();
+    }
+  }]);
+
+  return ToolPanelWrapper;
+}(Component);
+ToolPanelWrapper.TEMPLATE = "<div class=\"ag-tool-panel-wrapper\"/>";
+
+__decorate([Autowired('userComponentFactory')], ToolPanelWrapper.prototype, 'userComponentFactory', void 0);
+
+__decorate([PostConstruct], ToolPanelWrapper.prototype, 'setupResize', null);

package/es/components/DataGrid/modules/side-bar/sideBarModule.d.ts

@@ -0,0 +1,19 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { HorizontalResizeComp } from './sideBar/horizontalResizeComp';
+import { SideBarComp } from './sideBar/sideBarComp';
+import { SideBarButtonsComp } from './sideBar/sideBarButtonsComp';
+import { ToolPanelColDefService } from './sideBar/common/toolPanelColDefService';
+export declare const SideBarModule: {
+    moduleName: ModuleNames;
+    beans: (typeof ToolPanelColDefService)[];
+    agStackComponents: ({
+        componentName: string;
+        componentClass: typeof HorizontalResizeComp;
+    } | {
+        componentName: string;
+        componentClass: typeof SideBarComp;
+    } | {
+        componentName: string;
+        componentClass: typeof SideBarButtonsComp;
+    })[];
+};