ngx-bootstrap
Version:
Native Angular Bootstrap Components
925 lines (913 loc) • 87.6 kB
JavaScript
import { Injectable, Component, ElementRef, HostListener, Renderer2, Directive, EventEmitter, Input, Output, ViewContainerRef, RendererFactory2, NgModule } from '@angular/core';
import { isBs3, Utils, document as document$1, window as window$1 } from 'ngx-bootstrap/utils';
import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
import { PositioningService } from 'ngx-bootstrap/positioning';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class BsModalRef {
constructor() {
/**
* Hides the modal
*/
this.hide = Function;
}
}
BsModalRef.decorators = [
{ type: Injectable }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class ModalBackdropOptions {
/**
* @param {?} options
*/
constructor(options) {
this.animate = true;
Object.assign(this, options);
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class ModalOptions {
}
ModalOptions.decorators = [
{ type: Injectable }
];
const /** @type {?} */ modalConfigDefaults = {
backdrop: true,
keyboard: true,
focus: true,
show: false,
ignoreBackdropClick: false,
class: '',
animated: true,
initialState: {}
};
const /** @type {?} */ CLASS_NAME = {
SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
BACKDROP: 'modal-backdrop',
OPEN: 'modal-open',
FADE: 'fade',
IN: 'in',
// bs3
SHOW: 'show' // bs4
};
const /** @type {?} */ TRANSITION_DURATIONS = {
MODAL: 300,
BACKDROP: 150
};
const /** @type {?} */ DISMISS_REASONS = {
BACKRDOP: 'backdrop-click',
ESC: 'esc'
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class ModalContainerComponent {
/**
* @param {?} options
* @param {?} _element
* @param {?} _renderer
*/
constructor(options, _element, _renderer) {
this._element = _element;
this._renderer = _renderer;
this.isShown = false;
this.isModalHiding = false;
this.config = Object.assign({}, options);
}
/**
* @return {?}
*/
ngOnInit() {
if (this.isAnimated) {
this._renderer.addClass(this._element.nativeElement, CLASS_NAME.FADE);
}
this._renderer.setStyle(this._element.nativeElement, 'display', 'block');
setTimeout(() => {
this.isShown = true;
this._renderer.addClass(this._element.nativeElement, isBs3() ? CLASS_NAME.IN : CLASS_NAME.SHOW);
}, this.isAnimated ? TRANSITION_DURATIONS.BACKDROP : 0);
if (document && document.body) {
if (this.bsModalService.getModalsCount() === 1) {
this.bsModalService.checkScrollbar();
this.bsModalService.setScrollbar();
}
this._renderer.addClass(document.body, CLASS_NAME.OPEN);
}
if (this._element.nativeElement) {
this._element.nativeElement.focus();
}
}
/**
* @param {?} event
* @return {?}
*/
onClick(event) {
if (this.config.ignoreBackdropClick ||
this.config.backdrop === 'static' ||
event.target !== this._element.nativeElement) {
return;
}
this.bsModalService.setDismissReason(DISMISS_REASONS.BACKRDOP);
this.hide();
}
/**
* @param {?} event
* @return {?}
*/
onEsc(event) {
if (!this.isShown) {
return;
}
// tslint:disable-next-line:deprecation
if (event.keyCode === 27 || event.key === 'Escape') {
event.preventDefault();
}
if (this.config.keyboard &&
this.level === this.bsModalService.getModalsCount()) {
this.bsModalService.setDismissReason(DISMISS_REASONS.ESC);
this.hide();
}
}
/**
* @return {?}
*/
ngOnDestroy() {
if (this.isShown) {
this.hide();
}
}
/**
* @return {?}
*/
hide() {
if (this.isModalHiding || !this.isShown) {
return;
}
this.isModalHiding = true;
this._renderer.removeClass(this._element.nativeElement, isBs3() ? CLASS_NAME.IN : CLASS_NAME.SHOW);
setTimeout(() => {
this.isShown = false;
if (document &&
document.body &&
this.bsModalService.getModalsCount() === 1) {
this._renderer.removeClass(document.body, CLASS_NAME.OPEN);
}
this.bsModalService.hide(this.level);
this.isModalHiding = false;
}, this.isAnimated ? TRANSITION_DURATIONS.MODAL : 0);
}
}
ModalContainerComponent.decorators = [
{ type: Component, args: [{
selector: 'modal-container',
template: `
<div [class]="'modal-dialog' + (config.class ? ' ' + config.class : '')" role="document">
<div class="modal-content">
<ng-content></ng-content>
</div>
</div>
`,
host: {
class: 'modal',
role: 'dialog',
tabindex: '-1',
'[attr.aria-modal]': 'true'
}
}] }
];
/** @nocollapse */
ModalContainerComponent.ctorParameters = () => [
{ type: ModalOptions, },
{ type: ElementRef, },
{ type: Renderer2, },
];
ModalContainerComponent.propDecorators = {
"onClick": [{ type: HostListener, args: ['click', ['$event'],] },],
"onEsc": [{ type: HostListener, args: ['window:keydown.esc', ['$event'],] },],
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* This component will be added as background layout for modals if enabled
*/
class ModalBackdropComponent {
/**
* @param {?} element
* @param {?} renderer
*/
constructor(element, renderer) {
this._isShown = false;
this.element = element;
this.renderer = renderer;
}
/**
* @return {?}
*/
get isAnimated() {
return this._isAnimated;
}
/**
* @param {?} value
* @return {?}
*/
set isAnimated(value) {
this._isAnimated = value;
// this.renderer.setElementClass(this.element.nativeElement, `${ClassName.FADE}`, value);
}
/**
* @return {?}
*/
get isShown() {
return this._isShown;
}
/**
* @param {?} value
* @return {?}
*/
set isShown(value) {
this._isShown = value;
if (value) {
this.renderer.addClass(this.element.nativeElement, `${CLASS_NAME.IN}`);
}
else {
this.renderer.removeClass(this.element.nativeElement, `${CLASS_NAME.IN}`);
}
if (!isBs3()) {
if (value) {
this.renderer.addClass(this.element.nativeElement, `${CLASS_NAME.SHOW}`);
}
else {
this.renderer.removeClass(this.element.nativeElement, `${CLASS_NAME.SHOW}`);
}
}
}
/**
* @return {?}
*/
ngOnInit() {
if (this.isAnimated) {
this.renderer.addClass(this.element.nativeElement, `${CLASS_NAME.FADE}`);
Utils.reflow(this.element.nativeElement);
}
this.isShown = true;
}
}
ModalBackdropComponent.decorators = [
{ type: Component, args: [{
selector: 'bs-modal-backdrop',
template: ' ',
host: { class: CLASS_NAME.BACKDROP }
}] }
];
/** @nocollapse */
ModalBackdropComponent.ctorParameters = () => [
{ type: ElementRef, },
{ type: Renderer2, },
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
const /** @type {?} */ TRANSITION_DURATION = 300;
const /** @type {?} */ BACKDROP_TRANSITION_DURATION = 150;
/**
* Mark any code with directive to show it's content in modal
*/
class ModalDirective {
/**
* @param {?} _element
* @param {?} _viewContainerRef
* @param {?} _renderer
* @param {?} clf
*/
constructor(_element, _viewContainerRef, _renderer, clf) {
this._element = _element;
this._renderer = _renderer;
/**
* This event fires immediately when the `show` instance method is called.
*/
this.onShow = new EventEmitter();
/**
* This event is fired when the modal has been made visible to the user
* (will wait for CSS transitions to complete)
*/
this.onShown = new EventEmitter();
/**
* This event is fired immediately when
* the hide instance method has been called.
*/
this.onHide = new EventEmitter();
/**
* This event is fired when the modal has finished being
* hidden from the user (will wait for CSS transitions to complete).
*/
this.onHidden = new EventEmitter();
this._isShown = false;
this.isBodyOverflowing = false;
this.originalBodyPadding = 0;
this.scrollbarWidth = 0;
this.timerHideModal = 0;
this.timerRmBackDrop = 0;
this.isNested = false;
this._backdrop = clf.createLoader(_element, _viewContainerRef, _renderer);
}
/**
* allows to set modal configuration via element property
* @param {?} conf
* @return {?}
*/
set config(conf) {
this._config = this.getConfig(conf);
}
/**
* @return {?}
*/
get config() {
return this._config;
}
/**
* @return {?}
*/
get isShown() {
return this._isShown;
}
/**
* @param {?} event
* @return {?}
*/
onClick(event) {
if (this.config.ignoreBackdropClick ||
this.config.backdrop === 'static' ||
event.target !== this._element.nativeElement) {
return;
}
this.dismissReason = DISMISS_REASONS.BACKRDOP;
this.hide(event);
}
/**
* @param {?} event
* @return {?}
*/
onEsc(event) {
if (!this._isShown) {
return;
}
// tslint:disable-next-line:deprecation
if (event.keyCode === 27 || event.key === 'Escape') {
event.preventDefault();
}
if (this.config.keyboard) {
this.dismissReason = DISMISS_REASONS.ESC;
this.hide();
}
}
/**
* @return {?}
*/
ngOnDestroy() {
this.config = void 0;
if (this._isShown) {
this._isShown = false;
this.hideModal();
this._backdrop.dispose();
}
}
/**
* @return {?}
*/
ngOnInit() {
this._config = this._config || this.getConfig();
setTimeout(() => {
if (this._config.show) {
this.show();
}
}, 0);
}
/**
* Allows to manually toggle modal visibility
* @return {?}
*/
toggle() {
return this._isShown ? this.hide() : this.show();
}
/**
* Allows to manually open modal
* @return {?}
*/
show() {
this.dismissReason = null;
this.onShow.emit(this);
if (this._isShown) {
return;
}
clearTimeout(this.timerHideModal);
clearTimeout(this.timerRmBackDrop);
this._isShown = true;
this.checkScrollbar();
this.setScrollbar();
if (document$1 && document$1.body) {
if (document$1.body.classList.contains(CLASS_NAME.OPEN)) {
this.isNested = true;
}
else {
this._renderer.addClass(document$1.body, CLASS_NAME.OPEN);
}
}
this.showBackdrop(() => {
this.showElement();
});
}
/**
* Allows to manually close modal
* @param {?=} event
* @return {?}
*/
hide(event) {
if (event) {
event.preventDefault();
}
this.onHide.emit(this);
// todo: add an option to prevent hiding
if (!this._isShown) {
return;
}
window$1.clearTimeout(this.timerHideModal);
window$1.clearTimeout(this.timerRmBackDrop);
this._isShown = false;
this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.IN);
if (!isBs3()) {
this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);
}
// this._addClassIn = false;
if (this._config.animated) {
this.timerHideModal = window$1.setTimeout(() => this.hideModal(), TRANSITION_DURATION);
}
else {
this.hideModal();
}
}
/**
* Private methods \@internal
* @param {?=} config
* @return {?}
*/
getConfig(config) {
return Object.assign({}, modalConfigDefaults, config);
}
/**
* Show dialog
* \@internal
* @return {?}
*/
showElement() {
// todo: replace this with component loader usage
if (!this._element.nativeElement.parentNode ||
this._element.nativeElement.parentNode.nodeType !== Node.ELEMENT_NODE) {
// don't move modals dom position
if (document$1 && document$1.body) {
document$1.body.appendChild(this._element.nativeElement);
}
}
this._renderer.setAttribute(this._element.nativeElement, 'aria-hidden', 'false');
this._renderer.setAttribute(this._element.nativeElement, 'aria-modal', 'true');
this._renderer.setStyle(this._element.nativeElement, 'display', 'block');
this._renderer.setProperty(this._element.nativeElement, 'scrollTop', 0);
if (this._config.animated) {
Utils.reflow(this._element.nativeElement);
}
// this._addClassIn = true;
this._renderer.addClass(this._element.nativeElement, CLASS_NAME.IN);
if (!isBs3()) {
this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);
}
const /** @type {?} */ transitionComplete = () => {
if (this._config.focus) {
this._element.nativeElement.focus();
}
this.onShown.emit(this);
};
if (this._config.animated) {
setTimeout(transitionComplete, TRANSITION_DURATION);
}
else {
transitionComplete();
}
}
/**
* \@internal
* @return {?}
*/
hideModal() {
this._renderer.setAttribute(this._element.nativeElement, 'aria-hidden', 'true');
this._renderer.setStyle(this._element.nativeElement, 'display', 'none');
this.showBackdrop(() => {
if (!this.isNested) {
if (document$1 && document$1.body) {
this._renderer.removeClass(document$1.body, CLASS_NAME.OPEN);
}
this.resetScrollbar();
}
this.resetAdjustments();
this.focusOtherModal();
this.onHidden.emit(this);
});
}
/**
* \@internal
* @param {?=} callback
* @return {?}
*/
showBackdrop(callback) {
if (this._isShown &&
this.config.backdrop &&
(!this.backdrop || !this.backdrop.instance.isShown)) {
this.removeBackdrop();
this._backdrop
.attach(ModalBackdropComponent)
.to('body')
.show({ isAnimated: this._config.animated });
this.backdrop = this._backdrop._componentRef;
if (!callback) {
return;
}
if (!this._config.animated) {
callback();
return;
}
setTimeout(callback, BACKDROP_TRANSITION_DURATION);
}
else if (!this._isShown && this.backdrop) {
this.backdrop.instance.isShown = false;
const /** @type {?} */ callbackRemove = () => {
this.removeBackdrop();
if (callback) {
callback();
}
};
if (this.backdrop.instance.isAnimated) {
this.timerRmBackDrop = window$1.setTimeout(callbackRemove, BACKDROP_TRANSITION_DURATION);
}
else {
callbackRemove();
}
}
else if (callback) {
callback();
}
}
/**
* \@internal
* @return {?}
*/
removeBackdrop() {
this._backdrop.hide();
}
/**
* Events tricks
* @return {?}
*/
focusOtherModal() {
if (this._element.nativeElement.parentElement == null) {
return;
}
const /** @type {?} */ otherOpenedModals = this._element.nativeElement.parentElement.querySelectorAll('.in[bsModal]');
if (!otherOpenedModals.length) {
return;
}
otherOpenedModals[otherOpenedModals.length - 1].focus();
}
/**
* \@internal
* @return {?}
*/
resetAdjustments() {
this._renderer.setStyle(this._element.nativeElement, 'paddingLeft', '');
this._renderer.setStyle(this._element.nativeElement, 'paddingRight', '');
}
/**
* \@internal
* @return {?}
*/
checkScrollbar() {
this.isBodyOverflowing = document$1.body.clientWidth < window$1.innerWidth;
this.scrollbarWidth = this.getScrollbarWidth();
}
/**
* @return {?}
*/
setScrollbar() {
if (!document$1) {
return;
}
this.originalBodyPadding = parseInt(window$1
.getComputedStyle(document$1.body)
.getPropertyValue('padding-right') || 0, 10);
if (this.isBodyOverflowing) {
document$1.body.style.paddingRight = `${this.originalBodyPadding +
this.scrollbarWidth}px`;
}
}
/**
* @return {?}
*/
resetScrollbar() {
document$1.body.style.paddingRight = `${this.originalBodyPadding}px`;
}
/**
* @return {?}
*/
getScrollbarWidth() {
const /** @type {?} */ scrollDiv = this._renderer.createElement('div');
this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
this._renderer.appendChild(document$1.body, scrollDiv);
const /** @type {?} */ scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
this._renderer.removeChild(document$1.body, scrollDiv);
return scrollbarWidth;
}
}
ModalDirective.decorators = [
{ type: Directive, args: [{
selector: '[bsModal]',
exportAs: 'bs-modal'
},] }
];
/** @nocollapse */
ModalDirective.ctorParameters = () => [
{ type: ElementRef, },
{ type: ViewContainerRef, },
{ type: Renderer2, },
{ type: ComponentLoaderFactory, },
];
ModalDirective.propDecorators = {
"config": [{ type: Input },],
"onShow": [{ type: Output },],
"onShown": [{ type: Output },],
"onHide": [{ type: Output },],
"onHidden": [{ type: Output },],
"onClick": [{ type: HostListener, args: ['click', ['$event'],] },],
"onEsc": [{ type: HostListener, args: ['keydown.esc', ['$event'],] },],
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class BsModalService {
/**
* @param {?} rendererFactory
* @param {?} clf
*/
constructor(rendererFactory, clf) {
this.clf = clf;
// constructor props
this.config = modalConfigDefaults;
// tslint:disable-next-line:no-any
this.onShow = new EventEmitter();
// tslint:disable-next-line:no-any
this.onShown = new EventEmitter();
// tslint:disable-next-line:no-any
this.onHide = new EventEmitter();
// tslint:disable-next-line:no-any
this.onHidden = new EventEmitter();
this.isBodyOverflowing = false;
this.originalBodyPadding = 0;
this.scrollbarWidth = 0;
this.modalsCount = 0;
this.lastDismissReason = '';
this.loaders = [];
this._backdropLoader = this.clf.createLoader(null, null, null);
this._renderer = rendererFactory.createRenderer(null, null);
}
/**
* Shows a modal
* @param {?} content
* @param {?=} config
* @return {?}
*/
show(content, config) {
this.modalsCount++;
this._createLoaders();
this.config = Object.assign({}, modalConfigDefaults, config);
this._showBackdrop();
this.lastDismissReason = null;
return this._showModal(content);
}
/**
* @param {?} level
* @return {?}
*/
hide(level) {
if (this.modalsCount === 1) {
this._hideBackdrop();
this.resetScrollbar();
}
this.modalsCount = this.modalsCount >= 1 ? this.modalsCount - 1 : 0;
setTimeout(() => {
this._hideModal(level);
this.removeLoaders(level);
}, this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0);
}
/**
* @return {?}
*/
_showBackdrop() {
const /** @type {?} */ isBackdropEnabled = this.config.backdrop || this.config.backdrop === 'static';
const /** @type {?} */ isBackdropInDOM = !this.backdropRef || !this.backdropRef.instance.isShown;
if (this.modalsCount === 1) {
this.removeBackdrop();
if (isBackdropEnabled && isBackdropInDOM) {
this._backdropLoader
.attach(ModalBackdropComponent)
.to('body')
.show({ isAnimated: this.config.animated });
this.backdropRef = this._backdropLoader._componentRef;
}
}
}
/**
* @return {?}
*/
_hideBackdrop() {
if (!this.backdropRef) {
return;
}
this.backdropRef.instance.isShown = false;
const /** @type {?} */ duration = this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0;
setTimeout(() => this.removeBackdrop(), duration);
}
/**
* @param {?} content
* @return {?}
*/
_showModal(content) {
const /** @type {?} */ modalLoader = this.loaders[this.loaders.length - 1];
const /** @type {?} */ bsModalRef = new BsModalRef();
const /** @type {?} */ modalContainerRef = modalLoader
.provide({ provide: ModalOptions, useValue: this.config })
.provide({ provide: BsModalRef, useValue: bsModalRef })
.attach(ModalContainerComponent)
.to('body')
.show({ content, isAnimated: this.config.animated, initialState: this.config.initialState, bsModalService: this });
modalContainerRef.instance.level = this.getModalsCount();
bsModalRef.hide = () => {
modalContainerRef.instance.hide();
};
bsModalRef.content = modalLoader.getInnerComponent() || null;
return bsModalRef;
}
/**
* @param {?} level
* @return {?}
*/
_hideModal(level) {
const /** @type {?} */ modalLoader = this.loaders[level - 1];
if (modalLoader) {
modalLoader.hide();
}
}
/**
* @return {?}
*/
getModalsCount() {
return this.modalsCount;
}
/**
* @param {?} reason
* @return {?}
*/
setDismissReason(reason) {
this.lastDismissReason = reason;
}
/**
* @return {?}
*/
removeBackdrop() {
this._backdropLoader.hide();
this.backdropRef = null;
}
/**
* \@internal
* @return {?}
*/
checkScrollbar() {
this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;
this.scrollbarWidth = this.getScrollbarWidth();
}
/**
* @return {?}
*/
setScrollbar() {
if (!document) {
return;
}
this.originalBodyPadding = parseInt(window
.getComputedStyle(document.body)
.getPropertyValue('padding-right') || '0', 10);
if (this.isBodyOverflowing) {
document.body.style.paddingRight = `${this.originalBodyPadding +
this.scrollbarWidth}px`;
}
}
/**
* @return {?}
*/
resetScrollbar() {
document.body.style.paddingRight = `${this.originalBodyPadding}px`;
}
/**
* @return {?}
*/
getScrollbarWidth() {
const /** @type {?} */ scrollDiv = this._renderer.createElement('div');
this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
this._renderer.appendChild(document.body, scrollDiv);
const /** @type {?} */ scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
this._renderer.removeChild(document.body, scrollDiv);
return scrollbarWidth;
}
/**
* @return {?}
*/
_createLoaders() {
const /** @type {?} */ loader = this.clf.createLoader(null, null, null);
this.copyEvent(loader.onBeforeShow, this.onShow);
this.copyEvent(loader.onShown, this.onShown);
this.copyEvent(loader.onBeforeHide, this.onHide);
this.copyEvent(loader.onHidden, this.onHidden);
this.loaders.push(loader);
}
/**
* @param {?} level
* @return {?}
*/
removeLoaders(level) {
this.loaders.splice(level - 1, 1);
this.loaders.forEach((loader, i) => {
loader.instance.level = i + 1;
});
}
/**
* @param {?} from
* @param {?} to
* @return {?}
*/
copyEvent(from, to) {
from.subscribe(() => {
to.emit(this.lastDismissReason);
});
}
}
BsModalService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
BsModalService.ctorParameters = () => [
{ type: RendererFactory2, },
{ type: ComponentLoaderFactory, },
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class ModalModule {
/**
* @return {?}
*/
static forRoot() {
return {
ngModule: ModalModule,
providers: [BsModalService, ComponentLoaderFactory, PositioningService]
};
}
}
ModalModule.decorators = [
{ type: NgModule, args: [{
declarations: [
ModalBackdropComponent,
ModalDirective,
ModalContainerComponent
],
exports: [ModalBackdropComponent, ModalDirective],
entryComponents: [ModalBackdropComponent, ModalContainerComponent]
},] }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
export { BsModalRef, ModalBackdropOptions, ModalContainerComponent, ModalBackdropComponent, ModalOptions, ModalDirective, ModalModule, BsModalService, CLASS_NAME as ɵa };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-modal.js.map","sources":["ng://ngx-bootstrap/modal/bs-modal-ref.service.ts","ng://ngx-bootstrap/modal/modal-backdrop.options.ts","ng://ngx-bootstrap/modal/modal-options.class.ts","ng://ngx-bootstrap/modal/modal-container.component.ts","ng://ngx-bootstrap/modal/modal-backdrop.component.ts","ng://ngx-bootstrap/modal/modal.directive.ts","ng://ngx-bootstrap/modal/bs-modal.service.ts","ng://ngx-bootstrap/modal/modal.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\n\n@Injectable()\nexport class BsModalRef {\n  /**\n   * Reference to a component inside the modal. Null if modal's been created with TemplateRef\n   */\n  // tslint:disable-next-line:no-any\n  content?: any | null;\n\n  /**\n   * Hides the modal\n   */\n  hide: () => void = Function;\n}\n","export class ModalBackdropOptions {\n  animate = true;\n\n  constructor(options: ModalBackdropOptions) {\n    Object.assign(this, options);\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { ClassName, DismissReasons, Selector, TransitionDurations } from './models';\n\n@Injectable()\nexport class ModalOptions {\n  /**\n   *  Includes a modal-backdrop element. Alternatively,\n   *  specify static for a backdrop which doesn't close the modal on click.\n   */\n  backdrop?: boolean | 'static';\n  /**\n   * Closes the modal when escape key is pressed.\n   */\n  keyboard?: boolean;\n\n  focus?: boolean;\n  /**\n   * Shows the modal when initialized.\n   */\n  show?: boolean;\n  /**\n   * Ignore the backdrop click\n   */\n  ignoreBackdropClick?: boolean;\n  /**\n   * Css class for opened modal\n   */\n  class?: string;\n  /**\n   * Toggle animation\n   */\n  animated?: boolean;\n  /**\n   * Modal data\n   */\n  initialState?: Object;\n}\n\n\nexport const modalConfigDefaults: ModalOptions = {\n  backdrop: true,\n  keyboard: true,\n  focus: true,\n  show: false,\n  ignoreBackdropClick: false,\n  class: '',\n  animated: true,\n  initialState: {}\n};\n\nexport const CLASS_NAME: ClassName = {\n  SCROLLBAR_MEASURER: 'modal-scrollbar-measure',\n  BACKDROP: 'modal-backdrop',\n  OPEN: 'modal-open',\n  FADE: 'fade',\n  IN: 'in', // bs3\n  SHOW: 'show' // bs4\n};\n\nexport const SELECTOR: Selector = {\n  DIALOG: '.modal-dialog',\n  DATA_TOGGLE: '[data-toggle=\"modal\"]',\n  DATA_DISMISS: '[data-dismiss=\"modal\"]',\n  FIXED_CONTENT: '.navbar-fixed-top, .navbar-fixed-bottom, .is-fixed'\n};\n\nexport const TRANSITION_DURATIONS: TransitionDurations = {\n  MODAL: 300,\n  BACKDROP: 150\n};\n\nexport const DISMISS_REASONS: DismissReasons = {\n  BACKRDOP: 'backdrop-click',\n  ESC: 'esc'\n};\n","import {\n  Component,\n  ElementRef,\n  HostListener,\n  OnDestroy,\n  OnInit,\n  Renderer2\n} from '@angular/core';\nimport {\n  CLASS_NAME,\n  DISMISS_REASONS,\n  ModalOptions,\n  TRANSITION_DURATIONS\n} from './modal-options.class';\nimport { BsModalService } from './bs-modal.service';\nimport { isBs3 } from 'ngx-bootstrap/utils';\n\n@Component({\n  selector: 'modal-container',\n  template: `\n    <div [class]=\"'modal-dialog' + (config.class ? ' ' + config.class : '')\" role=\"document\">\n      <div class=\"modal-content\">\n        <ng-content></ng-content>\n      </div>\n    </div>\n  `,\n  host: {\n    class: 'modal',\n    role: 'dialog',\n    tabindex: '-1',\n    '[attr.aria-modal]': 'true'\n  }\n})\nexport class ModalContainerComponent implements OnInit, OnDestroy {\n  config: ModalOptions;\n  isShown = false;\n  level: number;\n  isAnimated: boolean;\n  bsModalService: BsModalService;\n  private isModalHiding = false;\n\n  constructor(options: ModalOptions,\n              protected _element: ElementRef,\n              private _renderer: Renderer2) {\n    this.config = Object.assign({}, options);\n  }\n\n  ngOnInit(): void {\n    if (this.isAnimated) {\n      this._renderer.addClass(\n        this._element.nativeElement,\n        CLASS_NAME.FADE\n      );\n    }\n    this._renderer.setStyle(\n      this._element.nativeElement,\n      'display',\n      'block'\n    );\n    setTimeout(() => {\n      this.isShown = true;\n      this._renderer.addClass(\n        this._element.nativeElement,\n        isBs3() ? CLASS_NAME.IN : CLASS_NAME.SHOW\n      );\n    }, this.isAnimated ? TRANSITION_DURATIONS.BACKDROP : 0);\n    if (document && document.body) {\n      if (this.bsModalService.getModalsCount() === 1) {\n        this.bsModalService.checkScrollbar();\n        this.bsModalService.setScrollbar();\n      }\n      this._renderer.addClass(document.body, CLASS_NAME.OPEN);\n    }\n    if (this._element.nativeElement) {\n      this._element.nativeElement.focus();\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  onClick(event: MouseEvent): void {\n    if (\n      this.config.ignoreBackdropClick ||\n      this.config.backdrop === 'static' ||\n      event.target !== this._element.nativeElement\n    ) {\n      return;\n    }\n    this.bsModalService.setDismissReason(DISMISS_REASONS.BACKRDOP);\n    this.hide();\n  }\n\n  @HostListener('window:keydown.esc', ['$event'])\n  onEsc(event: KeyboardEvent): void {\n    if (!this.isShown) {\n      return;\n    }\n\n    // tslint:disable-next-line:deprecation\n    if (event.keyCode === 27 || event.key === 'Escape') {\n      event.preventDefault();\n    }\n\n    if (\n      this.config.keyboard &&\n      this.level === this.bsModalService.getModalsCount()\n    ) {\n      this.bsModalService.setDismissReason(DISMISS_REASONS.ESC);\n      this.hide();\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.isShown) {\n      this.hide();\n    }\n  }\n\n  hide(): void {\n    if (this.isModalHiding || !this.isShown) {\n      return;\n    }\n    this.isModalHiding = true;\n    this._renderer.removeClass(\n      this._element.nativeElement,\n      isBs3() ? CLASS_NAME.IN : CLASS_NAME.SHOW\n    );\n    setTimeout(() => {\n      this.isShown = false;\n      if (\n        document &&\n        document.body &&\n        this.bsModalService.getModalsCount() === 1\n      ) {\n        this._renderer.removeClass(document.body, CLASS_NAME.OPEN);\n      }\n      this.bsModalService.hide(this.level);\n      this.isModalHiding = false;\n    }, this.isAnimated ? TRANSITION_DURATIONS.MODAL : 0);\n  }\n}\n","import { Component, ElementRef, OnInit, Renderer2 } from '@angular/core';\n\nimport { CLASS_NAME } from './modal-options.class';\nimport { isBs3, Utils } from 'ngx-bootstrap/utils';\n\n\n/** This component will be added as background layout for modals if enabled */\n@Component({\n  selector: 'bs-modal-backdrop',\n  template: ' ',\n  host: { class: CLASS_NAME.BACKDROP }\n})\nexport class ModalBackdropComponent implements OnInit {\n  get isAnimated(): boolean {\n    return this._isAnimated;\n  }\n\n  set isAnimated(value: boolean) {\n    this._isAnimated = value;\n    // this.renderer.setElementClass(this.element.nativeElement, `${ClassName.FADE}`, value);\n  }\n\n  get isShown(): boolean {\n    return this._isShown;\n  }\n\n  set isShown(value: boolean) {\n    this._isShown = value;\n    if (value) {\n      this.renderer.addClass(\n        this.element.nativeElement,\n        `${CLASS_NAME.IN}`\n      );\n    } else {\n      this.renderer.removeClass(\n        this.element.nativeElement,\n        `${CLASS_NAME.IN}`\n      );\n    }\n    if (!isBs3()) {\n      if (value) {\n        this.renderer.addClass(\n          this.element.nativeElement,\n          `${CLASS_NAME.SHOW}`\n        );\n      } else {\n        this.renderer.removeClass(\n          this.element.nativeElement,\n          `${CLASS_NAME.SHOW}`\n        );\n      }\n    }\n  }\n\n  element: ElementRef;\n  renderer: Renderer2;\n\n  protected _isAnimated: boolean;\n  protected _isShown = false;\n\n  constructor(element: ElementRef, renderer: Renderer2) {\n    this.element = element;\n    this.renderer = renderer;\n  }\n\n  ngOnInit(): void {\n    if (this.isAnimated) {\n      this.renderer.addClass(\n        this.element.nativeElement,\n        `${CLASS_NAME.FADE}`\n      );\n      Utils.reflow(this.element.nativeElement);\n    }\n    this.isShown = true;\n  }\n}\n","/* tslint:disable:max-file-line-count */\n// todo: should we support enforce focus in?\n// todo: in original bs there are was a way to prevent modal from showing\n// todo: original modal had resize events\n\nimport {\n  ComponentRef, Directive, ElementRef, EventEmitter, HostListener, Input,\n  OnDestroy, OnInit, Output, Renderer2, ViewContainerRef\n} from '@angular/core';\n\nimport { document, window, isBs3, Utils } from 'ngx-bootstrap/utils';\nimport { ModalBackdropComponent } from './modal-backdrop.component';\nimport {\n  CLASS_NAME, DISMISS_REASONS, modalConfigDefaults, ModalOptions\n} from './modal-options.class';\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\n\nconst TRANSITION_DURATION = 300;\nconst BACKDROP_TRANSITION_DURATION = 150;\n\n/** Mark any code with directive to show it's content in modal */\n@Directive({\n  selector: '[bsModal]',\n  exportAs: 'bs-modal'\n})\nexport class ModalDirective implements OnDestroy, OnInit {\n  /** allows to set modal configuration via element property */\n  @Input()\n  set config(conf: ModalOptions) {\n    this._config = this.getConfig(conf);\n  }\n\n  get config(): ModalOptions {\n    return this._config;\n  }\n\n  /** This event fires immediately when the `show` instance method is called. */\n  @Output()\n  onShow: EventEmitter<ModalDirective> = new EventEmitter<ModalDirective>();\n  /** This event is fired when the modal has been made visible to the user\n   * (will wait for CSS transitions to complete)\n   */\n  @Output()\n  onShown: EventEmitter<ModalDirective> = new EventEmitter<ModalDirective>();\n  /** This event is fired immediately when\n   * the hide instance method has been called.\n   */\n  @Output()\n  onHide: EventEmitter<ModalDirective> = new EventEmitter<ModalDirective>();\n  /** This event is fired when the modal has finished being\n   * hidden from the user (will wait for CSS transitions to complete).\n   */\n  @Output()\n  onHidden: EventEmitter<ModalDirective> = new EventEmitter<ModalDirective>();\n\n  /** This field contains last dismiss reason.\n   * Possible values: `backdrop-click`, `esc` and `null`\n   * (if modal was closed by direct call of `.hide()`).\n   */\n  dismissReason: string;\n\n  get isShown(): boolean {\n    return this._isShown;\n  }\n\n  protected _config: ModalOptions;\n  protected _isShown = false;\n\n  protected isBodyOverflowing = false;\n  protected originalBodyPadding = 0;\n  protected scrollbarWidth = 0;\n\n  protected timerHideModal = 0;\n  protected timerRmBackDrop = 0;\n\n  // reference to backdrop component\n  protected backdrop: ComponentRef<ModalBackdropComponent>;\n  private _backdrop: ComponentLoader<ModalBackdropComponent>;\n\n  private isNested = false;\n\n  constructor(private _element: ElementRef,\n              _viewContainerRef: ViewContainerRef,\n              private _renderer: Renderer2,\n              clf: ComponentLoaderFactory) {\n    this._backdrop = clf.createLoader<ModalBackdropComponent>(\n      _element,\n      _viewContainerRef,\n      _renderer\n    );\n  }\n\n  @HostListener('click', ['$event'])\n  onClick(event: MouseEvent): void {\n    if (\n      this.config.ignoreBackdropClick ||\n      this.config.backdrop === 'static' ||\n      event.target !== this._element.nativeElement\n    ) {\n      return;\n    }\n    this.dismissReason = DISMISS_REASONS.BACKRDOP;\n    this.hide(event);\n  }\n\n  // todo: consider preventing default and stopping propagation\n  @HostListener('keydown.esc', ['$event'])\n  onEsc(event: KeyboardEvent): void {\n    if (!this._isShown) {\n      return;\n    }\n    // tslint:disable-next-line:deprecation\n    if (event.keyCode === 27 || event.key === 'Escape') {\n      event.preventDefault();\n    }\n\n    if (this.config.keyboard) {\n      this.dismissReason = DISMISS_REASONS.ESC;\n      this.hide();\n    }\n  }\n\n  ngOnDestroy() {\n    this.config = void 0;\n    if (this._isShown) {\n      this._isShown = false;\n      this.hideModal();\n      this._backdrop.dispose();\n    }\n  }\n\n  ngOnInit(): void {\n    this._config = this._config || this.getConfig();\n    setTimeout(() => {\n      if (this._config.show) {\n        this.show();\n      }\n    }, 0);\n  }\n\n  /* Public methods */\n\n  /** Allows to manually toggle modal visibility */\n  toggle(): void {\n    return this._isShown ? this.hide() : this.show();\n  }\n\n  /** Allows to manually open modal */\n  show(): void {\n    this.dismissReason = null;\n    this.onShow.emit(this);\n    if (this._isShown) {\n      return;\n    }\n    clearTimeout(this.timerHideModal);\n    clearTimeout(this.timerRmBackDrop);\n\n    this._isShown = true;\n\n    this.checkScrollbar();\n    this.setScrollbar();\n\n    if (document && document.body) {\n      if (document.body.classList.contains(CLASS_NAME.OPEN)) {\n        this.isNested = true;\n      } else {\n        this._renderer.addClass(document.body, CLASS_NAME.OPEN);\n      }\n    }\n\n    this.showBackdrop(() => {\n      this.showElement();\n    });\n  }\n\n  /** Allows to manually close modal */\n  hide(event?: Event): void {\n    if (event) {\n      event.preventDefault();\n    }\n\n    this.onHide.emit(this);\n\n    // todo: add an option to prevent hiding\n    if (!this._isShown) {\n      return;\n    }\n\n    window.clearTimeout(this.timerHideModal);\n    window.clearTimeout(this.timerRmBackDrop);\n\n    this._isShown = false;\n    this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.IN);\n    if (!isBs3()) {\n      this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);\n    }\n    // this._addClassIn = false;\n\n    if (this._config.animated) {\n      this.timerHideModal = window.setTimeout(\n        () => this.hideModal(),\n        TRANSITION_DURATION\n      );\n    } else {\n      this.hideModal();\n    }\n  }\n\n  /** Private methods @internal */\n  protected getConfig(config?: ModalOptions): ModalOptions {\n    return Object.assign({}, modalConfigDefaults, config);\n  }\n\n  /**\n   *  Show dialog\n   *  @internal\n   */\n  protected showElement(): void {\n    // todo: replace this with component loader usage\n    if (\n      !this._element.nativeElement.parentNode ||\n      this._element.nativeElement.parentNode.nodeType !== Node.ELEMENT_NODE\n    ) {\n      // don't move modals dom position\n      if (document && document.body) {\n        document.body.appendChild(this._element.nativeElement);\n      }\n    }\n\n    this._renderer.setAttribute(\n      this._element.nativeElement,\n      'aria-hidden',\n      'false'\n    );\n    this._renderer.setAttribute(\n      this._element.nativeElement,\n      'aria-modal',\n      'true'\n    );\n    this._renderer.setStyle(\n      this._element.nativeElement,\n      'display',\n      'block'\n    );\n    this._renderer.setProperty(\n      this._element.nativeElement,\n      'scrollTop',\n      0\n    );\n\n    if (this._config.animated) {\n      Utils.reflow(this._element.nativeElement);\n    }\n\n    // this._addClassIn = true;\n    this._renderer.addClass(this._element.nativeElement, CLASS_NAME.IN);\n    if (!isBs3()) {\n      this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);\n    }\n\n    const transitionComplete = () => {\n      if (this._config.focus) {\n        this._element.nativeElement.focus();\n      }\n      this.onShown.emit(this);\n    };\n\n    if (this._config.animated) {\n      setTimeout(transitionComplete, TRANSITION_DURATION);\n    } else {\n      transitionComplete();\n    }\n  }\n\n  /** @internal */\n  protected hideModal(): void {\n    this._renderer.setAttribute(\n      this._element.nativeElement,\n      'aria-hidden',\n      'true'\n    );\n    this._renderer.setStyle(\n      this._element.nativeElement,\n      'display',\n      'none'\n    );\n    this.showBackdrop(() => {\n      if (!this.isNested) {\n        if (document && document.body) {\n          this._renderer.removeClass(document.body, CLASS_NAME.OPEN);\n        }\n        this.resetScrollbar();\n      }\n      this.resetAdjustments();\n      this.focusOtherModal();\n      this.onHidden.emit(this);\n    });\n  }\n\n  // todo: original show was calling a callback when done, but we can use\n  // promise\n  /** @internal */\n  protected showBackdrop(callback?: Function): void {\n    if (\n      this._isShown &&\n      this.config.backdrop &&\n      (!this.backdrop || !this.backdrop.instance.isShown)\n    ) {\n      this.removeBackdrop();\n      this._backdrop\n        .attach(ModalBackdropComponent)\n        .to('body')\n        .show({isAnimated: this._config.animated});\n      this.backdrop = this._backdrop._componentRef;\n\n      if (!callback) {\n        return;\n      }\n\n      if (!this._config.animated) {\n        callback();\n\n        return;\n      }\n\n      setTimeout(callback, BACKDROP_TRANSITION_DURATION);\n    } else if (!this._isShown && this.backdrop) {\n      this.backdrop.instance.isShown = false;\n\n      const callbackRemove = () => {\n        this.removeBackdrop();\n        if (callback) {\n          callback();\n  