ngx-bootstrap 10.3.0 → 11.0.1

package/modal/esm2022/modal.directive.mjs

@@ -0,0 +1,364 @@
+// todo: should we support enforce focus in?
+// todo: in original bs there are was a way to prevent modal from showing
+// todo: original modal had resize events
+import { Directive, ElementRef, EventEmitter, HostListener, Input, Output, Renderer2, ViewContainerRef, Optional, Inject } from '@angular/core';
+import { document, window, Utils } from 'ngx-bootstrap/utils';
+import { ModalBackdropComponent } from './modal-backdrop.component';
+import { CLASS_NAME, DISMISS_REASONS, modalConfigDefaults, ModalOptions, MODAL_CONFIG_DEFAULT_OVERRIDE } from './modal-options.class';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/component-loader";
+import * as i2 from "./modal-options.class";
+const TRANSITION_DURATION = 300;
+const BACKDROP_TRANSITION_DURATION = 150;
+/** Mark any code with directive to show it's content in modal */
+export class ModalDirective {
+    /** allows to set modal configuration via element property */
+    set config(conf) {
+        this._config = this.getConfig(conf);
+    }
+    get config() {
+        return this._config;
+    }
+    get isShown() {
+        return this._isShown;
+    }
+    constructor(_element, _viewContainerRef, _renderer, clf, modalDefaultOption) {
+        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.clickStartedInContent = false;
+        this._focusEl = null;
+        this._backdrop = clf.createLoader(_element, _viewContainerRef, _renderer);
+        this._config = modalDefaultOption || modalConfigDefaults;
+    }
+    onClickStarted(event) {
+        this.clickStartedInContent = event.target !== this._element.nativeElement;
+    }
+    onClickStop(event) {
+        const clickedInBackdrop = event.target === this._element.nativeElement && !this.clickStartedInContent;
+        if (this.config.ignoreBackdropClick ||
+            this.config.backdrop === 'static' ||
+            !clickedInBackdrop) {
+            this.clickStartedInContent = false;
+            return;
+        }
+        this.dismissReason = DISMISS_REASONS.BACKRDOP;
+        this.hide(event);
+    }
+    // todo: consider preventing default and stopping propagation
+    onEsc(event) {
+        if (!this._isShown) {
+            return;
+        }
+        if (event.keyCode === 27 || event.key === 'Escape') {
+            event.preventDefault();
+        }
+        if (this.config.keyboard) {
+            this.dismissReason = DISMISS_REASONS.ESC;
+            this.hide();
+        }
+    }
+    ngOnDestroy() {
+        if (this._isShown) {
+            this._isShown = false;
+            this.hideModal();
+            this._backdrop.dispose();
+        }
+    }
+    ngOnInit() {
+        this._config = this._config || this.getConfig();
+        setTimeout(() => {
+            if (this._config.show) {
+                this.show();
+            }
+        }, 0);
+    }
+    /* Public methods */
+    /** Allows to manually toggle modal visibility */
+    toggle() {
+        return this._isShown ? this.hide() : this.show();
+    }
+    /** Allows to manually open modal */
+    show() {
+        this.dismissReason = void 0;
+        this.onShow.emit(this);
+        if (this._isShown) {
+            return;
+        }
+        clearTimeout(this.timerHideModal);
+        clearTimeout(this.timerRmBackDrop);
+        this._isShown = true;
+        this.checkScrollbar();
+        this.setScrollbar();
+        if (document && document.body) {
+            if (document.body.classList.contains(CLASS_NAME.OPEN)) {
+                this.isNested = true;
+            }
+            else {
+                this._renderer.addClass(document.body, CLASS_NAME.OPEN);
+                this._renderer.setStyle(document.body, 'overflow-y', 'hidden');
+            }
+        }
+        this.showBackdrop(() => {
+            this.showElement();
+        });
+    }
+    /** Check if we can close the modal */
+    hide(event) {
+        if (!this._isShown) {
+            return;
+        }
+        if (event) {
+            event.preventDefault();
+        }
+        if (this.config.closeInterceptor) {
+            this.config.closeInterceptor().then(() => this._hide(), () => undefined);
+            return;
+        }
+        this._hide();
+    }
+    /** Private methods @internal */
+    /**
+     *  Manually close modal
+     *  @internal
+     */
+    _hide() {
+        this.onHide.emit(this);
+        window.clearTimeout(this.timerHideModal);
+        window.clearTimeout(this.timerRmBackDrop);
+        this._isShown = false;
+        this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        if (this._config.animated) {
+            this.timerHideModal = window.setTimeout(() => this.hideModal(), TRANSITION_DURATION);
+        }
+        else {
+            this.hideModal();
+        }
+        if (this._focusEl) {
+            this._focusEl.focus();
+        }
+    }
+    getConfig(config) {
+        return Object.assign({}, this._config, config);
+    }
+    /**
+     *  Show dialog
+     *  @internal
+     */
+    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 && document.body) {
+                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.reflow(this._element.nativeElement);
+        }
+        this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        const transitionComplete = () => {
+            if (this._config.focus) {
+                this._element.nativeElement.focus();
+            }
+            this.onShown.emit(this);
+        };
+        if (this._config.animated) {
+            setTimeout(transitionComplete, TRANSITION_DURATION);
+        }
+        else {
+            transitionComplete();
+        }
+    }
+    /** @internal */
+    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 && document.body) {
+                    this._renderer.removeClass(document.body, CLASS_NAME.OPEN);
+                    this._renderer.setStyle(document.body, 'overflow-y', '');
+                }
+                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 */
+    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 callbackRemove = () => {
+                this.removeBackdrop();
+                if (callback) {
+                    callback();
+                }
+            };
+            if (this.backdrop.instance.isAnimated) {
+                this.timerRmBackDrop = window.setTimeout(callbackRemove, BACKDROP_TRANSITION_DURATION);
+            }
+            else {
+                callbackRemove();
+            }
+        }
+        else if (callback) {
+            callback();
+        }
+    }
+    /** @internal */
+    removeBackdrop() {
+        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)
+    // }
+    // }
+    focusOtherModal() {
+        if (this._element.nativeElement.parentElement == null) {
+            return;
+        }
+        const otherOpenedModals = this._element.nativeElement.parentElement.querySelectorAll('.in[bsModal]');
+        if (!otherOpenedModals.length) {
+            return;
+        }
+        otherOpenedModals[otherOpenedModals.length - 1].focus();
+    }
+    /** @internal */
+    resetAdjustments() {
+        this._renderer.setStyle(this._element.nativeElement, 'paddingLeft', '');
+        this._renderer.setStyle(this._element.nativeElement, 'paddingRight', '');
+    }
+    /** Scroll bar tricks */
+    /** @internal */
+    checkScrollbar() {
+        this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;
+        this.scrollbarWidth = this.getScrollbarWidth();
+    }
+    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`;
+        }
+    }
+    resetScrollbar() {
+        document.body.style.paddingRight = `${this.originalBodyPadding}px`;
+    }
+    // thx d.walsh
+    getScrollbarWidth() {
+        const scrollDiv = this._renderer.createElement('div');
+        this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
+        this._renderer.appendChild(document.body, scrollDiv);
+        const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+        this._renderer.removeChild(document.body, scrollDiv);
+        return scrollbarWidth;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i1.ComponentLoaderFactory }, { token: MODAL_CONFIG_DEFAULT_OVERRIDE, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: ModalDirective, selector: "[bsModal]", inputs: { config: "config", closeInterceptor: "closeInterceptor" }, outputs: { onShow: "onShow", onShown: "onShown", onHide: "onHide", onHidden: "onHidden" }, host: { listeners: { "mousedown": "onClickStarted($event)", "mouseup": "onClickStop($event)", "keydown.esc": "onEsc($event)" } }, exportAs: ["bs-modal"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsModal]',
+                    exportAs: 'bs-modal'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i0.Renderer2 }, { type: i1.ComponentLoaderFactory }, { type: i2.ModalOptions, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MODAL_CONFIG_DEFAULT_OVERRIDE]
+                }] }]; }, propDecorators: { config: [{
+                type: Input
+            }], closeInterceptor: [{
+                type: Input
+            }], onShow: [{
+                type: Output
+            }], onShown: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onHidden: [{
+                type: Output
+            }], onClickStarted: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], onClickStop: [{
+                type: HostListener,
+                args: ['mouseup', ['$event']]
+            }], onEsc: [{
+                type: HostListener,
+                args: ['keydown.esc', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.directive.js","sourceRoot":"","sources":["../../../../src/modal/modal.directive.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,yEAAyE;AACzE,yCAAyC;AAEzC,OAAO,EACS,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,KAAK,EACnD,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EACzE,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EACL,UAAU,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,6BAA6B,EAC9F,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAmB,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;;;;AAGzF,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAChC,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAEzC,iEAAiE;AAKjE,MAAM,OAAO,cAAc;IACzB,6DAA6D;IAC7D,IACI,MAAM,CAAC,IAAkB;QAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IA8BD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAoBD,YACU,QAAoB,EAC5B,iBAAmC,EAC3B,SAAoB,EAC5B,GAA2B,EACwB,kBAAgC;QAJ3E,aAAQ,GAAR,QAAQ,CAAY;QAEpB,cAAS,GAAT,SAAS,CAAW;QAlD9B,8EAA8E;QAE9E,WAAM,GAAiC,IAAI,YAAY,EAAkB,CAAC;QAC1E;;WAEG;QAEH,YAAO,GAAiC,IAAI,YAAY,EAAkB,CAAC;QAC3E;;WAEG;QAEH,WAAM,GAAiC,IAAI,YAAY,EAAkB,CAAC;QAC1E;;WAEG;QAEH,aAAQ,GAAiC,IAAI,YAAY,EAAkB,CAAC;QAalE,aAAQ,GAAG,KAAK,CAAC;QAEjB,sBAAiB,GAAG,KAAK,CAAC;QAC1B,wBAAmB,GAAG,CAAC,CAAC;QACxB,mBAAc,GAAG,CAAC,CAAC;QAEnB,mBAAc,GAAG,CAAC,CAAC;QACnB,oBAAe,GAAG,CAAC,CAAC;QAMtB,aAAQ,GAAG,KAAK,CAAC;QACjB,0BAAqB,GAAG,KAAK,CAAC;QAC9B,aAAQ,GAAmB,IAAI,CAAC;QAQtC,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC,YAAY,CAC/B,QAAQ,EACR,iBAAiB,EACjB,SAAS,CACV,CAAC;QACF,IAAI,CAAC,OAAO,GAAG,kBAAkB,IAAI,mBAAmB,CAAC;IAC3D,CAAC;IAGD,cAAc,CAAC,KAAiB;QAC9B,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;IAC5E,CAAC;IAGD,WAAW,CAAC,KAAiB;QAC3B,MAAM,iBAAiB,GAAG,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,QAAQ,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC;QACtG,IACE,IAAI,CAAC,MAAM,CAAC,mBAAmB;YAC/B,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,QAAQ;YACjC,CAAC,iBAAiB,EAClB;YACA,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;YAEnC,OAAO;SACR;QACD,IAAI,CAAC,aAAa,GAAG,eAAe,CAAC,QAAQ,CAAC;QAC9C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED,6DAA6D;IAE7D,KAAK,CAAC,KAAoB;QACxB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,OAAO;SACR;QACD,IAAI,KAAK,CAAC,OAAO,KAAK,EAAE,IAAI,KAAK,CAAC,GAAG,KAAK,QAAQ,EAAE;YAClD,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE;YACxB,IAAI,CAAC,aAAa,GAAG,eAAe,CAAC,GAAG,CAAC;YACzC,IAAI,CAAC,IAAI,EAAE,CAAC;SACb;IACH,CAAC;IAED,WAAW;QACT,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QAChD,UAAU,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;gBACrB,IAAI,CAAC,IAAI,EAAE,CAAC;aACb;QACH,CAAC,EAAE,CAAC,CAAC,CAAC;IACR,CAAC;IAED,oBAAoB;IAEpB,iDAAiD;IACjD,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACnD,CAAC;IAED,oCAAoC;IACpC,IAAI;QACF,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,OAAO;SACR;QACD,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAClC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAEnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QAErB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE;YAC7B,IAAI,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACrD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;aACtB;iBAAM;gBACL,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;gBACxD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC;aAChE;SACF;QAED,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE;YACrB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,sCAAsC;IACtC,IAAI,CAAC,KAAa;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,OAAO;SACR;QAED,IAAI,KAAK,EAAE;YACT,KAAK,CAAC,cAAc,EAAE,CAAC;SACxB;QAED,IAAI,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE;YAChC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC,IAAI,CACjC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAClB,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAEnB,OAAO;SACR;QAED,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED,gCAAgC;IAEhC;;;OAGG;IACO,KAAK;QACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEvB,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACzC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE1C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QAEzE,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;YACzB,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,UAAU,CACrC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,EACtB,mBAAmB,CACpB,CAAC;SACH;aAAM;YACL,IAAI,CAAC,SAAS,EAAE,CAAC;SAClB;QAED,IAAI,IAAI,CAAC,QAAQ,EAAE;YAChB,IAAI,CAAC,QAAwB,CAAC,KAAK,EAAE,CAAC;SACxC;IACH,CAAC;IAES,SAAS,CAAC,MAAqB;QACvC,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;IAED;;;OAGG;IACO,WAAW;QACnB,iDAAiD;QACjD,IACE,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU;YACvC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EACrE;YACA,iCAAiC;YACjC,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE;gBAC7B,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;aACxD;SACF;QAED,IAAI,CAAC,SAAS,CAAC,YAAY,CACzB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,aAAa,EACb,OAAO,CACR,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,YAAY,CACzB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,YAAY,EACZ,MAAM,CACP,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,QAAQ,CACrB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,SAAS,EACT,OAAO,CACR,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,WAAW,CACxB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,WAAW,EACX,CAAC,CACF,CAAC;QAEF,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;YACzB,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;SAC3C;QAED,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QAEtE,MAAM,kBAAkB,GAAG,GAAG,EAAE;YAC9B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBACtB,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;aACrC;YACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;YACzB,UAAU,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;SACrD;aAAM;YACL,kBAAkB,EAAE,CAAC;SACtB;IACH,CAAC;IAED,gBAAgB;IACN,SAAS;QACjB,IAAI,CAAC,SAAS,CAAC,YAAY,CACzB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,aAAa,EACb,MAAM,CACP,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,QAAQ,CACrB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,SAAS,EACT,MAAM,CACP,CAAC;QACF,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE;YACrB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;gBAClB,IAAI,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE;oBAC7B,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;oBAC3D,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;iBAC1D;gBACD,IAAI,CAAC,cAAc,EAAE,CAAC;aACvB;YACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;IACL,CAAC;IAED,uEAAuE;IACvE,UAAU;IACV,gBAAgB;IACN,YAAY,CAAC,QAAqB;QAC1C,IACE,IAAI,CAAC,QAAQ;YACb,IAAI,CAAC,MAAM,CAAC,QAAQ;YACpB,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,EACnD;YACA,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS;iBACX,MAAM,CAAC,sBAAsB,CAAC;iBAC9B,EAAE,CAAC,MAAM,CAAC;iBACV,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC/C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;YAE7C,IAAI,CAAC,QAAQ,EAAE;gBACb,OAAO;aACR;YAED,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;gBAC1B,QAAQ,EAAE,CAAC;gBAEX,OAAO;aACR;YAED,UAAU,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAC;SACpD;aAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC1C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,GAAG,KAAK,CAAC;YAEvC,MAAM,cAAc,GAAG,GAAG,EAAE;gBAC1B,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,IAAI,QAAQ,EAAE;oBACZ,QAAQ,EAAE,CAAC;iBACZ;YACH,CAAC,CAAC;YAEF,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,EAAE;gBACrC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,UAAU,CACtC,cAAc,EACd,4BAA4B,CAC7B,CAAC;aACH;iBAAM;gBACL,cAAc,EAAE,CAAC;aAClB;SACF;aAAM,IAAI,QAAQ,EAAE;YACnB,QAAQ,EAAE,CAAC;SACZ;IACH,CAAC;IAED,gBAAgB;IACN,cAAc;QACtB,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IACxB,CAAC;IAED,oBAAoB;IAEpB,iBAAiB;IACjB,oCAAoC;IACpC,kDAAkD;IAClD,8DAA8D;IAC9D,kCAAkC;IAClC,sBAAsB;IACtB,UAAU;IACV,SAAS;IACT,EAAE;IACF,iCAAiC;IACjC,kDAAkD;IAClD,MAAM;IACN,IAAI;IAEJ,oCAAoC;IACpC,6DAA6D;IAC7D,uBAAuB;IACvB,kEAAkE;IAClE,WAAW;IACX,gCAAgC;IAChC,IAAI;IACJ,IAAI;IAEM,eAAe;QACvB,IAAI,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,aAAa,IAAI,IAAI,EAAE;YACrD,OAAO;SACR;QACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QACrG,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE;YAC7B,OAAO;SACR;QACD,iBAAiB,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;IAC1D,CAAC;IAED,gBAAgB;IACN,gBAAgB;QACxB,IAAI,CAAC,SAAS,CAAC,QAAQ,CACrB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,aAAa,EACb,EAAE,CACH,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,QAAQ,CACrB,IAAI,CAAC,QAAQ,CAAC,aAAa,EAC3B,cAAc,EACd,EAAE,CACH,CAAC;IACJ,CAAC;IAED,wBAAwB;IACxB,gBAAgB;IACN,cAAc;QACtB,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC;QACvE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;IACjD,CAAC;IAES,YAAY;QACpB,IAAI,CAAC,QAAQ,EAAE;YACb,OAAO;SACR;QAED,IAAI,CAAC,mBAAmB,GAAG,QAAQ,CACjC,MAAM;aACH,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC;aAC/B,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,EACzC,EAAE,CACH,CAAC;QAEF,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,GAAG,IAAI,CAAC,mBAAmB;gBAC5D,IAAI,CAAC,cAAc,IAAI,CAAC;SAC3B;IACH,CAAC;IAES,cAAc;QACtB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,GAAG,IAAI,CAAC,mBAAmB,IAAI,CAAC;IACrE,CAAC;IAED,cAAc;IACJ,iBAAiB;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC;QAClE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACrD,MAAM,cAAc,GAAG,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QACrE,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAErD,OAAO,cAAc,CAAC;IACxB,CAAC;8GA7bU,cAAc,2IAkEH,6BAA6B;kGAlExC,cAAc;;2FAAd,cAAc;kBAJ1B,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,UAAU;iBACrB;;0BAmEI,QAAQ;;0BAAI,MAAM;2BAAC,6BAA6B;4CA/D/C,MAAM;sBADT,KAAK;gBAUG,gBAAgB;sBAAxB,KAAK;gBAIN,MAAM;sBADL,MAAM;gBAMP,OAAO;sBADN,MAAM;gBAMP,MAAM;sBADL,MAAM;gBAMP,QAAQ;sBADP,MAAM;gBA8CP,cAAc;sBADb,YAAY;uBAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBAMrC,WAAW;sBADV,YAAY;uBAAC,SAAS,EAAE,CAAC,QAAQ,CAAC;gBAkBnC,KAAK;sBADJ,YAAY;uBAAC,aAAa,EAAE,CAAC,QAAQ,CAAC","sourcesContent":["// 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, Optional, Inject\n} from '@angular/core';\n\nimport { document, window, Utils } from 'ngx-bootstrap/utils';\nimport { ModalBackdropComponent } from './modal-backdrop.component';\nimport {\n  CLASS_NAME, DISMISS_REASONS, modalConfigDefaults, ModalOptions, MODAL_CONFIG_DEFAULT_OVERRIDE\n} from './modal-options.class';\nimport { ComponentLoader, ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';\nimport { CloseInterceptorFn } from './models';\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  /** allows to provide a callback to intercept the closure of the modal */\n  @Input() closeInterceptor?: CloseInterceptorFn;\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 `id: number`\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  private clickStartedInContent = false;\n  private _focusEl: Element | null = null;\n\n  constructor(\n    private _element: ElementRef,\n    _viewContainerRef: ViewContainerRef,\n    private _renderer: Renderer2,\n    clf: ComponentLoaderFactory,\n    @Optional() @Inject(MODAL_CONFIG_DEFAULT_OVERRIDE) modalDefaultOption: ModalOptions) {\n    this._backdrop = clf.createLoader<ModalBackdropComponent>(\n      _element,\n      _viewContainerRef,\n      _renderer\n    );\n    this._config = modalDefaultOption || modalConfigDefaults;\n  }\n\n  @HostListener('mousedown', ['$event'])\n  onClickStarted(event: MouseEvent): void {\n    this.clickStartedInContent = event.target !== this._element.nativeElement;\n  }\n\n  @HostListener('mouseup', ['$event'])\n  onClickStop(event: MouseEvent): void {\n    const clickedInBackdrop = event.target === this._element.nativeElement && !this.clickStartedInContent;\n    if (\n      this.config.ignoreBackdropClick ||\n      this.config.backdrop === 'static' ||\n      !clickedInBackdrop\n    ) {\n      this.clickStartedInContent = false;\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    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    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 = void 0;\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        this._renderer.setStyle(document.body, 'overflow-y', 'hidden');\n      }\n    }\n\n    this.showBackdrop(() => {\n      this.showElement();\n    });\n  }\n\n  /** Check if we can close the modal */\n  hide(event?: Event): void {\n    if (!this._isShown) {\n      return;\n    }\n\n    if (event) {\n      event.preventDefault();\n    }\n\n    if (this.config.closeInterceptor) {\n      this.config.closeInterceptor().then(\n        () => this._hide(),\n        () => undefined);\n\n      return;\n    }\n\n    this._hide();\n  }\n\n  /** Private methods @internal */\n\n  /**\n   *  Manually close modal\n   *  @internal\n   */\n  protected _hide(): void {\n    this.onHide.emit(this);\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.SHOW);\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    if (this._focusEl) {\n      (this._focusEl as HTMLElement).focus();\n    }\n  }\n\n  protected getConfig(config?: ModalOptions): ModalOptions {\n    return Object.assign({}, this._config, 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._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);\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          this._renderer.setStyle(document.body, 'overflow-y', '');\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?: () => void): 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"]}

package/modal/{esm2020 → esm2022}/modal.module.mjs

@@ -21,13 +21,13 @@ export class ModalModule {
             providers: [BsModalService, ComponentLoaderFactory, PositioningService]
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, declarations: [ModalBackdropComponent,
+            ModalDirective,
+            ModalContainerComponent], imports: [FocusTrapModule], exports: [ModalBackdropComponent, ModalDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, imports: [FocusTrapModule] }); }
 }
-ModalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ModalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, declarations: [ModalBackdropComponent,
-        ModalDirective,
-        ModalContainerComponent], imports: [FocusTrapModule], exports: [ModalBackdropComponent, ModalDirective] });
-ModalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, imports: [FocusTrapModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [FocusTrapModule],
@@ -39,4 +39,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImpor
                     exports: [ModalBackdropComponent, ModalDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/modal/{fesm2020 → fesm2022}/ngx-bootstrap-modal.mjs

@@ -19,10 +19,10 @@ class BsModalRef {
          */
         this.setClass = () => void 0;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalRef, providedIn: 'platform' }); }
 }
-BsModalRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-BsModalRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalRef, providedIn: 'platform' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalRef, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalRef, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'platform' }]
         }] });
@@ -35,10 +35,10 @@ class ModalBackdropOptions {
 }
 
 class ModalOptions {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalOptions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalOptions, providedIn: 'platform' }); }
 }
-ModalOptions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalOptions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-ModalOptions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalOptions, providedIn: 'platform' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalOptions, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalOptions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'platform' }]
         }] });
@@ -175,9 +175,8 @@ class ModalContainerComponent {
             }
         }, this.isAnimated ? TRANSITION_DURATIONS.MODAL : 0);
     }
-}
-ModalContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalContainerComponent, deps: [{ token: ModalOptions }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
-ModalContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.3", type: ModalContainerComponent, selector: "modal-container", host: { attributes: { "role": "dialog", "tabindex": "-1" }, listeners: { "mousedown": "onClickStarted($event)", "click": "onClickStop($event)", "window:popstate": "onPopState()", "window:keydown.esc": "onEsc($event)" }, properties: { "attr.aria-modal": "true", "attr.aria-labelledby": "config.ariaLabelledBy", "attr.aria-describedby": "config.ariaDescribedby" }, classAttribute: "modal" }, ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalContainerComponent, deps: [{ token: ModalOptions }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: ModalContainerComponent, selector: "modal-container", host: { attributes: { "role": "dialog", "tabindex": "-1" }, listeners: { "mousedown": "onClickStarted($event)", "click": "onClickStop($event)", "window:popstate": "onPopState()", "window:keydown.esc": "onEsc($event)" }, properties: { "attr.aria-modal": "true", "attr.aria-labelledby": "config.ariaLabelledBy", "attr.aria-describedby": "config.ariaDescribedby" }, classAttribute: "modal" }, ngImport: i0, template: `
     <div [class]="'modal-dialog' + (config.class ? ' ' + config.class : '')"
          role="document"
          focusTrap>
