ngx-bootstrap 3.0.1 → 3.1.4

package/modal/bundles/ngx-bootstrap-modal.umd.js

@@ -0,0 +1,1156 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('ngx-bootstrap/utils'), require('ngx-bootstrap/component-loader'), require('ngx-bootstrap/positioning')) :
+    typeof define === 'function' && define.amd ? define('ngx-bootstrap/modal', ['exports', '@angular/core', 'ngx-bootstrap/utils', 'ngx-bootstrap/component-loader', 'ngx-bootstrap/positioning'], factory) :
+    (factory((global['ngx-bootstrap'] = global['ngx-bootstrap'] || {}, global['ngx-bootstrap'].modal = {}),global.ng.core,global.utils,global.componentLoader,global.positioning));
+}(this, (function (exports,core,utils,componentLoader,positioning) { 'use strict';
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var BsModalRef = (function () {
+        function BsModalRef() {
+            /**
+             * Hides the modal
+             */
+            this.hide = Function;
+            /**
+             * Sets new class to modal window
+             */
+            this.setClass = Function;
+        }
+        BsModalRef.decorators = [
+            { type: core.Injectable }
+        ];
+        return BsModalRef;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var ModalBackdropOptions = (function () {
+        function ModalBackdropOptions(options) {
+            this.animate = true;
+            Object.assign(this, options);
+        }
+        return ModalBackdropOptions;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var ModalOptions = (function () {
+        function ModalOptions() {
+        }
+        ModalOptions.decorators = [
+            { type: core.Injectable }
+        ];
+        return ModalOptions;
+    }());
+    var /** @type {?} */ modalConfigDefaults = {
+        backdrop: true,
+        keyboard: true,
+        focus: true,
+        show: false,
+        ignoreBackdropClick: false,
+        class: '',
+        animated: true,
+        initialState: {}
+    };
+    var /** @type {?} */ CLASS_NAME = {
+        SCROLLBAR_MEASURER: 'modal-scrollbar-measure',
+        BACKDROP: 'modal-backdrop',
+        OPEN: 'modal-open',
+        FADE: 'fade',
+        IN: 'in',
+        // bs3
+        SHOW: 'show' // bs4
+    };
+    var /** @type {?} */ TRANSITION_DURATIONS = {
+        MODAL: 300,
+        BACKDROP: 150
+    };
+    var /** @type {?} */ DISMISS_REASONS = {
+        BACKRDOP: 'backdrop-click',
+        ESC: 'esc'
+    };
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var ModalContainerComponent = (function () {
+        function ModalContainerComponent(options, _element, _renderer) {
+            this._element = _element;
+            this._renderer = _renderer;
+            this.isShown = false;
+            this.isModalHiding = false;
+            this.config = Object.assign({}, options);
+        }
+        /**
+         * @return {?}
+         */
+        ModalContainerComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                if (this.isAnimated) {
+                    this._renderer.addClass(this._element.nativeElement, CLASS_NAME.FADE);
+                }
+                this._renderer.setStyle(this._element.nativeElement, 'display', 'block');
+                setTimeout(function () {
+                    _this.isShown = true;
+                    _this._renderer.addClass(_this._element.nativeElement, utils.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 {?}
+         */
+        ModalContainerComponent.prototype.onClick = /**
+         * @param {?} event
+         * @return {?}
+         */
+            function (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 {?}
+         */
+        ModalContainerComponent.prototype.onEsc = /**
+         * @param {?} event
+         * @return {?}
+         */
+            function (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 {?}
+         */
+        ModalContainerComponent.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+            function () {
+                if (this.isShown) {
+                    this.hide();
+                }
+            };
+        /**
+         * @return {?}
+         */
+        ModalContainerComponent.prototype.hide = /**
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                if (this.isModalHiding || !this.isShown) {
+                    return;
+                }
+                this.isModalHiding = true;
+                this._renderer.removeClass(this._element.nativeElement, utils.isBs3() ? CLASS_NAME.IN : CLASS_NAME.SHOW);
+                setTimeout(function () {
+                    _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: core.Component, args: [{
+                        selector: 'modal-container',
+                        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  ",
+                        host: {
+                            class: 'modal',
+                            role: 'dialog',
+                            tabindex: '-1',
+                            '[attr.aria-modal]': 'true'
+                        }
+                    }] }
+        ];
+        /** @nocollapse */
+        ModalContainerComponent.ctorParameters = function () {
+            return [
+                { type: ModalOptions, },
+                { type: core.ElementRef, },
+                { type: core.Renderer2, },
+            ];
+        };
+        ModalContainerComponent.propDecorators = {
+            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+            "onEsc": [{ type: core.HostListener, args: ['window:keydown.esc', ['$event'],] },],
+        };
+        return ModalContainerComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    /**
+     * This component will be added as background layout for modals if enabled
+     */
+    var ModalBackdropComponent = (function () {
+        function ModalBackdropComponent(element, renderer) {
+            this._isShown = false;
+            this.element = element;
+            this.renderer = renderer;
+        }
+        Object.defineProperty(ModalBackdropComponent.prototype, "isAnimated", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._isAnimated;
+            },
+            set: /**
+             * @param {?} value
+             * @return {?}
+             */ function (value) {
+                this._isAnimated = value;
+                // this.renderer.setElementClass(this.element.nativeElement, `${ClassName.FADE}`, value);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ModalBackdropComponent.prototype, "isShown", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._isShown;
+            },
+            set: /**
+             * @param {?} value
+             * @return {?}
+             */ function (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 (!utils.isBs3()) {
+                    if (value) {
+                        this.renderer.addClass(this.element.nativeElement, "" + CLASS_NAME.SHOW);
+                    }
+                    else {
+                        this.renderer.removeClass(this.element.nativeElement, "" + CLASS_NAME.SHOW);
+                    }
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @return {?}
+         */
+        ModalBackdropComponent.prototype.ngOnInit = /**
+         * @return {?}
+         */
+            function () {
+                if (this.isAnimated) {
+                    this.renderer.addClass(this.element.nativeElement, "" + CLASS_NAME.FADE);
+                    utils.Utils.reflow(this.element.nativeElement);
+                }
+                this.isShown = true;
+            };
+        ModalBackdropComponent.decorators = [
+            { type: core.Component, args: [{
+                        selector: 'bs-modal-backdrop',
+                        template: ' ',
+                        host: { class: CLASS_NAME.BACKDROP }
+                    }] }
+        ];
+        /** @nocollapse */
+        ModalBackdropComponent.ctorParameters = function () {
+            return [
+                { type: core.ElementRef, },
+                { type: core.Renderer2, },
+            ];
+        };
+        return ModalBackdropComponent;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var /** @type {?} */ TRANSITION_DURATION = 300;
+    var /** @type {?} */ BACKDROP_TRANSITION_DURATION = 150;
+    /**
+     * Mark any code with directive to show it's content in modal
+     */
+    var ModalDirective = (function () {
+        function ModalDirective(_element, _viewContainerRef, _renderer, clf) {
+            this._element = _element;
+            this._renderer = _renderer;
+            /**
+             * This event fires immediately when the `show` instance method is called.
+             */
+            this.onShow = new core.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 core.EventEmitter();
+            /**
+             * This event is fired immediately when
+             * the hide instance method has been called.
+             */
+            this.onHide = new core.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 core.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);
+        }
+        Object.defineProperty(ModalDirective.prototype, "config", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._config;
+            },
+            set: /**
+             * allows to set modal configuration via element property
+             * @param {?} conf
+             * @return {?}
+             */ function (conf) {
+                this._config = this.getConfig(conf);
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(ModalDirective.prototype, "isShown", {
+            get: /**
+             * @return {?}
+             */ function () {
+                return this._isShown;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * @param {?} event
+         * @return {?}
+         */
+        ModalDirective.prototype.onClick = /**
+         * @param {?} event
+         * @return {?}
+         */
+            function (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 {?}
+         */
+        ModalDirective.prototype.onEsc = /**
+         * @param {?} event
+         * @return {?}
+         */
+            function (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 {?}
+         */
+        ModalDirective.prototype.ngOnDestroy = /**
+         * @return {?}
+         */
+            function () {
+                this.config = void 0;
+                if (this._isShown) {
+                    this._isShown = false;
+                    this.hideModal();
+                    this._backdrop.dispose();
+                }
+            };
+        /**
+         * @return {?}
+         */
+        ModalDirective.prototype.ngOnInit = /**
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                this._config = this._config || this.getConfig();
+                setTimeout(function () {
+                    if (_this._config.show) {
+                        _this.show();
+                    }
+                }, 0);
+            };
+        /* Public methods */
+        /** Allows to manually toggle modal visibility */
+        /**
+         * Allows to manually toggle modal visibility
+         * @return {?}
+         */
+        ModalDirective.prototype.toggle = /**
+         * Allows to manually toggle modal visibility
+         * @return {?}
+         */
+            function () {
+                return this._isShown ? this.hide() : this.show();
+            };
+        /** Allows to manually open modal */
+        /**
+         * Allows to manually open modal
+         * @return {?}
+         */
+        ModalDirective.prototype.show = /**
+         * Allows to manually open modal
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                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 (utils.document && utils.document.body) {
+                    if (utils.document.body.classList.contains(CLASS_NAME.OPEN)) {
+                        this.isNested = true;
+                    }
+                    else {
+                        this._renderer.addClass(utils.document.body, CLASS_NAME.OPEN);
+                    }
+                }
+                this.showBackdrop(function () {
+                    _this.showElement();
+                });
+            };
+        /** Allows to manually close modal */
+        /**
+         * Allows to manually close modal
+         * @param {?=} event
+         * @return {?}
+         */
+        ModalDirective.prototype.hide = /**
+         * Allows to manually close modal
+         * @param {?=} event
+         * @return {?}
+         */
+            function (event) {
+                var _this = this;
+                if (event) {
+                    event.preventDefault();
+                }
+                this.onHide.emit(this);
+                // todo: add an option to prevent hiding
+                if (!this._isShown) {
+                    return;
+                }
+                utils.window.clearTimeout(this.timerHideModal);
+                utils.window.clearTimeout(this.timerRmBackDrop);
+                this._isShown = false;
+                this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.IN);
+                if (!utils.isBs3()) {
+                    this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);
+                }
+                // this._addClassIn = false;
+                if (this._config.animated) {
+                    this.timerHideModal = utils.window.setTimeout(function () { return _this.hideModal(); }, TRANSITION_DURATION);
+                }
+                else {
+                    this.hideModal();
+                }
+            };
+        /** Private methods @internal */
+        /**
+         * Private methods \@internal
+         * @param {?=} config
+         * @return {?}
+         */
+        ModalDirective.prototype.getConfig = /**
+         * Private methods \@internal
+         * @param {?=} config
+         * @return {?}
+         */
+            function (config) {
+                return Object.assign({}, modalConfigDefaults, config);
+            };
+        /**
+         *  Show dialog
+         *  @internal
+         */
+        /**
+         *  Show dialog
+         *  \@internal
+         * @return {?}
+         */
+        ModalDirective.prototype.showElement = /**
+         *  Show dialog
+         *  \@internal
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                // 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 (utils.document && utils.document.body) {
+                        utils.document.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.Utils.reflow(this._element.nativeElement);
+                }
+                // this._addClassIn = true;
+                this._renderer.addClass(this._element.nativeElement, CLASS_NAME.IN);
+                if (!utils.isBs3()) {
+                    this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);
+                }
+                var /** @type {?} */ transitionComplete = function () {
+                    if (_this._config.focus) {
+                        _this._element.nativeElement.focus();
+                    }
+                    _this.onShown.emit(_this);
+                };
+                if (this._config.animated) {
+                    setTimeout(transitionComplete, TRANSITION_DURATION);
+                }
+                else {
+                    transitionComplete();
+                }
+            };
+        /** @internal */
+        /**
+         * \@internal
+         * @return {?}
+         */
+        ModalDirective.prototype.hideModal = /**
+         * \@internal
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                this._renderer.setAttribute(this._element.nativeElement, 'aria-hidden', 'true');
+                this._renderer.setStyle(this._element.nativeElement, 'display', 'none');
+                this.showBackdrop(function () {
+                    if (!_this.isNested) {
+                        if (utils.document && utils.document.body) {
+                            _this._renderer.removeClass(utils.document.body, CLASS_NAME.OPEN);
+                        }
+                        _this.resetScrollbar();
+                    }
+                    _this.resetAdjustments();
+                    _this.focusOtherModal();
+                    _this.onHidden.emit(_this);
+                });
+            };
+        // todo: original show was calling a callback when done, but we can use
+        // promise
+        /** @internal */
+        /**
+         * \@internal
+         * @param {?=} callback
+         * @return {?}
+         */
+        ModalDirective.prototype.showBackdrop = /**
+         * \@internal
+         * @param {?=} callback
+         * @return {?}
+         */
+            function (callback) {
+                var _this = this;
+                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;
+                    var /** @type {?} */ callbackRemove = function () {
+                        _this.removeBackdrop();
+                        if (callback) {
+                            callback();
+                        }
+                    };
+                    if (this.backdrop.instance.isAnimated) {
+                        this.timerRmBackDrop = utils.window.setTimeout(callbackRemove, BACKDROP_TRANSITION_DURATION);
+                    }
+                    else {
+                        callbackRemove();
+                    }
+                }
+                else if (callback) {
+                    callback();
+                }
+            };
+        /** @internal */
+        /**
+         * \@internal
+         * @return {?}
+         */
+        ModalDirective.prototype.removeBackdrop = /**
+         * \@internal
+         * @return {?}
+         */
+            function () {
+                this._backdrop.hide();
+            };
+        /** Events tricks */
+        // no need for it
+        // protected setEscapeEvent():void {
+        //   if (this._isShown && this._config.keyboard) {
+        //     $(this._element).on(Event.KEYDOWN_DISMISS, (event) => {
+        //       if (event.which === 27) {
+        //         this.hide()
+        //       }
+        //     })
+        //
+        //   } else if (!this._isShown) {
+        //     $(this._element).off(Event.KEYDOWN_DISMISS)
+        //   }
+        // }
+        // protected setResizeEvent():void {
+        // console.log(this.renderer.listenGlobal('', Event.RESIZE));
+        // if (this._isShown) {
+        //   $(window).on(Event.RESIZE, $.proxy(this._handleUpdate, this))
+        // } else {
+        //   $(window).off(Event.RESIZE)
+        // }
+        // }
+        /**
+         * Events tricks
+         * @return {?}
+         */
+        ModalDirective.prototype.focusOtherModal = /**
+         * Events tricks
+         * @return {?}
+         */
+            function () {
+                if (this._element.nativeElement.parentElement == null) {
+                    return;
+                }
+                var /** @type {?} */ otherOpenedModals = this._element.nativeElement.parentElement.querySelectorAll('.in[bsModal]');
+                if (!otherOpenedModals.length) {
+                    return;
+                }
+                otherOpenedModals[otherOpenedModals.length - 1].focus();
+            };
+        /** @internal */
+        /**
+         * \@internal
+         * @return {?}
+         */
+        ModalDirective.prototype.resetAdjustments = /**
+         * \@internal
+         * @return {?}
+         */
+            function () {
+                this._renderer.setStyle(this._element.nativeElement, 'paddingLeft', '');
+                this._renderer.setStyle(this._element.nativeElement, 'paddingRight', '');
+            };
+        /** Scroll bar tricks */
+        /** @internal */
+        /**
+         * \@internal
+         * @return {?}
+         */
+        ModalDirective.prototype.checkScrollbar = /**
+         * \@internal
+         * @return {?}
+         */
+            function () {
+                this.isBodyOverflowing = utils.document.body.clientWidth < utils.window.innerWidth;
+                this.scrollbarWidth = this.getScrollbarWidth();
+            };
+        /**
+         * @return {?}
+         */
+        ModalDirective.prototype.setScrollbar = /**
+         * @return {?}
+         */
+            function () {
+                if (!utils.document) {
+                    return;
+                }
+                this.originalBodyPadding = parseInt(utils.window
+                    .getComputedStyle(utils.document.body)
+                    .getPropertyValue('padding-right') || 0, 10);
+                if (this.isBodyOverflowing) {
+                    utils.document.body.style.paddingRight = this.originalBodyPadding +
+                        this.scrollbarWidth + "px";
+                }
+            };
+        /**
+         * @return {?}
+         */
+        ModalDirective.prototype.resetScrollbar = /**
+         * @return {?}
+         */
+            function () {
+                utils.document.body.style.paddingRight = this.originalBodyPadding + "px";
+            };
+        // thx d.walsh
+        /**
+         * @return {?}
+         */
+        ModalDirective.prototype.getScrollbarWidth = /**
+         * @return {?}
+         */
+            function () {
+                var /** @type {?} */ scrollDiv = this._renderer.createElement('div');
+                this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
+                this._renderer.appendChild(utils.document.body, scrollDiv);
+                var /** @type {?} */ scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+                this._renderer.removeChild(utils.document.body, scrollDiv);
+                return scrollbarWidth;
+            };
+        ModalDirective.decorators = [
+            { type: core.Directive, args: [{
+                        selector: '[bsModal]',
+                        exportAs: 'bs-modal'
+                    },] }
+        ];
+        /** @nocollapse */
+        ModalDirective.ctorParameters = function () {
+            return [
+                { type: core.ElementRef, },
+                { type: core.ViewContainerRef, },
+                { type: core.Renderer2, },
+                { type: componentLoader.ComponentLoaderFactory, },
+            ];
+        };
+        ModalDirective.propDecorators = {
+            "config": [{ type: core.Input },],
+            "onShow": [{ type: core.Output },],
+            "onShown": [{ type: core.Output },],
+            "onHide": [{ type: core.Output },],
+            "onHidden": [{ type: core.Output },],
+            "onClick": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+            "onEsc": [{ type: core.HostListener, args: ['keydown.esc', ['$event'],] },],
+        };
+        return ModalDirective;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var BsModalService = (function () {
+        function BsModalService(rendererFactory, clf) {
+            this.clf = clf;
+            // constructor props
+            this.config = modalConfigDefaults;
+            // tslint:disable-next-line:no-any
+            this.onShow = new core.EventEmitter();
+            // tslint:disable-next-line:no-any
+            this.onShown = new core.EventEmitter();
+            // tslint:disable-next-line:no-any
+            this.onHide = new core.EventEmitter();
+            // tslint:disable-next-line:no-any
+            this.onHidden = new core.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 */
+        // tslint:disable-next-line:no-any
+        /**
+         * Shows a modal
+         * @param {?} content
+         * @param {?=} config
+         * @return {?}
+         */
+        BsModalService.prototype.show = /**
+         * Shows a modal
+         * @param {?} content
+         * @param {?=} config
+         * @return {?}
+         */
+            function (content, config) {
+                this.modalsCount++;
+                this._createLoaders();
+                this.config = Object.assign({}, modalConfigDefaults, config);
+                this._showBackdrop();
+                this.lastDismissReason = null;
+                return this._showModal(content);
+            };
+        /**
+         * @param {?} level
+         * @return {?}
+         */
+        BsModalService.prototype.hide = /**
+         * @param {?} level
+         * @return {?}
+         */
+            function (level) {
+                var _this = this;
+                if (this.modalsCount === 1) {
+                    this._hideBackdrop();
+                    this.resetScrollbar();
+                }
+                this.modalsCount = this.modalsCount >= 1 ? this.modalsCount - 1 : 0;
+                setTimeout(function () {
+                    _this._hideModal(level);
+                    _this.removeLoaders(level);
+                }, this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0);
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype._showBackdrop = /**
+         * @return {?}
+         */
+            function () {
+                var /** @type {?} */ isBackdropEnabled = this.config.backdrop || this.config.backdrop === 'static';
+                var /** @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 {?}
+         */
+        BsModalService.prototype._hideBackdrop = /**
+         * @return {?}
+         */
+            function () {
+                var _this = this;
+                if (!this.backdropRef) {
+                    return;
+                }
+                this.backdropRef.instance.isShown = false;
+                var /** @type {?} */ duration = this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0;
+                setTimeout(function () { return _this.removeBackdrop(); }, duration);
+            };
+        // tslint:disable-next-line:no-any
+        /**
+         * @param {?} content
+         * @return {?}
+         */
+        BsModalService.prototype._showModal = /**
+         * @param {?} content
+         * @return {?}
+         */
+            function (content) {
+                var /** @type {?} */ modalLoader = this.loaders[this.loaders.length - 1];
+                var /** @type {?} */ bsModalRef = new BsModalRef();
+                var /** @type {?} */ modalContainerRef = modalLoader
+                    .provide({ provide: ModalOptions, useValue: this.config })
+                    .provide({ provide: BsModalRef, useValue: bsModalRef })
+                    .attach(ModalContainerComponent)
+                    .to('body')
+                    .show({ content: content, isAnimated: this.config.animated, initialState: this.config.initialState, bsModalService: this });
+                modalContainerRef.instance.level = this.getModalsCount();
+                bsModalRef.hide = function () {
+                    modalContainerRef.instance.hide();
+                };
+                bsModalRef.content = modalLoader.getInnerComponent() || null;
+                bsModalRef.setClass = function (newClass) {
+                    modalContainerRef.instance.config.class = newClass;
+                };
+                return bsModalRef;
+            };
+        /**
+         * @param {?} level
+         * @return {?}
+         */
+        BsModalService.prototype._hideModal = /**
+         * @param {?} level
+         * @return {?}
+         */
+            function (level) {
+                var /** @type {?} */ modalLoader = this.loaders[level - 1];
+                if (modalLoader) {
+                    modalLoader.hide();
+                }
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype.getModalsCount = /**
+         * @return {?}
+         */
+            function () {
+                return this.modalsCount;
+            };
+        /**
+         * @param {?} reason
+         * @return {?}
+         */
+        BsModalService.prototype.setDismissReason = /**
+         * @param {?} reason
+         * @return {?}
+         */
+            function (reason) {
+                this.lastDismissReason = reason;
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype.removeBackdrop = /**
+         * @return {?}
+         */
+            function () {
+                this._backdropLoader.hide();
+                this.backdropRef = null;
+            };
+        /** AFTER PR MERGE MODAL.COMPONENT WILL BE USING THIS CODE */
+        /** Scroll bar tricks */
+        /** @internal */
+        /**
+         * \@internal
+         * @return {?}
+         */
+        BsModalService.prototype.checkScrollbar = /**
+         * \@internal
+         * @return {?}
+         */
+            function () {
+                this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;
+                this.scrollbarWidth = this.getScrollbarWidth();
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype.setScrollbar = /**
+         * @return {?}
+         */
+            function () {
+                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 {?}
+         */
+        BsModalService.prototype.resetScrollbar = /**
+         * @return {?}
+         */
+            function () {
+                document.body.style.paddingRight = this.originalBodyPadding + "px";
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype.getScrollbarWidth = /**
+         * @return {?}
+         */
+            function () {
+                var /** @type {?} */ scrollDiv = this._renderer.createElement('div');
+                this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
+                this._renderer.appendChild(document.body, scrollDiv);
+                var /** @type {?} */ scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+                this._renderer.removeChild(document.body, scrollDiv);
+                return scrollbarWidth;
+            };
+        /**
+         * @return {?}
+         */
+        BsModalService.prototype._createLoaders = /**
+         * @return {?}
+         */
+            function () {
+                var /** @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 {?}
+         */
+        BsModalService.prototype.removeLoaders = /**
+         * @param {?} level
+         * @return {?}
+         */
+            function (level) {
+                this.loaders.splice(level - 1, 1);
+                this.loaders.forEach(function (loader, i) {
+                    loader.instance.level = i + 1;
+                });
+            };
+        /**
+         * @param {?} from
+         * @param {?} to
+         * @return {?}
+         */
+        BsModalService.prototype.copyEvent = /**
+         * @param {?} from
+         * @param {?} to
+         * @return {?}
+         */
+            function (from, to) {
+                var _this = this;
+                from.subscribe(function () {
+                    to.emit(_this.lastDismissReason);
+                });
+            };
+        BsModalService.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        BsModalService.ctorParameters = function () {
+            return [
+                { type: core.RendererFactory2, },
+                { type: componentLoader.ComponentLoaderFactory, },
+            ];
+        };
+        return BsModalService;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+    var ModalModule = (function () {
+        function ModalModule() {
+        }
+        /**
+         * @return {?}
+         */
+        ModalModule.forRoot = /**
+         * @return {?}
+         */
+            function () {
+                return {
+                    ngModule: ModalModule,
+                    providers: [BsModalService, componentLoader.ComponentLoaderFactory, positioning.PositioningService]
+                };
+            };
+        ModalModule.decorators = [
+            { type: core.NgModule, args: [{
+                        declarations: [
+                            ModalBackdropComponent,
+                            ModalDirective,
+                            ModalContainerComponent
+                        ],
+                        exports: [ModalBackdropComponent, ModalDirective],
+                        entryComponents: [ModalBackdropComponent, ModalContainerComponent]
+                    },] }
+        ];
+        return ModalModule;
+    }());
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes} checked by tsc
+     */
+
+    exports.BsModalRef = BsModalRef;
+    exports.ModalBackdropOptions = ModalBackdropOptions;
+    exports.ModalContainerComponent = ModalContainerComponent;
+    exports.ModalBackdropComponent = ModalBackdropComponent;
+    exports.ModalOptions = ModalOptions;
+    exports.ModalDirective = ModalDirective;
+    exports.ModalModule = ModalModule;
+    exports.BsModalService = BsModalService;
+    exports.ɵa = CLASS_NAME;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ngx-bootstrap-modal.umd.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   * Sets new class to modal window\n   */\n  setClass: (newClass: string) => 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        }\n      };\n\n      if (this.backdrop.instance.isAnimated) {\n        this.timerRmBackDrop = window.setTimeout(\n          callbackRemove,\n          BACKDROP_TRANSITION_DURATION\n        );\n      } else {\n        callbackRemove();\n      }\n    } else if (callback) {\n      callback();\n    }\n  }\n\n  /** @internal */\n  protected removeBackdrop(): void {\n    this._backdrop.hide();\n  }\n\n  /** Events tricks */\n\n  // no need for it\n  // protected setEscapeEvent():void {\n  //   if (this._isShown && this._config.keyboard) {\n  //     $(this._element).on(Event.KEYDOWN_DISMISS, (event) => {\n  //       if (event.which === 27) {\n  //         this.hide()\n  //       }\n  //     })\n  //\n  //   } else if (!this._isShown) {\n  //     $(this._element).off(Event.KEYDOWN_DISMISS)\n  //   }\n  // }\n\n  // protected setResizeEvent():void {\n  // console.log(this.renderer.listenGlobal('', Event.RESIZE));\n  // if (this._isShown) {\n  //   $(window).on(Event.RESIZE, $.proxy(this._handleUpdate, this))\n  // } else {\n  //   $(window).off(Event.RESIZE)\n  // }\n  // }\n\n  protected focusOtherModal() {\n    if (this._element.nativeElement.parentElement == null) {\n      return;\n    }\n    const otherOpenedModals = this._element.nativeElement.parentElement.querySelectorAll('.in[bsModal]');\n    if (!otherOpenedModals.length) {\n      return;\n    }\n    otherOpenedModals[otherOpenedModals.length - 1].focus();\n  }\n\n  /** @internal */\n  protected resetAdjustments(): void {\n    this._renderer.setStyle(\n      this._element.nativeElement,\n      'paddingLeft',\n      ''\n    );\n    this._renderer.setStyle(\n      this._element.nativeElement,\n      'paddingRight',\n      ''\n    );\n  }\n\n  /** Scroll bar tricks */\n  /** @internal */\n  protected checkScrollbar(): void {\n    this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;\n    this.scrollbarWidth = this.getScrollbarWidth();\n  }\n\n  protected setScrollbar(): void {\n    if (!document) {\n      return;\n    }\n\n    this.originalBodyPadding = parseInt(\n      window\n        .getComputedStyle(document.body)\n        .getPropertyValue('padding-right') || 0,\n      10\n    );\n\n    if (this.isBodyOverflowing) {\n      document.body.style.paddingRight = `${this.originalBodyPadding +\n      this.scrollbarWidth}px`;\n    }\n  }\n\n  protected resetScrollbar(): void {\n    document.body.style.paddingRight = `${this.originalBodyPadding}px`;\n  }\n\n  // thx d.walsh\n  protected getScrollbarWidth(): number {\n    const scrollDiv = this._renderer.createElement('div');\n    this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);\n    this._renderer.appendChild(document.body, scrollDiv);\n    const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n    this._renderer.removeChild(document.body, scrollDiv);\n\n    return scrollbarWidth;\n  }\n}\n","import {\n  ComponentRef,\n  Injectable,\n  TemplateRef,\n  EventEmitter,\n  Renderer2,\n  RendererFactory2\n} from '@angular/core';\n\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { ModalBackdropComponent } from './modal-backdrop.component';\nimport { ModalContainerComponent } from './modal-container.component';\nimport {\n  CLASS_NAME,\n  modalConfigDefaults,\n  ModalOptions,\n  TRANSITION_DURATIONS\n} from './modal-options.class';\nimport { BsModalRef } from './bs-modal-ref.service';\n\n@Injectable()\nexport class BsModalService {\n  // constructor props\n  config: ModalOptions = modalConfigDefaults;\n\n  // tslint:disable-next-line:no-any\n  onShow: EventEmitter<any> = new EventEmitter();\n  // tslint:disable-next-line:no-any\n  onShown: EventEmitter<any> = new EventEmitter();\n  // tslint:disable-next-line:no-any\n  onHide: EventEmitter<any> = new EventEmitter();\n  // tslint:disable-next-line:no-any\n  onHidden: EventEmitter<any> = new EventEmitter();\n\n  protected isBodyOverflowing = false;\n  protected originalBodyPadding = 0;\n\n  protected scrollbarWidth = 0;\n\n  protected backdropRef: ComponentRef<ModalBackdropComponent>;\n  private _backdropLoader: ComponentLoader<ModalBackdropComponent>;\n  private modalsCount = 0;\n  private lastDismissReason = '';\n\n  private loaders: ComponentLoader<ModalContainerComponent>[] = [];\n\n  private _renderer: Renderer2;\n\n  constructor(rendererFactory: RendererFactory2, private clf: ComponentLoaderFactory) {\n    this._backdropLoader = this.clf.createLoader<ModalBackdropComponent>(\n      null,\n      null,\n      null\n    );\n    this._renderer = rendererFactory.createRenderer(null, null);\n  }\n\n  /** Shows a modal */\n  // tslint:disable-next-line:no-any\n  show(content: string | TemplateRef<any> | any, config?: ModalOptions): BsModalRef {\n    this.modalsCount++;\n    this._createLoaders();\n    this.config = Object.assign({}, modalConfigDefaults, config);\n    this._showBackdrop();\n    this.lastDismissReason = null;\n\n    return this._showModal(content);\n  }\n\n  hide(level: number) {\n    if (this.modalsCount === 1) {\n      this._hideBackdrop();\n      this.resetScrollbar();\n    }\n    this.modalsCount = this.modalsCount >= 1 ? this.modalsCount - 1 : 0;\n    setTimeout(() => {\n      this._hideModal(level);\n      this.removeLoaders(level);\n    }, this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0);\n  }\n\n  _showBackdrop(): void {\n    const isBackdropEnabled =\n      this.config.backdrop || this.config.backdrop === 'static';\n    const isBackdropInDOM =\n      !this.backdropRef || !this.backdropRef.instance.isShown;\n\n    if (this.modalsCount === 1) {\n      this.removeBackdrop();\n\n      if (isBackdropEnabled && isBackdropInDOM) {\n        this._backdropLoader\n          .attach(ModalBackdropComponent)\n          .to('body')\n          .show({ isAnimated: this.config.animated });\n        this.backdropRef = this._backdropLoader._componentRef;\n      }\n    }\n  }\n\n  _hideBackdrop(): void {\n    if (!this.backdropRef) {\n      return;\n    }\n    this.backdropRef.instance.isShown = false;\n    const duration = this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0;\n    setTimeout(() => this.removeBackdrop(), duration);\n  }\n  // tslint:disable-next-line:no-any\n  _showModal(content: any): BsModalRef {\n    const modalLoader = this.loaders[this.loaders.length - 1];\n    const bsModalRef = new BsModalRef();\n    const modalContainerRef = modalLoader\n      .provide({ provide: ModalOptions, useValue: this.config })\n      .provide({ provide: BsModalRef, useValue: bsModalRef })\n      .attach(ModalContainerComponent)\n      .to('body')\n      .show({content, isAnimated: this.config.animated, initialState: this.config.initialState, bsModalService: this});\n    modalContainerRef.instance.level = this.getModalsCount();\n    bsModalRef.hide = () => {\n      modalContainerRef.instance.hide();\n    };\n    bsModalRef.content = modalLoader.getInnerComponent() || null;\n    bsModalRef.setClass = (newClass: string) => {\n      modalContainerRef.instance.config.class = newClass;\n    };\n\n    return bsModalRef;\n  }\n\n  _hideModal(level: number): void {\n    const modalLoader = this.loaders[level - 1];\n    if (modalLoader) {\n      modalLoader.hide();\n    }\n  }\n\n  getModalsCount(): number {\n    return this.modalsCount;\n  }\n\n  setDismissReason(reason: string) {\n    this.lastDismissReason = reason;\n  }\n\n  removeBackdrop(): void {\n    this._backdropLoader.hide();\n    this.backdropRef = null;\n  }\n\n  /** AFTER PR MERGE MODAL.COMPONENT WILL BE USING THIS CODE */\n  /** Scroll bar tricks */\n  /** @internal */\n  checkScrollbar(): void {\n    this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;\n    this.scrollbarWidth = this.getScrollbarWidth();\n  }\n\n  setScrollbar(): void {\n    if (!document) {\n      return;\n    }\n\n    this.originalBodyPadding = parseInt(\n      window\n        .getComputedStyle(document.body)\n        .getPropertyValue('padding-right') || '0',\n      10\n    );\n\n    if (this.isBodyOverflowing) {\n      document.body.style.paddingRight = `${this.originalBodyPadding +\n        this.scrollbarWidth}px`;\n    }\n  }\n\n  private resetScrollbar(): void {\n    document.body.style.paddingRight = `${this.originalBodyPadding}px`;\n  }\n\n  // thx d.walsh\n  private getScrollbarWidth(): number {\n    const scrollDiv = this._renderer.createElement('div');\n    this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);\n    this._renderer.appendChild(document.body, scrollDiv);\n    const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;\n    this._renderer.removeChild(document.body, scrollDiv);\n\n    return scrollbarWidth;\n  }\n\n  private _createLoaders(): void {\n    const loader = this.clf.createLoader<ModalContainerComponent>(\n      null,\n      null,\n      null\n    );\n    this.copyEvent(loader.onBeforeShow, this.onShow);\n    this.copyEvent(loader.onShown, this.onShown);\n    this.copyEvent(loader.onBeforeHide, this.onHide);\n    this.copyEvent(loader.onHidden, this.onHidden);\n    this.loaders.push(loader);\n  }\n\n  private removeLoaders(level: number): void {\n    this.loaders.splice(level - 1, 1);\n    this.loaders.forEach(\n      (loader: ComponentLoader<ModalContainerComponent>, i: number) => {\n        loader.instance.level = i + 1;\n      }\n    );\n  }\n\n  // tslint:disable-next-line:no-any\n  private copyEvent(from: EventEmitter<any>, to: EventEmitter<any>) {\n    from.subscribe(() => {\n      to.emit(this.lastDismissReason);\n    });\n  }\n}\n","import { NgModule, ModuleWithProviders } from '@angular/core';\n\nimport { ModalBackdropComponent } from './modal-backdrop.component';\nimport { ModalDirective } from './modal.directive';\nimport { PositioningService } from 'ngx-bootstrap/positioning';\nimport { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { ModalContainerComponent } from './modal-container.component';\nimport { BsModalService } from './bs-modal.service';\n\n@NgModule({\n  declarations: [\n    ModalBackdropComponent,\n    ModalDirective,\n    ModalContainerComponent\n  ],\n  exports: [ModalBackdropComponent, ModalDirective],\n  entryComponents: [ModalBackdropComponent, ModalContainerComponent]\n})\nexport class ModalModule {\n  static forRoot(): ModuleWithProviders {\n    return {\n      ngModule: ModalModule,\n      providers: [BsModalService, ComponentLoaderFactory, PositioningService]\n    };\n  }\n}\n"],"names":["Injectable","isBs3","Component","ElementRef","Renderer2","HostListener","Utils","EventEmitter","document","window","Directive","ViewContainerRef","ComponentLoaderFactory","Input","Output","RendererFactory2","PositioningService","NgModule"],"mappings":"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"}