@lemon-fe/kits 1.0.0-21 → 1.0.0-210

package/es/components/DataGrid/modules/row-grouping/rowGrouping/groupFilter/groupFilter.js

@@ -0,0 +1,395 @@
+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 { _, AgPromise, AgSelect, Autowired, Events, PostConstruct, RefSelector, TabGuardComp } from '@ag-grid-community/core';
+export var GroupFilter = /*#__PURE__*/function (_TabGuardComp) {
+  _inherits(GroupFilter, _TabGuardComp);
+
+  var _super = _createSuper(GroupFilter);
+
+  function GroupFilter() {
+    _classCallCheck(this, GroupFilter);
+
+    return _super.call(this,
+    /* html */
+    "\n            <div class=\"ag-group-filter\">\n                <div ref=\"eGroupField\"></div>\n                <div ref=\"eUnderlyingFilter\"></div>\n            </div>\n        ");
+  }
+
+  _createClass(GroupFilter, [{
+    key: "postConstruct",
+    value: function postConstruct() {
+      this.initialiseTabGuard({});
+    }
+  }, {
+    key: "init",
+    value: function init(params) {
+      var _this = this;
+
+      this.params = params;
+      this.validateParams();
+      return this.updateGroups().then(function () {
+        _this.addManagedListener(_this.eventService, Events.EVENT_COLUMN_ROW_GROUP_CHANGED, function () {
+          return _this.onColumnRowGroupChanged();
+        });
+      });
+    }
+  }, {
+    key: "validateParams",
+    value: function validateParams() {
+      var colDef = this.params.colDef;
+
+      if (colDef.field) {
+        _.doOnce(function () {
+          return console.warn('AG Grid: Group Column Filter does not work with the colDef property "field". This property will be ignored.');
+        }, 'groupFilterFieldParam');
+      }
+
+      if (colDef.filterValueGetter) {
+        _.doOnce(function () {
+          return console.warn('AG Grid: Group Column Filter does not work with the colDef property "filterValueGetter". This property will be ignored.');
+        }, 'groupFilterFilterValueGetterParam');
+      }
+
+      if (colDef.filterParams) {
+        _.doOnce(function () {
+          return console.warn('AG Grid: Group Column Filter does not work with the colDef property "filterParams". This property will be ignored.');
+        }, 'groupFilterFilterParams');
+      }
+    }
+  }, {
+    key: "updateGroups",
+    value: function updateGroups() {
+      var sourceColumns = this.updateGroupField();
+      return this.getUnderlyingFilters(sourceColumns);
+    }
+  }, {
+    key: "getSourceColumns",
+    value: function getSourceColumns() {
+      this.groupColumn = this.params.column;
+
+      if (this.gridOptionsService.is('treeData')) {
+        _.doOnce(function () {
+          return console.warn('AG Grid: Group Column Filter does not work with Tree Data enabled. Please disable Tree Data, or use a different filter.');
+        }, 'groupFilterTreeData');
+
+        return [];
+      }
+
+      var sourceColumns = this.columnModel.getSourceColumnsForGroupColumn(this.groupColumn);
+
+      if (!sourceColumns) {
+        _.doOnce(function () {
+          return console.warn('AG Grid: Group Column Filter only works on group columns. Please use a different filter.');
+        }, 'groupFilterNotGroupColumn');
+
+        return [];
+      }
+
+      return sourceColumns;
+    }
+  }, {
+    key: "updateGroupField",
+    value: function updateGroupField() {
+      var _this2 = this;
+
+      _.clearElement(this.eGroupField);
+
+      if (this.eGroupFieldSelect) {
+        this.destroyBean(this.eGroupFieldSelect);
+      }
+
+      var allSourceColumns = this.getSourceColumns();
+      var sourceColumns = allSourceColumns.filter(function (sourceColumn) {
+        return sourceColumn.isFilterAllowed();
+      });
+
+      if (!sourceColumns.length) {
+        this.selectedColumn = undefined;
+
+        _.setDisplayed(this.eGroupField, false);
+
+        return null;
+      }
+
+      if (allSourceColumns.length === 1) {
+        // we only want to hide the group field element if there's only one group column.
+        // If there's one group column that has a filter, but multiple columns in total,
+        // we should still show the select so the user knows which column it's for.
+        this.selectedColumn = sourceColumns[0];
+
+        _.setDisplayed(this.eGroupField, false);
+      } else {
+        // keep the old selected column if it's still valid
+        if (!this.selectedColumn || !sourceColumns.some(function (column) {
+          return column.getId() === _this2.selectedColumn.getId();
+        })) {
+          this.selectedColumn = sourceColumns[0];
+        }
+
+        this.createGroupFieldSelectElement(sourceColumns);
+        this.eGroupField.appendChild(this.eGroupFieldSelect.getGui());
+        this.eGroupField.appendChild(_.loadTemplate(
+        /* html */
+        "<div class=\"ag-filter-separator\"></div>"));
+
+        _.setDisplayed(this.eGroupField, true);
+      }
+
+      return sourceColumns;
+    }
+  }, {
+    key: "createGroupFieldSelectElement",
+    value: function createGroupFieldSelectElement(sourceColumns) {
+      var _this3 = this;
+
+      this.eGroupFieldSelect = this.createManagedBean(new AgSelect());
+      var localeTextFunc = this.localeService.getLocaleTextFunc();
+      this.eGroupFieldSelect.setLabel(localeTextFunc('groupFilterSelect', 'Select field:'));
+      this.eGroupFieldSelect.setLabelAlignment('top');
+      this.eGroupFieldSelect.addOptions(sourceColumns.map(function (sourceColumn) {
+        var _a;
+
+        return {
+          value: sourceColumn.getId(),
+          text: (_a = _this3.columnModel.getDisplayNameForColumn(sourceColumn, 'groupFilter', false)) !== null && _a !== void 0 ? _a : undefined
+        };
+      }));
+      this.eGroupFieldSelect.setValue(this.selectedColumn.getId());
+      this.eGroupFieldSelect.onValueChange(function (newValue) {
+        return _this3.updateSelectedColumn(newValue);
+      });
+      this.eGroupFieldSelect.addCssClass('ag-group-filter-field-select-wrapper');
+
+      if (sourceColumns.length === 1) {
+        this.eGroupFieldSelect.setDisabled(true);
+      }
+    }
+  }, {
+    key: "getUnderlyingFilters",
+    value: function getUnderlyingFilters(sourceColumns) {
+      var _this4 = this;
+
+      if (!sourceColumns) {
+        this.filterColumnPairs = undefined;
+        this.selectedFilter = undefined;
+        this.groupColumn.setFilterActive(false, 'columnRowGroupChanged');
+        return AgPromise.resolve();
+      }
+
+      var filterPromises = [];
+      var filterColumnPairs = [];
+      sourceColumns.forEach(function (column) {
+        var filterWrapper = _this4.filterManager.getOrCreateFilterWrapper(column, 'COLUMN_MENU');
+
+        if (filterWrapper === null || filterWrapper === void 0 ? void 0 : filterWrapper.filterPromise) {
+          filterPromises.push(filterWrapper.filterPromise.then(function (filter) {
+            if (filter) {
+              filterColumnPairs.push({
+                filter: filter,
+                column: column
+              });
+            }
+
+            if (column.getId() === _this4.selectedColumn.getId()) {
+              _this4.selectedFilter = filter !== null && filter !== void 0 ? filter : undefined;
+            }
+
+            return filter;
+          }));
+        }
+      });
+      return AgPromise.all(filterPromises).then(function () {
+        _this4.filterColumnPairs = filterColumnPairs;
+
+        _this4.groupColumn.setFilterActive(_this4.isFilterActive(), 'columnRowGroupChanged');
+      });
+    }
+  }, {
+    key: "addUnderlyingFilterElement",
+    value: function addUnderlyingFilterElement() {
+      var _this5 = this;
+
+      _.clearElement(this.eUnderlyingFilter);
+
+      if (!this.selectedColumn) {
+        return AgPromise.resolve();
+      }
+
+      var filterWrapper = this.filterManager.getOrCreateFilterWrapper(this.selectedColumn, 'COLUMN_MENU');
+
+      if (!filterWrapper) {
+        return AgPromise.resolve();
+      }
+
+      return filterWrapper.guiPromise.then(function (gui) {
+        var _a;
+
+        _this5.eUnderlyingFilter.appendChild(gui);
+
+        (_a = filterWrapper.filterPromise) === null || _a === void 0 ? void 0 : _a.then(function (filter) {
+          var _a, _b;
+
+          (_a = filter === null || filter === void 0 ? void 0 : filter.afterGuiAttached) === null || _a === void 0 ? void 0 : _a.call(filter, _this5.afterGuiAttachedParams);
+
+          if (!((_b = _this5.afterGuiAttachedParams) === null || _b === void 0 ? void 0 : _b.suppressFocus) && _this5.eGroupFieldSelect && !_this5.eGroupFieldSelect.isDisabled()) {
+            _this5.eGroupFieldSelect.getFocusableElement().focus();
+          }
+        });
+      });
+    }
+  }, {
+    key: "updateSelectedColumn",
+    value: function updateSelectedColumn(columnId) {
+      var _a, _b;
+
+      if (!columnId) {
+        return;
+      }
+
+      (_b = (_a = this.selectedFilter) === null || _a === void 0 ? void 0 : _a.afterGuiDetached) === null || _b === void 0 ? void 0 : _b.call(_a);
+      var selectedFilterColumnPair = this.getFilterColumnPair(columnId);
+      this.selectedColumn = selectedFilterColumnPair === null || selectedFilterColumnPair === void 0 ? void 0 : selectedFilterColumnPair.column;
+      this.selectedFilter = selectedFilterColumnPair === null || selectedFilterColumnPair === void 0 ? void 0 : selectedFilterColumnPair.filter;
+      this.dispatchEvent({
+        type: GroupFilter.EVENT_SELECTED_COLUMN_CHANGED
+      });
+      this.addUnderlyingFilterElement();
+    }
+  }, {
+    key: "isFilterActive",
+    value: function isFilterActive() {
+      var _a;
+
+      return !!((_a = this.filterColumnPairs) === null || _a === void 0 ? void 0 : _a.some(function (_ref) {
+        var filter = _ref.filter;
+        return filter.isFilterActive();
+      }));
+    }
+  }, {
+    key: "doesFilterPass",
+    value: function doesFilterPass() {
+      return true;
+    }
+  }, {
+    key: "getModel",
+    value: function getModel() {
+      return null;
+    }
+  }, {
+    key: "setModel",
+    value: function setModel() {
+      return AgPromise.resolve();
+    }
+  }, {
+    key: "afterGuiAttached",
+    value: function afterGuiAttached(params) {
+      this.afterGuiAttachedParams = params;
+      this.addUnderlyingFilterElement();
+    }
+  }, {
+    key: "afterGuiDetached",
+    value: function afterGuiDetached() {
+      var _a, _b;
+
+      _.clearElement(this.eUnderlyingFilter);
+
+      (_b = (_a = this.selectedFilter) === null || _a === void 0 ? void 0 : _a.afterGuiDetached) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+  }, {
+    key: "onColumnRowGroupChanged",
+    value: function onColumnRowGroupChanged() {
+      var _this6 = this;
+
+      this.updateGroups().then(function () {
+        _this6.dispatchEvent({
+          type: GroupFilter.EVENT_COLUMN_ROW_GROUP_CHANGED
+        });
+
+        _this6.eventService.dispatchEvent({
+          type: 'filterAllowedUpdated'
+        });
+      });
+    }
+  }, {
+    key: "getFilterColumnPair",
+    value: function getFilterColumnPair(columnId) {
+      var _a;
+
+      if (!columnId) {
+        return undefined;
+      }
+
+      return (_a = this.filterColumnPairs) === null || _a === void 0 ? void 0 : _a.find(function (_ref2) {
+        var column = _ref2.column;
+        return column.getId() === columnId;
+      });
+    }
+  }, {
+    key: "getSelectedFilter",
+    value: function getSelectedFilter() {
+      return this.selectedFilter;
+    }
+  }, {
+    key: "getSelectedColumn",
+    value: function getSelectedColumn() {
+      return this.selectedColumn;
+    }
+  }, {
+    key: "isFilterAllowed",
+    value: function isFilterAllowed() {
+      return !!this.selectedColumn;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(GroupFilter.prototype), "destroy", this).call(this);
+    }
+  }]);
+
+  return GroupFilter;
+}(TabGuardComp);
+GroupFilter.EVENT_COLUMN_ROW_GROUP_CHANGED = 'columnRowGroupChanged';
+GroupFilter.EVENT_SELECTED_COLUMN_CHANGED = 'selectedColumnChanged';
+
+__decorate([Autowired('filterManager')], GroupFilter.prototype, "filterManager", void 0);
+
+__decorate([Autowired('columnModel')], GroupFilter.prototype, "columnModel", void 0);
+
+__decorate([RefSelector('eGroupField')], GroupFilter.prototype, "eGroupField", void 0);
+
+__decorate([RefSelector('eUnderlyingFilter')], GroupFilter.prototype, "eUnderlyingFilter", void 0);
+
+__decorate([PostConstruct], GroupFilter.prototype, "postConstruct", null);