@@ -185,8 +184,9 @@ ModalContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0"
         <ng-content></ng-content>
       </div>
     </div>
-  `, isInline: true, dependencies: [{ kind: "directive", type: i2.FocusTrapDirective, selector: "[focusTrap]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["focusTrap"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalContainerComponent, decorators: [{
+  `, isInline: true, dependencies: [{ kind: "directive", type: i2.FocusTrapDirective, selector: "[focusTrap]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["focusTrap"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalContainerComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'modal-container',
@@ -225,12 +225,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImpor
 
 /** This component will be added as background layout for modals if enabled */
 class ModalBackdropComponent {
-    constructor(element, renderer) {
-        this._isAnimated = false;
-        this._isShown = false;
-        this.element = element;
-        this.renderer = renderer;
-    }
     get isAnimated() {
         return this._isAnimated;
     }
@@ -249,6 +243,12 @@ class ModalBackdropComponent {
             this.renderer.removeClass(this.element.nativeElement, `${CLASS_NAME.SHOW}`);
         }
     }
+    constructor(element, renderer) {
+        this._isAnimated = false;
+        this._isShown = false;
+        this.element = element;
+        this.renderer = renderer;
+    }
     ngOnInit() {
         if (this.isAnimated) {
             this.renderer.addClass(this.element.nativeElement, `${CLASS_NAME.FADE}`);
@@ -256,10 +256,10 @@ class ModalBackdropComponent {
         }
         this.isShown = true;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalBackdropComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.4", type: ModalBackdropComponent, selector: "bs-modal-backdrop", host: { classAttribute: "modal-backdrop" }, ngImport: i0, template: ' ', isInline: true }); }
 }
-ModalBackdropComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalBackdropComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
-ModalBackdropComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.3", type: ModalBackdropComponent, selector: "bs-modal-backdrop", host: { classAttribute: "modal-backdrop" }, ngImport: i0, template: ' ', isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalBackdropComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalBackdropComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'bs-modal-backdrop',
@@ -270,10 +270,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImpor
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; } });
 
 // todo: should we support enforce focus in?
