@lemon-fe/kits 0.1.136 → 1.0.0-0

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

@@ -0,0 +1,546 @@
+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 _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 _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, ProvidedColumnGroup, VirtualList, PreDestroy } from '@ag-grid-community/core';
+import { PrimaryColsListPanelItemDragFeature } from "./primaryColsListPanelItemDragFeature";
+import { ToolPanelColumnGroupComp } from "./toolPanelColumnGroupComp";
+import { ToolPanelColumnComp } from "./toolPanelColumnComp";
+import { ExpandState } from "./primaryColsHeaderPanel";
+import { ColumnModelItem } from "./columnModelItem";
+
+var UIColumnModel = /*#__PURE__*/function () {
+  function UIColumnModel(items) {
+    _classCallCheck(this, UIColumnModel);
+
+    this.items = items;
+  }
+
+  _createClass(UIColumnModel, [{
+    key: "getRowCount",
+    value: function getRowCount() {
+      return this.items.length;
+    }
+  }, {
+    key: "getRow",
+    value: function getRow(index) {
+      return this.items[index];
+    }
+  }]);
+
+  return UIColumnModel;
+}();
+
+var PRIMARY_COLS_LIST_PANEL_CLASS = 'ag-column-select-list';
+export var PrimaryColsListPanel = /*#__PURE__*/function (_Component) {
+  _inherits(PrimaryColsListPanel, _Component);
+
+  var _super = _createSuper(PrimaryColsListPanel);
+
+  function PrimaryColsListPanel() {
+    var _this;
+
+    _classCallCheck(this, PrimaryColsListPanel);
+
+    _this = _super.call(this, PrimaryColsListPanel.TEMPLATE);
+    _this.destroyColumnItemFuncs = [];
+    return _this;
+  }
+
+  _createClass(PrimaryColsListPanel, [{
+    key: "destroyColumnTree",
+    value: function destroyColumnTree() {
+      this.allColsTree = [];
+      this.destroyColumnItemFuncs.forEach(function (f) {
+        return f();
+      });
+      this.destroyColumnItemFuncs = [];
+    }
+  }, {
+    key: "init",
+    value: function init(params, allowDragging, eventType) {
+      var _this2 = this;
+
+      this.params = params;
+      this.allowDragging = allowDragging;
+      this.eventType = eventType;
+
+      if (!this.params.suppressSyncLayoutWithGrid) {
+        this.addManagedListener(this.eventService, Events.EVENT_COLUMN_MOVED, this.onColumnsChanged.bind(this));
+      }
+
+      this.addManagedListener(this.eventService, Events.EVENT_NEW_COLUMNS_LOADED, this.onColumnsChanged.bind(this));
+      var eventsImpactingCheckedState = [Events.EVENT_COLUMN_PIVOT_CHANGED, Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, Events.EVENT_COLUMN_ROW_GROUP_CHANGED, Events.EVENT_COLUMN_VALUE_CHANGED, Events.EVENT_COLUMN_VISIBLE, Events.EVENT_NEW_COLUMNS_LOADED];
+      eventsImpactingCheckedState.forEach(function (event) {
+        // update header select all checkbox with current selection state
+        _this2.addManagedListener(_this2.eventService, event, _this2.fireSelectionChangedEvent.bind(_this2));
+      });
+      this.expandGroupsByDefault = !this.params.contractColumnSelection;
+      var translate = this.gridOptionsWrapper.getLocaleTextFunc();
+      var columnListName = translate('ariaColumnList', 'Column List');
+      this.virtualList = this.createManagedBean(new VirtualList('column-select', 'tree', columnListName));
+      this.appendChild(this.virtualList.getGui());
+      this.virtualList.setComponentCreator(function (item, listItemElement) {
+        _.setAriaLevel(listItemElement, item.getDept() + 1);
+
+        return _this2.createComponentFromItem(item, listItemElement);
+      });
+
+      if (this.columnModel.isReady()) {
+        this.onColumnsChanged();
+      }
+
+      if (!params.suppressColumnMove && !this.gridOptionsWrapper.isSuppressMovableColumns()) {
+        this.createManagedBean(new PrimaryColsListPanelItemDragFeature(this, this.virtualList));
+      }
+    }
+  }, {
+    key: "createComponentFromItem",
+    value: function createComponentFromItem(item, listItemElement) {
+      if (item.isGroup()) {
+        var renderedGroup = new ToolPanelColumnGroupComp(item, this.allowDragging, this.eventType, listItemElement);
+        this.getContext().createBean(renderedGroup);
+        return renderedGroup;
+      }
+
+      var columnComp = new ToolPanelColumnComp(item.getColumn(), item.getDept(), this.allowDragging, this.groupsExist, listItemElement);
+      this.getContext().createBean(columnComp);
+      return columnComp;
+    }
+  }, {
+    key: "onColumnsChanged",
+    value: function onColumnsChanged() {
+      var expandedStates = this.getExpandedStates();
+      var pivotModeActive = this.columnModel.isPivotMode();
+      var shouldSyncColumnLayoutWithGrid = !this.params.suppressSyncLayoutWithGrid && !pivotModeActive;
+
+      if (shouldSyncColumnLayoutWithGrid) {
+        this.buildTreeFromWhatGridIsDisplaying();
+      } else {
+        this.buildTreeFromProvidedColumnDefs();
+      }
+
+      this.setExpandedStates(expandedStates);
+      this.markFilteredColumns();
+      this.flattenAndFilterModel();
+    }
+  }, {
+    key: "getDisplayedColsList",
+    value: function getDisplayedColsList() {
+      return this.displayedColsList;
+    }
+  }, {
+    key: "getExpandedStates",
+    value: function getExpandedStates() {
+      if (!this.allColsTree) {
+        return {};
+      }
+
+      var res = {};
+      this.forEachItem(function (item) {
+        if (!item.isGroup()) {
+          return;
+        }
+
+        var colGroup = item.getColumnGroup();
+
+        if (colGroup) {
+          // group should always exist, this is defensive
+          res[colGroup.getId()] = item.isExpanded();
+        }
+      });
+      return res;
+    }
+  }, {
+    key: "setExpandedStates",
+    value: function setExpandedStates(states) {
+      if (!this.allColsTree) {
+        return;
+      }
+
+      this.forEachItem(function (item) {
+        if (!item.isGroup()) {
+          return;
+        }
+
+        var colGroup = item.getColumnGroup();
+
+        if (colGroup) {
+          // group should always exist, this is defensive
+          var expanded = states[colGroup.getId()];
+          var groupExistedLastTime = expanded != null;
+
+          if (groupExistedLastTime) {
+            item.setExpanded(expanded);
+          }
+        }
+      });
+    }
+  }, {
+    key: "buildTreeFromWhatGridIsDisplaying",
+    value: function buildTreeFromWhatGridIsDisplaying() {
+      this.colDefService.syncLayoutWithGrid(this.setColumnLayout.bind(this));
+    }
+  }, {
+    key: "setColumnLayout",
+    value: function setColumnLayout(colDefs) {
+      var columnTree = this.colDefService.createColumnTree(colDefs);
+      this.buildListModel(columnTree); // using col defs to check if groups exist as it could be a custom layout
+
+      this.groupsExist = colDefs.some(function (colDef) {
+        return colDef && typeof colDef.children !== 'undefined';
+      });
+      this.markFilteredColumns();
+      this.flattenAndFilterModel();
+    }
+  }, {
+    key: "buildTreeFromProvidedColumnDefs",
+    value: function buildTreeFromProvidedColumnDefs() {
+      // add column / group comps to tool panel
+      this.buildListModel(this.columnModel.getPrimaryColumnTree());
+      this.groupsExist = this.columnModel.isPrimaryColumnGroupsPresent();
+    }
+  }, {
+    key: "buildListModel",
+    value: function buildListModel(columnTree) {
+      var _this3 = this;
+
+      var columnExpandedListener = this.onColumnExpanded.bind(this);
+
+      var addListeners = function addListeners(item) {
+        item.addEventListener(ColumnModelItem.EVENT_EXPANDED_CHANGED, columnExpandedListener);
+        var removeFunc = item.removeEventListener.bind(item, ColumnModelItem.EVENT_EXPANDED_CHANGED, columnExpandedListener);
+
+        _this3.destroyColumnItemFuncs.push(removeFunc);
+      };
+
+      var recursivelyBuild = function recursivelyBuild(tree, dept, parentList) {
+        tree.forEach(function (child) {
+          if (child instanceof ProvidedColumnGroup) {
+            createGroupItem(child, dept, parentList);
+          } else {
+            createColumnItem(child, dept, parentList);
+          }
+        });
+      };
+
+      var createGroupItem = function createGroupItem(columnGroup, dept, parentList) {
+        var columnGroupDef = columnGroup.getColGroupDef();
+        var skipThisGroup = columnGroupDef && columnGroupDef.suppressColumnsToolPanel;
+
+        if (skipThisGroup) {
+          return;
+        }
+
+        if (columnGroup.isPadding()) {
+          recursivelyBuild(columnGroup.getChildren(), dept, parentList);
+          return;
+        }
+
+        var displayName = _this3.columnModel.getDisplayNameForProvidedColumnGroup(null, columnGroup, _this3.eventType);
+
+        var item = new ColumnModelItem(displayName, columnGroup, dept, true, _this3.expandGroupsByDefault);
+        parentList.push(item);
+        addListeners(item);
+        recursivelyBuild(columnGroup.getChildren(), dept + 1, item.getChildren());
+      };
+
+      var createColumnItem = function createColumnItem(column, dept, parentList) {
+        var skipThisColumn = column.getColDef() && column.getColDef().suppressColumnsToolPanel;
+
+        if (skipThisColumn) {
+          return;
+        }
+
+        var displayName = _this3.columnModel.getDisplayNameForColumn(column, 'columnToolPanel');
+
+        parentList.push(new ColumnModelItem(displayName, column, dept));
+      };
+
+      this.destroyColumnTree();
+      recursivelyBuild(columnTree, 0, this.allColsTree);
+    }
+  }, {
+    key: "onColumnExpanded",
+    value: function onColumnExpanded() {
+      this.flattenAndFilterModel();
+    }
+  }, {
+    key: "flattenAndFilterModel",
+    value: function flattenAndFilterModel() {
+      var _this4 = this;
+
+      this.displayedColsList = [];
+
+      var recursiveFunc = function recursiveFunc(item) {
+        if (!item.isPassesFilter()) {
+          return;
+        }
+
+        _this4.displayedColsList.push(item);
+
+        if (item.isGroup() && item.isExpanded()) {
+          item.getChildren().forEach(recursiveFunc);
+        }
+      };
+
+      this.allColsTree.forEach(recursiveFunc);
+      this.virtualList.setModel(new UIColumnModel(this.displayedColsList));
+      var focusedRow = this.virtualList.getLastFocusedRow();
+      this.virtualList.refresh();
+
+      if (focusedRow != null) {
+        this.focusRowIfAlive(focusedRow);
+      }
+
+      this.notifyListeners();
+    }
+  }, {
+    key: "focusRowIfAlive",
+    value: function focusRowIfAlive(rowIndex) {
+      var _this5 = this;
+
+      window.setTimeout(function () {
+        if (_this5.isAlive()) {
+          _this5.virtualList.focusRow(rowIndex);
+        }
+      }, 0);
+    }
+  }, {
+    key: "forEachItem",
+    value: function forEachItem(callback) {
+      var recursiveFunc = function recursiveFunc(items) {
+        items.forEach(function (item) {
+          callback(item);
+
+          if (item.isGroup()) {
+            recursiveFunc(item.getChildren());
+          }
+        });
+      };
+
+      recursiveFunc(this.allColsTree);
+    }
+  }, {
+    key: "doSetExpandedAll",
+    value: function doSetExpandedAll(value) {
+      this.forEachItem(function (item) {
+        if (item.isGroup()) {
+          item.setExpanded(value);
+        }
+      });
+    }
+  }, {
+    key: "setGroupsExpanded",
+    value: function setGroupsExpanded(expand, groupIds) {
+      if (!groupIds) {
+        this.doSetExpandedAll(expand);
+        return;
+      }
+
+      var expandedGroupIds = [];
+      this.forEachItem(function (item) {
+        if (!item.isGroup()) {
+          return;
+        }
+
+        var groupId = item.getColumnGroup().getId();
+
+        if (groupIds.indexOf(groupId) >= 0) {
+          item.setExpanded(expand);
+          expandedGroupIds.push(groupId);
+        }
+      });
+      var unrecognisedGroupIds = groupIds.filter(function (groupId) {
+        return !_.includes(expandedGroupIds, groupId);
+      });
+
+      if (unrecognisedGroupIds.length > 0) {
+        console.warn('AG Grid: unable to find group(s) for supplied groupIds:', unrecognisedGroupIds);
+      }
+    }
+  }, {
+    key: "getExpandState",
+    value: function getExpandState() {
+      var expandedCount = 0;
+      var notExpandedCount = 0;
+      this.forEachItem(function (item) {
+        if (!item.isGroup()) {
+          return;
+        }
+
+        if (item.isExpanded()) {
+          expandedCount++;
+        } else {
+          notExpandedCount++;
+        }
+      });
+
+      if (expandedCount > 0 && notExpandedCount > 0) {
+        return ExpandState.INDETERMINATE;
+      }
+
+      if (notExpandedCount > 0) {
+        return ExpandState.COLLAPSED;
+      }
+
+      return ExpandState.EXPANDED;
+    }
+  }, {
+    key: "doSetSelectedAll",
+    value: function doSetSelectedAll(selectAllChecked) {
+      this.modelItemUtils.selectAllChildren(this.allColsTree, selectAllChecked, this.eventType);
+    }
+  }, {
+    key: "getSelectionState",
+    value: function getSelectionState() {
+      var checkedCount = 0;
+      var uncheckedCount = 0;
+      var pivotMode = this.columnModel.isPivotMode();
+      this.forEachItem(function (item) {
+        if (item.isGroup()) {
+          return;
+        }
+
+        if (!item.isPassesFilter()) {
+          return;
+        }
+
+        var column = item.getColumn();
+        var colDef = column.getColDef();
+        var checked;
+
+        if (pivotMode) {
+          var noPivotModeOptionsAllowed = !column.isAllowPivot() && !column.isAllowRowGroup() && !column.isAllowValue();
+
+          if (noPivotModeOptionsAllowed) {
+            return;
+          }
+
+          checked = column.isValueActive() || column.isPivotActive() || column.isRowGroupActive();
+        } else {
+          if (colDef.lockVisible) {
+            return;
+          }
+
+          checked = column.isVisible();
+        }
+
+        checked ? checkedCount++ : uncheckedCount++;
+      });
+
+      if (checkedCount > 0 && uncheckedCount > 0) {
+        return undefined;
+      }
+
+      return !(checkedCount === 0 || uncheckedCount > 0);
+    }
+  }, {
+    key: "setFilterText",
+    value: function setFilterText(filterText) {
+      this.filterText = _.exists(filterText) ? filterText.toLowerCase() : null;
+      this.markFilteredColumns();
+      this.flattenAndFilterModel();
+    }
+  }, {
+    key: "markFilteredColumns",
+    value: function markFilteredColumns() {
+      var _this6 = this;
+
+      var passesFilter = function passesFilter(item) {
+        if (!_.exists(_this6.filterText)) {
+          return true;
+        }
+
+        var displayName = item.getDisplayName();
+        return displayName == null || displayName.toLowerCase().indexOf(_this6.filterText) !== -1;
+      };
+
+      var recursivelyCheckFilter = function recursivelyCheckFilter(item, parentPasses) {
+        var atLeastOneChildPassed = false;
+
+        if (item.isGroup()) {
+          var groupPasses = passesFilter(item);
+          item.getChildren().forEach(function (child) {
+            var childPasses = recursivelyCheckFilter(child, groupPasses || parentPasses);
+
+            if (childPasses) {
+              atLeastOneChildPassed = childPasses;
+            }
+          });
+        }
+
+        var filterPasses = parentPasses || atLeastOneChildPassed ? true : passesFilter(item);
+        item.setPassesFilter(filterPasses);
+        return filterPasses;
+      };
+
+      this.allColsTree.forEach(function (item) {
+        return recursivelyCheckFilter(item, false);
+      });
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners() {
+      this.fireGroupExpandedEvent();
+      this.fireSelectionChangedEvent();
+    }
+  }, {
+    key: "fireGroupExpandedEvent",
+    value: function fireGroupExpandedEvent() {
+      var expandState = this.getExpandState();
+      this.dispatchEvent({
+        type: 'groupExpanded',
+        state: expandState
+      });
+    }
+  }, {
+    key: "fireSelectionChangedEvent",
+    value: function fireSelectionChangedEvent() {
+      var selectionState = this.getSelectionState();
+      this.dispatchEvent({
+        type: 'selectionChanged',
+        state: selectionState
+      });
+    }
+  }]);
+
+  return PrimaryColsListPanel;
+}(Component);
+PrimaryColsListPanel.TEMPLATE = "<div class=\"".concat(PRIMARY_COLS_LIST_PANEL_CLASS, "\" role=\"presentation\"></div>");
+
+__decorate([Autowired('columnModel')], PrimaryColsListPanel.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('toolPanelColDefService')], PrimaryColsListPanel.prototype, 'colDefService', void 0);
+
+__decorate([Autowired('modelItemUtils')], PrimaryColsListPanel.prototype, 'modelItemUtils', void 0);
+
+__decorate([PreDestroy], PrimaryColsListPanel.prototype, 'destroyColumnTree', null);

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

@@ -0,0 +1,26 @@
+import { BeanStub, VirtualList } from '@ag-grid-community/core';
+import { PrimaryColsListPanel } from './primaryColsListPanel';
+export declare class PrimaryColsListPanelItemDragFeature extends BeanStub {
+  private readonly comp;
+  private readonly virtualList;
+  private columnModel;
+  private dragAndDropService;
+  private currentDragColumn;
+  private lastHoveredColumnItem;
+  private autoScrollService;
+  private moveBlocked;
+  constructor(comp: PrimaryColsListPanel, virtualList: VirtualList);
+  private postConstruct;
+  private columnPanelItemDragStart;
+  private columnPanelItemDragEnd;
+  private createDropTarget;
+  private createAutoScrollService;
+  private onDragging;
+  private getDragColumnItem;
+  private onDragStop;
+  private getMoveDiff;
+  private getCurrentColumns;
+  private getTargetIndex;
+  private onDragLeave;
+  private clearHoveredItems;
+}