package/es/components/DataGrid/modules/row-grouping/rowGrouping/groupFilter/groupFloatingFilter.d.ts

@@ -0,0 +1,23 @@
+import { AgPromise, Component, FilterChangedEvent, IFloatingFilterComp, IFloatingFilterParams } from '@ag-grid-community/core';
+import { GroupFilter } from './groupFilter';
+export declare class GroupFloatingFilterComp extends Component implements IFloatingFilterComp<GroupFilter> {
+    private readonly columnModel;
+    private readonly filterManager;
+    private readonly eFloatingFilter;
+    private params;
+    private eFloatingFilterText;
+    private parentFilterInstance;
+    private underlyingFloatingFilter;
+    private showingUnderlyingFloatingFilter;
+    private columnVisibleChangedListener;
+    constructor();
+    init(params: IFloatingFilterParams<GroupFilter>): AgPromise<void>;
+    private setupReadOnlyFloatingFilterElement;
+    private setupUnderlyingFloatingFilterElement;
+    private onColumnVisibleChanged;
+    onParentModelChanged(_model: null, event: FilterChangedEvent): void;
+    private updateDisplayedValue;
+    private onSelectedColumnChanged;
+    private onColumnRowGroupChanged;
+    destroy(): void;
+}

package/es/components/DataGrid/modules/row-grouping/rowGrouping/groupFilter/groupFloatingFilter.js

