@lemon-fe/components 0.1.154 → 1.1.0-alpha.1

package/es/data-grid/modules/clipboard/clipboardModule.d.ts

@@ -0,0 +1,2 @@
+import { Module } from "@ag-grid-community/core";
+export declare const ClipboardModule: Module;

package/es/data-grid/modules/clipboard/clipboardModule.js

@@ -0,0 +1,10 @@
+import { ModuleNames } from "@ag-grid-community/core";
+import { CsvExportModule } from "@ag-grid-community/csv-export";
+import { ClipboardService } from "./clipboard/clipboardService";
+import { VERSION } from "./version";
+export var ClipboardModule = {
+  version: VERSION,
+  moduleName: ModuleNames.ClipboardModule,
+  beans: [ClipboardService],
+  dependantModules: [CsvExportModule]
+};

package/es/data-grid/modules/clipboard/main.d.ts

@@ -0,0 +1 @@
+export { ClipboardModule } from "./clipboardModule";

package/es/data-grid/modules/clipboard/main.js

@@ -0,0 +1 @@
+export { ClipboardModule } from "./clipboardModule";

package/es/data-grid/modules/clipboard/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "29.2.0";

package/es/data-grid/modules/clipboard/version.js

@@ -0,0 +1,2 @@
+// DO NOT UPDATE MANUALLY: Generated from script during build time
+export var VERSION = '29.2.0';

package/es/data-grid/modules/column-tool-panel/columnToolPanel/columnModelItem.d.ts

@@ -0,0 +1,26 @@
+import { Column, IEventEmitter, ProvidedColumnGroup } from "@ag-grid-community/core";
+export declare class ColumnModelItem implements IEventEmitter {
+    private eventService;
+    static EVENT_EXPANDED_CHANGED: string;
+    private readonly group;
+    private readonly displayName;
+    private readonly columnGroup;
+    private readonly column;
+    private readonly dept;
+    private readonly children;
+    private expanded;
+    private passesFilter;
+    constructor(displayName: string | null, columnOrGroup: Column | ProvidedColumnGroup, dept: number, group?: boolean, expanded?: boolean);
+    isGroup(): boolean;
+    getDisplayName(): string | null;
+    getColumnGroup(): ProvidedColumnGroup;
+    getColumn(): Column;
+    getDept(): number;
+    isExpanded(): boolean;
+    getChildren(): ColumnModelItem[];
+    isPassesFilter(): boolean;
+    setExpanded(expanded: boolean): void;
+    setPassesFilter(passesFilter: boolean): void;
+    addEventListener(eventType: string, listener: Function): void;
+    removeEventListener(eventType: string, listener: Function): void;
+}

package/es/data-grid/modules/column-tool-panel/columnToolPanel/columnModelItem.js