+// todo: in original bs there are was a way to prevent modal from showing
+// todo: original modal had resize events
 const TRANSITION_DURATION = 300;
 const BACKDROP_TRANSITION_DURATION = 150;
 /** Mark any code with directive to show it's content in modal */
 class ModalDirective {
+    /** allows to set modal configuration via element property */
+    set config(conf) {
+        this._config = this.getConfig(conf);
+    }
+    get config() {
+        return this._config;
+    }
+    get isShown() {
+        return this._isShown;
+    }
     constructor(_element, _viewContainerRef, _renderer, clf, modalDefaultOption) {
         this._element = _element;
         this._renderer = _renderer;
@@ -303,16 +315,6 @@ class ModalDirective {
         this._backdrop = clf.createLoader(_element, _viewContainerRef, _renderer);
         this._config = modalDefaultOption || modalConfigDefaults;
     }
-    /** allows to set modal configuration via element property */
-    set config(conf) {
-        this._config = this.getConfig(conf);
-    }
-    get config() {
-        return this._config;
-    }
-    get isShown() {
-        return this._isShown;
-    }
     onClickStarted(event) {
         this.clickStartedInContent = event.target !== this._element.nativeElement;
     }
@@ -586,10 +588,10 @@ class ModalDirective {
         this._renderer.removeChild(document.body, scrollDiv);
         return scrollbarWidth;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i1.ComponentLoaderFactory }, { token: MODAL_CONFIG_DEFAULT_OVERRIDE, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.4", type: ModalDirective, selector: "[bsModal]", inputs: { config: "config", closeInterceptor: "closeInterceptor" }, outputs: { onShow: "onShow", onShown: "onShown", onHide: "onHide", onHidden: "onHidden" }, host: { listeners: { "mousedown": "onClickStarted($event)", "mouseup": "onClickStop($event)", "keydown.esc": "onEsc($event)" } }, exportAs: ["bs-modal"], ngImport: i0 }); }
 }
-ModalDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalDirective, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i1.ComponentLoaderFactory }, { token: MODAL_CONFIG_DEFAULT_OVERRIDE, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-ModalDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.3", type: ModalDirective, selector: "[bsModal]", inputs: { config: "config", closeInterceptor: "closeInterceptor" }, outputs: { onShow: "onShow", onShown: "onShown", onHide: "onHide", onHidden: "onHidden" }, host: { listeners: { "mousedown": "onClickStarted($event)", "mouseup": "onClickStop($event)", "keydown.esc": "onEsc($event)" } }, exportAs: ["bs-modal"], ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[bsModal]',
@@ -825,10 +827,10 @@ class BsModalService {
             to.emit(this.lastDismissReason || data);
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalService, deps: [{ token: i0.RendererFactory2 }, { token: i1.ComponentLoaderFactory }, { token: MODAL_CONFIG_DEFAULT_OVERRIDE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalService, providedIn: 'platform' }); }
 }
-BsModalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalService, deps: [{ token: i0.RendererFactory2 }, { token: i1.ComponentLoaderFactory }, { token: MODAL_CONFIG_DEFAULT_OVERRIDE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-BsModalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalService, providedIn: 'platform' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: BsModalService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: BsModalService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'platform' }]
         }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }, { type: i1.ComponentLoaderFactory }, { type: ModalOptions, decorators: [{
@@ -852,13 +854,13 @@ class ModalModule {
             providers: [BsModalService, ComponentLoaderFactory, PositioningService]
         };
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, declarations: [ModalBackdropComponent,
+            ModalDirective,
+            ModalContainerComponent], imports: [FocusTrapModule], exports: [ModalBackdropComponent, ModalDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, imports: [FocusTrapModule] }); }
 }
-ModalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ModalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, declarations: [ModalBackdropComponent,
-        ModalDirective,
-        ModalContainerComponent], imports: [FocusTrapModule], exports: [ModalBackdropComponent, ModalDirective] });
-ModalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, imports: [FocusTrapModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.3", ngImport: i0, type: ModalModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [FocusTrapModule],