@@ -0,0 +1,207 @@
+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 { _, AgInputTextField, AgPromise, Autowired, Column, Component, RefSelector } from '@ag-grid-community/core';
+import { GroupFilter } from "./groupFilter";
+export var GroupFloatingFilterComp = /*#__PURE__*/function (_Component) {
+  _inherits(GroupFloatingFilterComp, _Component);
+
+  var _super = _createSuper(GroupFloatingFilterComp);
+
+  function GroupFloatingFilterComp() {
+    _classCallCheck(this, GroupFloatingFilterComp);
+
+    return _super.call(this,
+    /* html */
+    "\n            <div ref=\"eFloatingFilter\" class=\"ag-group-floating-filter ag-floating-filter-input\" role=\"presentation\"></div>\n        ");
+  }
+
+  _createClass(GroupFloatingFilterComp, [{
+    key: "init",
+    value: function init(params) {
+      var _this = this;
+
+      this.params = params; // we only support showing the underlying floating filter for multiple group columns
+
+      var canShowUnderlyingFloatingFilter = this.gridOptionsService.get('groupDisplayType') === 'multipleColumns';
+      return new AgPromise(function (resolve) {
+        _this.params.parentFilterInstance(function (parentFilterInstance) {
+          _this.parentFilterInstance = parentFilterInstance;
+
+          if (canShowUnderlyingFloatingFilter) {
+            _this.setupUnderlyingFloatingFilterElement().then(function () {
+              return resolve();
+            });
+          } else {
+            _this.setupReadOnlyFloatingFilterElement();
+
+            resolve();
+          }
+        });
+      }).then(function () {
+        _this.addManagedListener(_this.parentFilterInstance, GroupFilter.EVENT_SELECTED_COLUMN_CHANGED, function () {
+          return _this.onSelectedColumnChanged();
+        });
+
+        _this.addManagedListener(_this.parentFilterInstance, GroupFilter.EVENT_COLUMN_ROW_GROUP_CHANGED, function () {
+          return _this.onColumnRowGroupChanged();
+        });
+      });
+      ;
+    }
+  }, {
+    key: "setupReadOnlyFloatingFilterElement",
+    value: function setupReadOnlyFloatingFilterElement() {
+      var _this2 = this;
+
+      if (!this.eFloatingFilterText) {
+        this.eFloatingFilterText = this.createManagedBean(new AgInputTextField());
+        var displayName = this.columnModel.getDisplayNameForColumn(this.params.column, 'header', true);
+        var translate = this.localeService.getLocaleTextFunc();
+        this.eFloatingFilterText.setDisabled(true).setInputAriaLabel("".concat(displayName, " ").concat(translate('ariaFilterInput', 'Filter Input'))).addGuiEventListener('click', function () {
+          return _this2.params.showParentFilter();
+        });
+      }
+
+      this.updateDisplayedValue();
+      this.eFloatingFilter.appendChild(this.eFloatingFilterText.getGui());
+    }
+  }, {
+    key: "setupUnderlyingFloatingFilterElement",
+    value: function setupUnderlyingFloatingFilterElement() {
+      var _this3 = this;
+
+      this.showingUnderlyingFloatingFilter = false;
+      this.underlyingFloatingFilter = undefined;
+
+      _.clearElement(this.eFloatingFilter);
+
+      var column = this.parentFilterInstance.getSelectedColumn(); // we can only show the underlying filter if there is one instance (e.g. the underlying column is not visible)
+
+      if (column && !column.isVisible()) {
+        var compDetails = this.filterManager.getFloatingFilterCompDetails(column, this.params.showParentFilter);
+
+        if (compDetails) {
+          if (!this.columnVisibleChangedListener) {
+            this.columnVisibleChangedListener = this.addManagedListener(column, Column.EVENT_VISIBLE_CHANGED, this.onColumnVisibleChanged.bind(this));
+          }
+
+          return compDetails.newAgStackInstance().then(function (floatingFilter) {
+            var _a, _b;
+
+            _this3.underlyingFloatingFilter = floatingFilter;
+            (_a = _this3.underlyingFloatingFilter) === null || _a === void 0 ? void 0 : _a.onParentModelChanged((_b = _this3.parentFilterInstance.getSelectedFilter()) === null || _b === void 0 ? void 0 : _b.getModel());
+
+            _this3.appendChild(floatingFilter.getGui());
+
+            _this3.showingUnderlyingFloatingFilter = true;
+          });
+        }
+      } // fallback to the read-only version
+
+
+      this.setupReadOnlyFloatingFilterElement();
+      return AgPromise.resolve();
+    }
+  }, {
+    key: "onColumnVisibleChanged",
+    value: function onColumnVisibleChanged() {
+      this.setupUnderlyingFloatingFilterElement();
+    }
+  }, {
+    key: "onParentModelChanged",
+    value: function onParentModelChanged(_model, event) {
+      var _a, _b;
+
+      if (this.showingUnderlyingFloatingFilter) {
+        (_a = this.underlyingFloatingFilter) === null || _a === void 0 ? void 0 : _a.onParentModelChanged((_b = this.parentFilterInstance.getSelectedFilter()) === null || _b === void 0 ? void 0 : _b.getModel(), event);
+      } else {
+        this.updateDisplayedValue();
+      }
+    }
+  }, {
+    key: "updateDisplayedValue",
+    value: function updateDisplayedValue() {
+      if (!this.parentFilterInstance || !this.eFloatingFilterText) {
+        return;
+      }
+
+      var selectedFilter = this.parentFilterInstance.getSelectedFilter();
+
+      if (!selectedFilter) {
+        this.eFloatingFilterText.setValue('');
+        this.eFloatingFilterText.setDisplayed(false);
+        return;
+      }
+
+      this.eFloatingFilterText.setDisplayed(true);
+
+      if (selectedFilter.getModelAsString) {
+        var filterModel = selectedFilter.getModel();
+        this.eFloatingFilterText.setValue(filterModel == null ? '' : selectedFilter.getModelAsString(filterModel));
+      } else {
+        this.eFloatingFilterText.setValue('');
+      }
+    }
+  }, {
+    key: "onSelectedColumnChanged",
+    value: function onSelectedColumnChanged() {
+      if (!this.showingUnderlyingFloatingFilter) {
+        this.updateDisplayedValue();
+      }
+    }
+  }, {
+    key: "onColumnRowGroupChanged",
+    value: function onColumnRowGroupChanged() {
+      if (!this.showingUnderlyingFloatingFilter) {
+        this.updateDisplayedValue();
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(GroupFloatingFilterComp.prototype), "destroy", this).call(this);
+    }
+  }]);
+
+  return GroupFloatingFilterComp;
+}(Component);
+
+__decorate([Autowired('columnModel')], GroupFloatingFilterComp.prototype, "columnModel", void 0);
+
+__decorate([Autowired('filterManager')], GroupFloatingFilterComp.prototype, "filterManager", void 0);
+
+__decorate([RefSelector('eFloatingFilter')], GroupFloatingFilterComp.prototype, "eFloatingFilter", void 0);

package/es/components/DataGrid/modules/row-grouping/rowGrouping/groupStage.d.ts

@@ -12,11 +12,12 @@ export declare class GroupStage extends BeanStub implements IRowNodeStage {
     private oldGroupDisplayColIds;
     private postConstruct;
     execute(params: StageExecuteParams): void;
-    private positionLeafsAboveGroups;
+    private positionLeafsAndGroups;
     private createGroupingDetails;
     private handleTransaction;
     private sortChildren;
     private orderGroups;
+    private getInitialGroupOrderComparator;
     private getExistingPathForNode;
     private moveNodesInWrongPath;
     private moveNode;