@@ -0,0 +1,94 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, _toPropertyKey(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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { EventService } from "@ag-grid-community/core";
+export var ColumnModelItem = /*#__PURE__*/function () {
+  function ColumnModelItem(displayName, columnOrGroup, dept) {
+    var group = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var expanded = arguments.length > 4 ? arguments[4] : undefined;
+    _classCallCheck(this, ColumnModelItem);
+    this.eventService = new EventService();
+    this.displayName = displayName;
+    this.dept = dept;
+    this.group = group;
+    if (group) {
+      this.columnGroup = columnOrGroup;
+      this.expanded = expanded;
+      this.children = [];
+    } else {
+      this.column = columnOrGroup;
+    }
+  }
+  _createClass(ColumnModelItem, [{
+    key: "isGroup",
+    value: function isGroup() {
+      return this.group;
+    }
+  }, {
+    key: "getDisplayName",
+    value: function getDisplayName() {
+      return this.displayName;
+    }
+  }, {
+    key: "getColumnGroup",
+    value: function getColumnGroup() {
+      return this.columnGroup;
+    }
+  }, {
+    key: "getColumn",
+    value: function getColumn() {
+      return this.column;
+    }
+  }, {
+    key: "getDept",
+    value: function getDept() {
+      return this.dept;
+    }
+  }, {
+    key: "isExpanded",
+    value: function isExpanded() {
+      return !!this.expanded;
+    }
+  }, {
+    key: "getChildren",
+    value: function getChildren() {
+      return this.children;
+    }
+  }, {
+    key: "isPassesFilter",
+    value: function isPassesFilter() {
+      return this.passesFilter;
+    }
+  }, {
+    key: "setExpanded",
+    value: function setExpanded(expanded) {
+      if (expanded === this.expanded) {
+        return;
+      }
+      this.expanded = expanded;
+      this.eventService.dispatchEvent({
+        type: ColumnModelItem.EVENT_EXPANDED_CHANGED
+      });
+    }
+  }, {
+    key: "setPassesFilter",
+    value: function setPassesFilter(passesFilter) {
+      this.passesFilter = passesFilter;
+    }
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(eventType, listener) {
+      this.eventService.addEventListener(eventType, listener);
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(eventType, listener) {
+      this.eventService.removeEventListener(eventType, listener);
+    }
+  }]);
+  return ColumnModelItem;
+}();
+ColumnModelItem.EVENT_EXPANDED_CHANGED = 'expandedChanged';

package/es/data-grid/modules/column-tool-panel/columnToolPanel/columnToolPanel.d.ts

@@ -0,0 +1,32 @@
+import { ColDef, ColGroupDef, Component, IColumnToolPanel, IToolPanelComp, ToolPanelColumnCompParams } from "@ag-grid-community/core";
+export declare class ColumnToolPanel extends Component implements IColumnToolPanel, IToolPanelComp {
+    private static TEMPLATE;
+    private gridApi;
+    private columnApi;
+    private initialised;
+    private params;
+    private childDestroyFuncs;
+    private pivotModePanel;
+    private primaryColsPanel;
+    private rowGroupDropZonePanel;
+    private valuesDropZonePanel;
+    private pivotDropZonePanel;
+    constructor();
+    setVisible(visible: boolean): void;
+    init(params: ToolPanelColumnCompParams): void;
+    setPivotModeSectionVisible(visible: boolean): void;
+    setRowGroupsSectionVisible(visible: boolean): void;
+    setValuesSectionVisible(visible: boolean): void;
+    setPivotSectionVisible(visible: boolean): void;
+    private setResizers;
+    private setLastVisible;
+    private resetChildrenHeight;
+    private isRowGroupingModuleLoaded;
+    expandColumnGroups(groupIds?: string[]): void;
+    collapseColumnGroups(groupIds?: string[]): void;
+    setColumnLayout(colDefs: (ColDef | ColGroupDef)[]): void;
+    syncLayoutWithGrid(): void;
+    destroyChildren(): void;
+    refresh(): void;
+    destroy(): void;
+}

package/es/data-grid/modules/column-tool-panel/columnToolPanel/columnToolPanel.js

@@ -0,0 +1,272 @@
+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, _toPropertyKey(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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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, Events, ModuleNames, ModuleRegistry } from "@ag-grid-community/core";
+import { PivotModePanel } from "./pivotModePanel";
+import { PivotDropZonePanel, RowGroupDropZonePanel, ValuesDropZonePanel } from "../../row-grouping/main";
+import { PrimaryColsPanel } from "./primaryColsPanel";
+export var ColumnToolPanel = /*#__PURE__*/function (_Component) {
+  _inherits(ColumnToolPanel, _Component);
+  var _super = _createSuper(ColumnToolPanel);
+  function ColumnToolPanel() {
+    var _this;
+    _classCallCheck(this, ColumnToolPanel);
+    _this = _super.call(this, ColumnToolPanel.TEMPLATE);
+    _this.initialised = false;
+    _this.childDestroyFuncs = [];
+    return _this;
+  }
+  // lazy initialise the panel
+  _createClass(ColumnToolPanel, [{
+    key: "setVisible",
+    value: function setVisible(visible) {
+      _get(_getPrototypeOf(ColumnToolPanel.prototype), "setDisplayed", this).call(this, visible);
+      if (visible && !this.initialised) {
+        this.init(this.params);
+      }
+    }
+  }, {
+    key: "init",
+    value: function init(params) {
+      var _this2 = this;
+      var defaultParams = {
+        suppressColumnMove: false,
+        suppressColumnSelectAll: false,
+        suppressColumnFilter: false,
+        suppressColumnExpandAll: false,
+        contractColumnSelection: false,
+        suppressPivotMode: false,
+        suppressRowGroups: false,
+        suppressValues: false,
+        suppressPivots: false,
+        suppressSyncLayoutWithGrid: false,
+        api: this.gridApi,
+        columnApi: this.columnApi
+      };
+      this.params = Object.assign(Object.assign(Object.assign({}, defaultParams), params), {
+        context: this.gridOptionsService.context
+      });
+      if (this.isRowGroupingModuleLoaded() && !this.params.suppressPivotMode) {
+        // DO NOT CHANGE TO createManagedBean
+        this.pivotModePanel = this.createBean(new PivotModePanel());
+        this.childDestroyFuncs.push(function () {
+          return _this2.destroyBean(_this2.pivotModePanel);
+        });
+        this.appendChild(this.pivotModePanel);
+      }
+      // DO NOT CHANGE TO createManagedBean
+      this.primaryColsPanel = this.createBean(new PrimaryColsPanel());
+      this.childDestroyFuncs.push(function () {
+        return _this2.destroyBean(_this2.primaryColsPanel);
+      });
+      this.primaryColsPanel.init(true, this.params, "toolPanelUi");
+      this.primaryColsPanel.addCssClass('ag-column-panel-column-select');
+      this.appendChild(this.primaryColsPanel);
+      if (this.isRowGroupingModuleLoaded()) {
+        if (!this.params.suppressRowGroups) {
+          // DO NOT CHANGE TO createManagedBean
+          this.rowGroupDropZonePanel = this.createBean(new RowGroupDropZonePanel(false));
+          this.childDestroyFuncs.push(function () {
+            return _this2.destroyBean(_this2.rowGroupDropZonePanel);
+          });
+          this.appendChild(this.rowGroupDropZonePanel);
+        }
+        if (!this.params.suppressValues) {
+          // DO NOT CHANGE TO createManagedBean
+          this.valuesDropZonePanel = this.createBean(new ValuesDropZonePanel(false));
+          this.childDestroyFuncs.push(function () {
+            return _this2.destroyBean(_this2.valuesDropZonePanel);
+          });
+          this.appendChild(this.valuesDropZonePanel);
+        }
+        if (!this.params.suppressPivots) {
+          // DO NOT CHANGE TO createManagedBean
+          this.pivotDropZonePanel = this.createBean(new PivotDropZonePanel(false));
+          this.childDestroyFuncs.push(function () {
+            return _this2.destroyBean(_this2.pivotDropZonePanel);
+          });
+          this.appendChild(this.pivotDropZonePanel);
+        }
+        this.setLastVisible();
+        var pivotModeListener = this.addManagedListener(this.eventService, Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, function () {
+          _this2.resetChildrenHeight();
+          _this2.setLastVisible();
+        });
+        this.childDestroyFuncs.push(function () {
+          return pivotModeListener();
+        });
+      }
+      this.initialised = true;
+    }
+  }, {
+    key: "setPivotModeSectionVisible",
+    value: function setPivotModeSectionVisible(visible) {
+      var _this3 = this;
+      if (!this.isRowGroupingModuleLoaded()) {
+        return;
+      }
+      if (this.pivotModePanel) {
+        this.pivotModePanel.setDisplayed(visible);
+      } else if (visible) {
+        this.pivotModePanel = this.createBean(new PivotModePanel());
+        // ensure pivot mode panel is positioned at the top of the columns tool panel
+        this.getGui().insertBefore(this.pivotModePanel.getGui(), this.getGui().firstChild);
+        this.childDestroyFuncs.push(function () {
+          return _this3.destroyBean(_this3.pivotModePanel);
+        });
+      }
+      this.setLastVisible();
+    }
+  }, {
+    key: "setRowGroupsSectionVisible",
+    value: function setRowGroupsSectionVisible(visible) {
+      if (!this.isRowGroupingModuleLoaded()) {
+        return;
+      }
+      if (this.rowGroupDropZonePanel) {
+        this.rowGroupDropZonePanel.setDisplayed(visible);
+      } else if (visible) {
+        this.rowGroupDropZonePanel = this.createManagedBean(new RowGroupDropZonePanel(false));
+        this.appendChild(this.rowGroupDropZonePanel);
+      }
+      this.setLastVisible();
+    }
+  }, {
+    key: "setValuesSectionVisible",
+    value: function setValuesSectionVisible(visible) {
+      if (!this.isRowGroupingModuleLoaded()) {
+        return;
+      }
+      if (this.valuesDropZonePanel) {
+        this.valuesDropZonePanel.setDisplayed(visible);
+      } else if (visible) {
+        this.valuesDropZonePanel = this.createManagedBean(new ValuesDropZonePanel(false));
+        this.appendChild(this.valuesDropZonePanel);
+      }
+      this.setLastVisible();
+    }
+  }, {
+    key: "setPivotSectionVisible",
+    value: function setPivotSectionVisible(visible) {
+      if (!this.isRowGroupingModuleLoaded()) {
+        return;
+      }
+      if (this.pivotDropZonePanel) {
+        this.pivotDropZonePanel.setDisplayed(visible);
+      } else if (visible) {
+        this.pivotDropZonePanel = this.createManagedBean(new PivotDropZonePanel(false));
+        this.appendChild(this.pivotDropZonePanel);
+        this.pivotDropZonePanel.setDisplayed(visible);
+      }
+      this.setLastVisible();
+    }
+  }, {
+    key: "setResizers",
+    value: function setResizers() {
+      [this.primaryColsPanel, this.rowGroupDropZonePanel, this.valuesDropZonePanel, this.pivotDropZonePanel].forEach(function (panel) {
+        if (!panel) {
+          return;
+        }
+        var eGui = panel.getGui();
+        panel.toggleResizable(!eGui.classList.contains('ag-last-column-drop') && !eGui.classList.contains('ag-hidden'));
+      });
+    }
+  }, {
+    key: "setLastVisible",
+    value: function setLastVisible() {
+      var eGui = this.getGui();
+      var columnDrops = Array.prototype.slice.call(eGui.querySelectorAll('.ag-column-drop'));
+      columnDrops.forEach(function (columnDrop) {
+        return columnDrop.classList.remove('ag-last-column-drop');
+      });
+      var columnDropEls = eGui.querySelectorAll('.ag-column-drop:not(.ag-hidden)');
+      var lastVisible = _.last(columnDropEls);
+      if (lastVisible) {
+        lastVisible.classList.add('ag-last-column-drop');
+      }
+      this.setResizers();
+    }
+  }, {
+    key: "resetChildrenHeight",
+    value: function resetChildrenHeight() {
+      var eGui = this.getGui();
+      var children = eGui.children;
+      for (var i = 0; i < children.length; i++) {
+        var child = children[i];
+        child.style.removeProperty('height');
+        child.style.removeProperty('flex');
+      }
+    }
+  }, {
+    key: "isRowGroupingModuleLoaded",
+    value: function isRowGroupingModuleLoaded() {
+      return ModuleRegistry.assertRegistered(ModuleNames.RowGroupingModule, 'Row Grouping');
+    }
+  }, {
+    key: "expandColumnGroups",
+    value: function expandColumnGroups(groupIds) {
+      this.primaryColsPanel.expandGroups(groupIds);
+    }
+  }, {
+    key: "collapseColumnGroups",
+    value: function collapseColumnGroups(groupIds) {
+      this.primaryColsPanel.collapseGroups(groupIds);
+    }
+  }, {
+    key: "setColumnLayout",
+    value: function setColumnLayout(colDefs) {
+      this.primaryColsPanel.setColumnLayout(colDefs);
+    }
+  }, {
+    key: "syncLayoutWithGrid",
+    value: function syncLayoutWithGrid() {
+      this.primaryColsPanel.syncLayoutWithGrid();
+    }
+  }, {
+    key: "destroyChildren",
+    value: function destroyChildren() {
+      this.childDestroyFuncs.forEach(function (func) {
+        return func();
+      });
+      this.childDestroyFuncs.length = 0;
+      _.clearElement(this.getGui());
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      this.destroyChildren();
+      this.init(this.params);
+    }
+    // this is a user component, and IComponent has "public destroy()" as part of the interface.
+    // so this must be public.
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.destroyChildren();
+      _get(_getPrototypeOf(ColumnToolPanel.prototype), "destroy", this).call(this);
+    }
+  }]);
+  return ColumnToolPanel;
+}(Component);
+ColumnToolPanel.TEMPLATE = "<div class=\"ag-column-panel\"></div>";
+__decorate([Autowired("gridApi")], ColumnToolPanel.prototype, "gridApi", void 0);
+__decorate([Autowired("columnApi")], ColumnToolPanel.prototype, "columnApi", void 0);

package/es/data-grid/modules/column-tool-panel/columnToolPanel/modelItemUtils.d.ts

@@ -0,0 +1,16 @@
+import { ColumnModelItem } from "./columnModelItem";
+import { ColumnModel, ColumnEventType, IAggFuncService, Column } from "@ag-grid-community/core";
+export declare class ModelItemUtils {
+    aggFuncService: IAggFuncService;
+    columnModel: ColumnModel;
+    private gridOptionsService;
+    private eventService;
+    selectAllChildren(colTree: ColumnModelItem[], selectAllChecked: boolean, eventType: ColumnEventType): void;
+    setColumn(col: Column, selectAllChecked: boolean, eventType: ColumnEventType): void;
+    setAllColumns(cols: Column[], selectAllChecked: boolean, eventType: ColumnEventType): void;
+    private extractAllLeafColumns;
+    private setAllVisible;
+    private setAllPivot;
+    private setAllPivotPassive;
+    private setAllPivotActive;
+}