@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/clipboard/clipboardModule.d.ts

@@ -0,0 +1,7 @@
+import { ModuleNames } from '@ag-grid-community/core';
+import { ClipboardService } from './clipboard/clipboardService';
+export declare const ClipboardModule: {
+    moduleName: ModuleNames;
+    beans: (typeof ClipboardService)[];
+    dependantModules: import("@ag-grid-community/core").Module[];
+};

package/es/components/DataGrid/modules/clipboard/clipboardModule.js

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+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/components/DataGrid/modules/column-tool-panel/columnToolPanel/columnModelItem.js

@@ -0,0 +1,100 @@
+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; }
+
+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/components/DataGrid/modules/column-tool-panel/columnToolPanel/columnToolPanel.d.ts

@@ -0,0 +1,51 @@
+import {
+  ColDef,
+  ColGroupDef,
+  Component,
+  IColumnToolPanel,
+  IToolPanelComp,
+  IToolPanelParams,
+} from '@ag-grid-community/core';
+export interface ToolPanelColumnCompParams extends IToolPanelParams {
+  suppressColumnMove: boolean;
+  suppressRowGroups: boolean;
+  suppressValues: boolean;
+  suppressPivots: boolean;
+  suppressPivotMode: boolean;
+  suppressColumnFilter: boolean;
+  suppressColumnSelectAll: boolean;
+  suppressColumnExpandAll: boolean;
+  contractColumnSelection: boolean;
+  suppressSyncLayoutWithGrid: boolean;
+}
+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/components/DataGrid/modules/column-tool-panel/columnToolPanel/columnToolPanel.js

@@ -0,0 +1,320 @@
+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 { _, Autowired, Component, Events, ModuleNames, ModuleRegistry } from '@ag-grid-community/core';
+import { PivotModePanel } from "./pivotModePanel";
+import { PivotDropZonePanel, RowGroupDropZonePanel, ValuesDropZonePanel } from "../../row-grouping";
+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.gridOptionsWrapper.getContext()
+      });
+
+      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/components/DataGrid/modules/column-tool-panel/columnToolPanel/modelItemUtils.d.ts

@@ -0,0 +1,20 @@
+import { ColumnModelItem } from './columnModelItem';
+import { ColumnModel, ColumnEventType, IAggFuncService, Column } from '@ag-grid-community/core';
+export declare class ModelItemUtils {
+  aggFuncService: IAggFuncService;
+  columnModel: ColumnModel;
+  private gridOptionsWrapper;
+  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;
+}