ngx-bootstrap
Version:
Native Angular Bootstrap Components
736 lines (720 loc) • 77.9 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('ngx-bootstrap/utils'), require('rxjs/operators'), require('ngx-bootstrap/component-loader'), require('ngx-bootstrap/positioning')) :
typeof define === 'function' && define.amd ? define('ngx-bootstrap/dropdown', ['exports', '@angular/core', 'ngx-bootstrap/utils', 'rxjs/operators', 'ngx-bootstrap/component-loader', 'ngx-bootstrap/positioning'], factory) :
(factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].dropdown = {}),global.ng.core,global.utils,global.rxjs.operators,global.componentLoader,global.positioning));
}(this, (function (exports,core,utils,operators,componentLoader,positioning) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m)
return m.call(o);
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* Default dropdown configuration
*/
var BsDropdownConfig = (function () {
function BsDropdownConfig() {
/**
* default dropdown auto closing behavior
*/
this.autoClose = true;
}
BsDropdownConfig.decorators = [
{ type: core.Injectable }
];
return BsDropdownConfig;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownState = (function () {
function BsDropdownState() {
var _this = this;
this.direction = 'down';
this.isOpenChange = new core.EventEmitter();
this.isDisabledChange = new core.EventEmitter();
this.toggleClick = new core.EventEmitter();
this.dropdownMenu = new Promise(function (resolve) {
_this.resolveDropdownMenu = resolve;
});
}
BsDropdownState.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
BsDropdownState.ctorParameters = function () { return []; };
return BsDropdownState;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownContainerComponent = (function () {
function BsDropdownContainerComponent(_state, cd, _renderer, _element) {
var _this = this;
this._state = _state;
this.cd = cd;
this._renderer = _renderer;
this.isOpen = false;
this._subscription = _state.isOpenChange.subscribe(function (value) {
_this.isOpen = value;
var /** @type {?} */ dropdown = _element.nativeElement.querySelector('.dropdown-menu');
if (dropdown && !utils.isBs3()) {
_this._renderer.addClass(dropdown, 'show');
if (dropdown.classList.contains('dropdown-menu-right')) {
_this._renderer.setStyle(dropdown, 'left', 'auto');
_this._renderer.setStyle(dropdown, 'right', '0');
}
if (_this.direction === 'up') {
_this._renderer.setStyle(dropdown, 'top', 'auto');
_this._renderer.setStyle(dropdown, 'transform', 'translateY(-101%)');
}
}
_this.cd.markForCheck();
_this.cd.detectChanges();
});
}
Object.defineProperty(BsDropdownContainerComponent.prototype, "direction", {
get: /**
* @return {?}
*/ function () {
return this._state.direction;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
BsDropdownContainerComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this._subscription.unsubscribe();
};
BsDropdownContainerComponent.decorators = [
{ type: core.Component, args: [{
selector: 'bs-dropdown-container',
changeDetection: core.ChangeDetectionStrategy.OnPush,
host: {
style: 'display:block;position: absolute;'
},
template: "\n <div [class.dropup]=\"direction === 'up'\"\n [class.dropdown]=\"direction === 'down'\"\n [class.show]=\"isOpen\"\n [class.open]=\"isOpen\"><ng-content></ng-content></div>\n "
}] }
];
/** @nocollapse */
BsDropdownContainerComponent.ctorParameters = function () {
return [
{ type: BsDropdownState, },
{ type: core.ChangeDetectorRef, },
{ type: core.Renderer2, },
{ type: core.ElementRef, },
];
};
return BsDropdownContainerComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownDirective = (function () {
function BsDropdownDirective(_elementRef, _renderer, _viewContainerRef, _cis, _config, _state) {
this._elementRef = _elementRef;
this._renderer = _renderer;
this._viewContainerRef = _viewContainerRef;
this._cis = _cis;
this._config = _config;
this._state = _state;
this._isInlineOpen = false;
this._subscriptions = [];
this._isInited = false;
// set initial dropdown state from config
this._state.autoClose = this._config.autoClose;
// create dropdown component loader
this._dropdown = this._cis
.createLoader(this._elementRef, this._viewContainerRef, this._renderer)
.provide({ provide: BsDropdownState, useValue: this._state });
this.onShown = this._dropdown.onShown;
this.onHidden = this._dropdown.onHidden;
this.isOpenChange = this._state.isOpenChange;
}
Object.defineProperty(BsDropdownDirective.prototype, "autoClose", {
get: /**
* @return {?}
*/ function () {
return this._state.autoClose;
},
set: /**
* Indicates that dropdown will be closed on item or document click,
* and after pressing ESC
* @param {?} value
* @return {?}
*/ function (value) {
this._state.autoClose = value;
},
enumerable: true,
configurable: true
});
Object.defineProperty(BsDropdownDirective.prototype, "isDisabled", {
get: /**
* @return {?}
*/ function () {
return this._isDisabled;
},
set: /**
* Disables dropdown toggle and hides dropdown menu if opened
* @param {?} value
* @return {?}
*/ function (value) {
this._isDisabled = value;
this._state.isDisabledChange.emit(value);
if (value) {
this.hide();
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(BsDropdownDirective.prototype, "isOpen", {
get: /**
* Returns whether or not the popover is currently being shown
* @return {?}
*/ function () {
if (this._showInline) {
return this._isInlineOpen;
}
return this._dropdown.isShown;
},
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
if (value) {
this.show();
}
else {
this.hide();
}
},
enumerable: true,
configurable: true
});
Object.defineProperty(BsDropdownDirective.prototype, "isBs4", {
get: /**
* @return {?}
*/ function () {
return !utils.isBs3();
},
enumerable: true,
configurable: true
});
Object.defineProperty(BsDropdownDirective.prototype, "_showInline", {
get: /**
* @return {?}
*/ function () {
return !this.container;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
BsDropdownDirective.prototype.ngOnInit = /**
* @return {?}
*/
function () {
var _this = this;
// fix: seems there are an issue with `routerLinkActive`
// which result in duplicated call ngOnInit without call to ngOnDestroy
// read more: https://github.com/valor-software/ngx-bootstrap/issues/1885
if (this._isInited) {
return;
}
this._isInited = true;
// attach DOM listeners
this._dropdown.listen({
// because of dropdown inline mode
outsideClick: false,
triggers: this.triggers,
show: function () { return _this.show(); }
});
// toggle visibility on toggle element click
this._subscriptions.push(this._state.toggleClick.subscribe(function (value) { return _this.toggle(value); }));
// hide dropdown if set disabled while opened
this._subscriptions.push(this._state.isDisabledChange
.pipe(operators.filter(function (value) { return value; }))
.subscribe(function (value) { return _this.hide(); }));
};
/**
* Opens an element’s popover. This is considered a “manual” triggering of
* the popover.
*/
/**
* Opens an element’s popover. This is considered a “manual” triggering of
* the popover.
* @return {?}
*/
BsDropdownDirective.prototype.show = /**
* Opens an element’s popover. This is considered a “manual” triggering of
* the popover.
* @return {?}
*/
function () {
var _this = this;
if (this.isOpen || this.isDisabled) {
return;
}
if (this._showInline) {
if (!this._inlinedMenu) {
this._state.dropdownMenu.then(function (dropdownMenu) {
_this._dropdown.attachInline(dropdownMenu.viewContainer, dropdownMenu.templateRef);
_this._inlinedMenu = _this._dropdown._inlineViewRef;
_this.addBs4Polyfills();
})
.catch();
}
this.addBs4Polyfills();
this._isInlineOpen = true;
this.onShown.emit(true);
this._state.isOpenChange.emit(true);
return;
}
this._state.dropdownMenu.then(function (dropdownMenu) {
// check direction in which dropdown should be opened
var /** @type {?} */ _dropup = _this.dropup ||
(typeof _this.dropup !== 'undefined' && _this.dropup);
_this._state.direction = _dropup ? 'up' : 'down';
var /** @type {?} */ _placement = _this.placement || (_dropup ? 'top left' : 'bottom left');
// show dropdown
// show dropdown
_this._dropdown
.attach(BsDropdownContainerComponent)
.to(_this.container)
.position({ attachment: _placement })
.show({
content: dropdownMenu.templateRef,
placement: _placement
});
_this._state.isOpenChange.emit(true);
})
.catch();
};
/**
* Closes an element’s popover. This is considered a “manual” triggering of
* the popover.
*/
/**
* Closes an element’s popover. This is considered a “manual” triggering of
* the popover.
* @return {?}
*/
BsDropdownDirective.prototype.hide = /**
* Closes an element’s popover. This is considered a “manual” triggering of
* the popover.
* @return {?}
*/
function () {
if (!this.isOpen) {
return;
}
if (this._showInline) {
this.removeShowClass();
this.removeDropupStyles();
this._isInlineOpen = false;
this.onHidden.emit(true);
}
else {
this._dropdown.hide();
}
this._state.isOpenChange.emit(false);
};
/**
* Toggles an element’s popover. This is considered a “manual” triggering of
* the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
* only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
*/
/**
* Toggles an element’s popover. This is considered a “manual” triggering of
* the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
* only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
* @param {?=} value
* @return {?}
*/
BsDropdownDirective.prototype.toggle = /**
* Toggles an element’s popover. This is considered a “manual” triggering of
* the popover. With parameter <code>true</code> allows toggling, with parameter <code>false</code>
* only hides opened dropdown. Parameter usage will be removed in ngx-bootstrap v3
* @param {?=} value
* @return {?}
*/
function (value) {
if (this.isOpen || !value) {
return this.hide();
}
return this.show();
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
try {
// clean up subscriptions and destroy dropdown
for (var _a = __values(this._subscriptions), _b = _a.next(); !_b.done; _b = _a.next()) {
var sub = _b.value;
sub.unsubscribe();
}
}
catch (e_1_1) {
e_1 = { error: e_1_1 };
}
finally {
try {
if (_b && !_b.done && (_c = _a.return))
_c.call(_a);
}
finally {
if (e_1)
throw e_1.error;
}
}
this._dropdown.dispose();
var e_1, _c;
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.addBs4Polyfills = /**
* @return {?}
*/
function () {
if (!utils.isBs3()) {
this.addShowClass();
this.checkRightAlignment();
this.addDropupStyles();
}
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.addShowClass = /**
* @return {?}
*/
function () {
if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
this._renderer.addClass(this._inlinedMenu.rootNodes[0], 'show');
}
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.removeShowClass = /**
* @return {?}
*/
function () {
if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
this._renderer.removeClass(this._inlinedMenu.rootNodes[0], 'show');
}
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.checkRightAlignment = /**
* @return {?}
*/
function () {
if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
var /** @type {?} */ isRightAligned = this._inlinedMenu.rootNodes[0].classList.contains('dropdown-menu-right');
this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'left', isRightAligned ? 'auto' : '0');
this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'right', isRightAligned ? '0' : 'auto');
}
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.addDropupStyles = /**
* @return {?}
*/
function () {
if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
// a little hack to not break support of bootstrap 4 beta
this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'top', this.dropup ? 'auto' : '100%');
this._renderer.setStyle(this._inlinedMenu.rootNodes[0], 'transform', this.dropup ? 'translateY(-101%)' : 'translateY(0)');
}
};
/**
* @return {?}
*/
BsDropdownDirective.prototype.removeDropupStyles = /**
* @return {?}
*/
function () {
if (this._inlinedMenu && this._inlinedMenu.rootNodes[0]) {
this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'top');
this._renderer.removeStyle(this._inlinedMenu.rootNodes[0], 'transform');
}
};
BsDropdownDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[bsDropdown],[dropdown]',
exportAs: 'bs-dropdown',
providers: [BsDropdownState],
host: {
'[class.dropup]': 'dropup',
'[class.open]': 'isOpen',
'[class.show]': 'isOpen && isBs4'
}
},] }
];
/** @nocollapse */
BsDropdownDirective.ctorParameters = function () {
return [
{ type: core.ElementRef, },
{ type: core.Renderer2, },
{ type: core.ViewContainerRef, },
{ type: componentLoader.ComponentLoaderFactory, },
{ type: BsDropdownConfig, },
{ type: BsDropdownState, },
];
};
BsDropdownDirective.propDecorators = {
"placement": [{ type: core.Input },],
"triggers": [{ type: core.Input },],
"container": [{ type: core.Input },],
"dropup": [{ type: core.Input },],
"autoClose": [{ type: core.Input },],
"isDisabled": [{ type: core.Input },],
"isOpen": [{ type: core.Input },],
"isOpenChange": [{ type: core.Output },],
"onShown": [{ type: core.Output },],
"onHidden": [{ type: core.Output },],
};
return BsDropdownDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownMenuDirective = (function () {
// tslint:disable:no-any
function BsDropdownMenuDirective(_state, _viewContainer, _templateRef) {
_state.resolveDropdownMenu({
templateRef: _templateRef,
viewContainer: _viewContainer
});
}
BsDropdownMenuDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[bsDropdownMenu],[dropdownMenu]',
exportAs: 'bs-dropdown-menu'
},] }
];
/** @nocollapse */
BsDropdownMenuDirective.ctorParameters = function () {
return [
{ type: BsDropdownState, },
{ type: core.ViewContainerRef, },
{ type: core.TemplateRef, },
];
};
return BsDropdownMenuDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownToggleDirective = (function () {
function BsDropdownToggleDirective(_state, _element) {
var _this = this;
this._state = _state;
this._element = _element;
this.isDisabled = null;
this._subscriptions = [];
// sync is open value with state
this._subscriptions.push(this._state.isOpenChange.subscribe(function (value) { return (_this.isOpen = value); }));
// populate disabled state
this._subscriptions.push(this._state.isDisabledChange.subscribe(function (value) { return (_this.isDisabled = value || null); }));
}
/**
* @return {?}
*/
BsDropdownToggleDirective.prototype.onClick = /**
* @return {?}
*/
function () {
if (this.isDisabled) {
return;
}
this._state.toggleClick.emit(true);
};
/**
* @param {?} event
* @return {?}
*/
BsDropdownToggleDirective.prototype.onDocumentClick = /**
* @param {?} event
* @return {?}
*/
function (event) {
if (this._state.autoClose &&
event.button !== 2 &&
!this._element.nativeElement.contains(event.target)) {
this._state.toggleClick.emit(false);
}
};
/**
* @return {?}
*/
BsDropdownToggleDirective.prototype.onEsc = /**
* @return {?}
*/
function () {
if (this._state.autoClose) {
this._state.toggleClick.emit(false);
}
};
/**
* @return {?}
*/
BsDropdownToggleDirective.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
try {
for (var _a = __values(this._subscriptions), _b = _a.next(); !_b.done; _b = _a.next()) {
var sub = _b.value;
sub.unsubscribe();
}
}
catch (e_1_1) {
e_1 = { error: e_1_1 };
}
finally {
try {
if (_b && !_b.done && (_c = _a.return))
_c.call(_a);
}
finally {
if (e_1)
throw e_1.error;
}
}
var e_1, _c;
};
BsDropdownToggleDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[bsDropdownToggle],[dropdownToggle]',
exportAs: 'bs-dropdown-toggle',
host: {
'[attr.aria-haspopup]': 'true'
}
},] }
];
/** @nocollapse */
BsDropdownToggleDirective.ctorParameters = function () {
return [
{ type: BsDropdownState, },
{ type: core.ElementRef, },
];
};
BsDropdownToggleDirective.propDecorators = {
"isDisabled": [{ type: core.HostBinding, args: ['attr.disabled',] },],
"isOpen": [{ type: core.HostBinding, args: ['attr.aria-expanded',] },],
"onClick": [{ type: core.HostListener, args: ['click', [],] },],
"onDocumentClick": [{ type: core.HostListener, args: ['document:click', ['$event'],] },],
"onEsc": [{ type: core.HostListener, args: ['keyup.esc',] },],
};
return BsDropdownToggleDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
var BsDropdownModule = (function () {
function BsDropdownModule() {
}
// tslint:disable-next-line:no-any
/**
* @param {?=} config
* @return {?}
*/
BsDropdownModule.forRoot = /**
* @param {?=} config
* @return {?}
*/
function (config) {
return {
ngModule: BsDropdownModule,
providers: [
componentLoader.ComponentLoaderFactory,
positioning.PositioningService,
BsDropdownState,
{
provide: BsDropdownConfig,
useValue: config ? config : { autoClose: true }
}
]
};
};
BsDropdownModule.decorators = [
{ type: core.NgModule, args: [{
declarations: [
BsDropdownMenuDirective,
BsDropdownToggleDirective,
BsDropdownContainerComponent,
BsDropdownDirective
],
exports: [
BsDropdownMenuDirective,
BsDropdownToggleDirective,
BsDropdownDirective
],
entryComponents: [BsDropdownContainerComponent]
},] }
];
return BsDropdownModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
exports.BsDropdownDirective = BsDropdownDirective;
exports.BsDropdownMenuDirective = BsDropdownMenuDirective;
exports.BsDropdownToggleDirective = BsDropdownToggleDirective;
exports.BsDropdownContainerComponent = BsDropdownContainerComponent;
exports.BsDropdownState = BsDropdownState;
exports.BsDropdownConfig = BsDropdownConfig;
exports.BsDropdownModule = BsDropdownModule;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-dropdown.umd.js.map","sources":["node_modules/tslib/tslib.es6.js","ng://ngx-bootstrap/dropdown/bs-dropdown.config.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.state.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-container.component.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-menu.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown-toggle.directive.ts","ng://ngx-bootstrap/dropdown/bs-dropdown.module.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    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;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","import { Injectable } from '@angular/core';\n\n/** Default dropdown configuration */\n@Injectable()\nexport class BsDropdownConfig {\n  /** default dropdown auto closing behavior */\n  autoClose = true;\n}\n","import { EventEmitter, Injectable } from '@angular/core';\nimport { BsComponentRef } from 'ngx-bootstrap/component-loader';\n\n@Injectable()\nexport class BsDropdownState {\n  direction: 'down' | 'up' = 'down';\n  autoClose: boolean;\n  isOpenChange = new EventEmitter<boolean>();\n  isDisabledChange = new EventEmitter<boolean>();\n  toggleClick = new EventEmitter<boolean>();\n\n  /**\n   * Content to be displayed as popover.\n   */\n  // tslint:disable:no-any\n  dropdownMenu: Promise<BsComponentRef<any>>;\n  resolveDropdownMenu: (componentRef: BsComponentRef<any>) => void;\n\n  constructor() {\n    this.dropdownMenu = new Promise(resolve => {\n      this.resolveDropdownMenu = resolve;\n    });\n  }\n}\n","import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  OnDestroy,\n  Renderer2\n} from '@angular/core';\nimport { BsDropdownState } from './bs-dropdown.state';\nimport { isBs3 } from 'ngx-bootstrap/utils';\n\n@Component({\n  selector: 'bs-dropdown-container',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    style: 'display:block;position: absolute;'\n  },\n  template: `\n    <div [class.dropup]=\"direction === 'up'\"\n         [class.dropdown]=\"direction === 'down'\"\n         [class.show]=\"isOpen\"\n         [class.open]=\"isOpen\"><ng-content></ng-content></div>\n  `\n})\nexport class BsDropdownContainerComponent implements OnDestroy {\n  isOpen = false;\n\n  get direction(): 'down' | 'up' {\n    return this._state.direction;\n  }\n\n// tslint:disable-next-line:no-any\n  private _subscription: any;\n\n  constructor(\n    private _state: BsDropdownState,\n    private cd: ChangeDetectorRef,\n    private _renderer: Renderer2,\n    _element: ElementRef\n  ) {\n    this._subscription = _state.isOpenChange.subscribe((value: boolean) => {\n      this.isOpen = value;\n      const dropdown = _element.nativeElement.querySelector('.dropdown-menu');\n      if (dropdown && !isBs3()) {\n        this._renderer.addClass(dropdown, 'show');\n        if (dropdown.classList.contains('dropdown-menu-right')) {\n          this._renderer.setStyle(dropdown, 'left', 'auto');\n          this._renderer.setStyle(dropdown, 'right', '0');\n        }\n        if (this.direction === 'up') {\n          this._renderer.setStyle(dropdown, 'top', 'auto');\n          this._renderer.setStyle(\n            dropdown,\n            'transform',\n            'translateY(-101%)'\n          );\n        }\n      }\n      this.cd.markForCheck();\n      this.cd.detectChanges();\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._subscription.unsubscribe();\n  }\n}\n","// tslint:disable:max-file-line-count\nimport {\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  ViewContainerRef\n} from '@angular/core';\nimport { filter } from 'rxjs/operators';\nimport { Subscription } from 'rxjs';\nimport { ComponentLoader, ComponentLoaderFactory, BsComponentRef } from 'ngx-bootstrap/component-loader';\n\nimport { BsDropdownConfig } from './bs-dropdown.config';\nimport { BsDropdownContainerComponent } from './bs-dropdown-container.component';\nimport { BsDropdownState } from './bs-dropdown.state';\nimport { BsDropdownMenuDirective } from './index';\nimport { isBs3 } from 'ngx-bootstrap/utils';\n\n@Directive({\n  selector: '[bsDropdown],[dropdown]',\n  exportAs: 'bs-dropdown',\n  providers: [BsDropdownState],\n  host: {\n    '[class.dropup]': 'dropup',\n    '[class.open]': 'isOpen',\n    '[class.show]': 'isOpen && isBs4'\n  }\n})\nexport class BsDropdownDirective implements OnInit, OnDestroy {\n  /**\n   * Placement of a popover. Accepts: \"top\", \"bottom\", \"left\", \"right\"\n   */\n  @Input() placement: string;\n  /**\n   * Specifies events that should trigger. Supports a space separated list of\n   * event names.\n   */\n  @Input() triggers: string;\n  /**\n   * A selector specifying the element the popover should be appended to.\n   * Currently only supports \"body\".\n   */\n  @Input() container: string;\n\n  /**\n   * This attribute indicates that the dropdown should be opened upwards\n   */\n  @Input() dropup: boolean;\n\n  /**\n   * Indicates that dropdown will be closed on item or document click,\n   * and after pressing ESC\n   */\n  @Input()\n  set autoClose(value: boolean) {\n    this._state.autoClose = value;\n  }\n\n  get autoClose(): boolean {\n    return this._state.autoClose;\n  }\n\n  /**\n   * Disables dropdown toggle and hides dropdown menu if opened\n   */\n  @Input()\n  set isDisabled(value: boolean) {\n    this._isDisabled = value;\n    this._state.isDisabledChange.emit(value);\n    if (value) {\n      this.hide();\n    }\n  }\n\n  get isDisabled(): boolean {\n    return this._isDisabled;\n  }\n\n  /**\n   * Returns whether or not the popover is currently being shown\n   */\n  @Input()\n  get isOpen(): boolean {\n    if (this._showInline) {\n      return this._isInlineOpen;\n    }\n\n    return this._dropdown.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    if (value) {\n      this.show();\n    } else {\n      this.hide();\n    }\n  }\n\n  /**\n   * Emits an event when isOpen change\n   */\n  @Output() isOpenChange: EventEmitter<boolean>;\n\n  /**\n   * Emits an event when the popover is shown\n   */\n  @Output() onShown: EventEmitter<boolean>;\n\n  /**\n   * Emits an event when the popover is hidden\n   */\n  @Output() onHidden: EventEmitter<boolean>;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  // todo: move to component loader\n  private _isInlineOpen = false;\n\n  private get _showInline(): boolean {\n    return !this.container;\n  }\n\n  private _inlinedMenu: EmbeddedViewRef<BsDropdownMenuDirective>;\n\n  private _isDisabled: boolean;\n  private _dropdown: ComponentLoader<BsDropdownContainerCompon