ngx-bootstrap 3.0.1 → 3.1.4

package/modal/esm2015/modal.directive.js

@@ -0,0 +1,459 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/* tslint:disable:max-file-line-count */
+// 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 } from '@angular/core';
+import { document, window, isBs3, Utils } from 'ngx-bootstrap/utils';
+import { ModalBackdropComponent } from './modal-backdrop.component';
+import { CLASS_NAME, DISMISS_REASONS, modalConfigDefaults, ModalOptions } from './modal-options.class';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+const /** @type {?} */ TRANSITION_DURATION = 300;
+const /** @type {?} */ BACKDROP_TRANSITION_DURATION = 150;
+/**
+ * Mark any code with directive to show it's content in modal
+ */
+export class ModalDirective {
+    /**
+     * @param {?} _element
+     * @param {?} _viewContainerRef
+     * @param {?} _renderer
+     * @param {?} clf
+     */
+    constructor(_element, _viewContainerRef, _renderer, clf) {
+        this._element = _element;
+        this._renderer = _renderer;
+        /**
+         * This event fires immediately when the `show` instance method is called.
+         */
+        this.onShow = new EventEmitter();
+        /**
+         * This event is fired when the modal has been made visible to the user
+         * (will wait for CSS transitions to complete)
+         */
+        this.onShown = new EventEmitter();
+        /**
+         * This event is fired immediately when
+         * the hide instance method has been called.
+         */
+        this.onHide = new EventEmitter();
+        /**
+         * This event is fired when the modal has finished being
+         * hidden from the user (will wait for CSS transitions to complete).
+         */
+        this.onHidden = new EventEmitter();
+        this._isShown = false;
+        this.isBodyOverflowing = false;
+        this.originalBodyPadding = 0;
+        this.scrollbarWidth = 0;
+        this.timerHideModal = 0;
+        this.timerRmBackDrop = 0;
+        this.isNested = false;
+        this._backdrop = clf.createLoader(_element, _viewContainerRef, _renderer);
+    }
+    /**
+     * allows to set modal configuration via element property
+     * @param {?} conf
+     * @return {?}
+     */
+    set config(conf) {
+        this._config = this.getConfig(conf);
+    }
+    /**
+     * @return {?}
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * @return {?}
+     */
+    get isShown() {
+        return this._isShown;
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onClick(event) {
+        if (this.config.ignoreBackdropClick ||
+            this.config.backdrop === 'static' ||
+            event.target !== this._element.nativeElement) {
+            return;
+        }
+        this.dismissReason = DISMISS_REASONS.BACKRDOP;
+        this.hide(event);
+    }
+    /**
+     * @param {?} event
+     * @return {?}
+     */
+    onEsc(event) {
+        if (!this._isShown) {
+            return;
+        }
+        // tslint:disable-next-line:deprecation
+        if (event.keyCode === 27 || event.key === 'Escape') {
+            event.preventDefault();
+        }
+        if (this.config.keyboard) {
+            this.dismissReason = DISMISS_REASONS.ESC;
+            this.hide();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.config = void 0;
+        if (this._isShown) {
+            this._isShown = false;
+            this.hideModal();
+            this._backdrop.dispose();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this._config = this._config || this.getConfig();
+        setTimeout(() => {
+            if (this._config.show) {
+                this.show();
+            }
+        }, 0);
+    }
+    /**
+     * Allows to manually toggle modal visibility
+     * @return {?}
+     */
+    toggle() {
+        return this._isShown ? this.hide() : this.show();
+    }
+    /**
+     * Allows to manually open modal
+     * @return {?}
+     */
+    show() {
+        this.dismissReason = null;
+        this.onShow.emit(this);
+        if (this._isShown) {
+            return;
+        }
+        clearTimeout(this.timerHideModal);
+        clearTimeout(this.timerRmBackDrop);
+        this._isShown = true;
+        this.checkScrollbar();
+        this.setScrollbar();
+        if (document && document.body) {
+            if (document.body.classList.contains(CLASS_NAME.OPEN)) {
+                this.isNested = true;
+            }
+            else {
+                this._renderer.addClass(document.body, CLASS_NAME.OPEN);
+            }
+        }
+        this.showBackdrop(() => {
+            this.showElement();
+        });
+    }
+    /**
+     * Allows to manually close modal
+     * @param {?=} event
+     * @return {?}
+     */
+    hide(event) {
+        if (event) {
+            event.preventDefault();
+        }
+        this.onHide.emit(this);
+        // todo: add an option to prevent hiding
+        if (!this._isShown) {
+            return;
+        }
+        window.clearTimeout(this.timerHideModal);
+        window.clearTimeout(this.timerRmBackDrop);
+        this._isShown = false;
+        this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.IN);
+        if (!isBs3()) {
+            this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        }
+        // this._addClassIn = false;
+        if (this._config.animated) {
+            this.timerHideModal = window.setTimeout(() => this.hideModal(), TRANSITION_DURATION);
+        }
+        else {
+            this.hideModal();
+        }
+    }
+    /**
+     * Private methods \@internal
+     * @param {?=} config
+     * @return {?}
+     */
+    getConfig(config) {
+        return Object.assign({}, modalConfigDefaults, config);
+    }
+    /**
+     *  Show dialog
+     *  \@internal
+     * @return {?}
+     */
+    showElement() {
+        // todo: replace this with component loader usage
+        if (!this._element.nativeElement.parentNode ||
+            this._element.nativeElement.parentNode.nodeType !== Node.ELEMENT_NODE) {
+            // don't move modals dom position
+            if (document && 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._addClassIn = true;
+        this._renderer.addClass(this._element.nativeElement, CLASS_NAME.IN);
+        if (!isBs3()) {
+            this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        }
+        const /** @type {?} */ transitionComplete = () => {
+            if (this._config.focus) {
+                this._element.nativeElement.focus();
+            }
+            this.onShown.emit(this);
+        };
+        if (this._config.animated) {
+            setTimeout(transitionComplete, TRANSITION_DURATION);
+        }
+        else {
+            transitionComplete();
+        }
+    }
+    /**
+     * \@internal
+     * @return {?}
+     */
+    hideModal() {
+        this._renderer.setAttribute(this._element.nativeElement, 'aria-hidden', 'true');
+        this._renderer.setStyle(this._element.nativeElement, 'display', 'none');
+        this.showBackdrop(() => {
+            if (!this.isNested) {
+                if (document && document.body) {
+                    this._renderer.removeClass(document.body, CLASS_NAME.OPEN);
+                }
+                this.resetScrollbar();
+            }
+            this.resetAdjustments();
+            this.focusOtherModal();
+            this.onHidden.emit(this);
+        });
+    }
+    /**
+     * \@internal
+     * @param {?=} callback
+     * @return {?}
+     */
+    showBackdrop(callback) {
+        if (this._isShown &&
+            this.config.backdrop &&
+            (!this.backdrop || !this.backdrop.instance.isShown)) {
+            this.removeBackdrop();
+            this._backdrop
+                .attach(ModalBackdropComponent)
+                .to('body')
+                .show({ isAnimated: this._config.animated });
+            this.backdrop = this._backdrop._componentRef;
+            if (!callback) {
+                return;
+            }
+            if (!this._config.animated) {
+                callback();
+                return;
+            }
+            setTimeout(callback, BACKDROP_TRANSITION_DURATION);
+        }
+        else if (!this._isShown && this.backdrop) {
+            this.backdrop.instance.isShown = false;
+            const /** @type {?} */ callbackRemove = () => {
+                this.removeBackdrop();
+                if (callback) {
+                    callback();
+                }
+            };
+            if (this.backdrop.instance.isAnimated) {
+                this.timerRmBackDrop = window.setTimeout(callbackRemove, BACKDROP_TRANSITION_DURATION);
+            }
+            else {
+                callbackRemove();
+            }
+        }
+        else if (callback) {
+            callback();
+        }
+    }
+    /**
+     * \@internal
+     * @return {?}
+     */
+    removeBackdrop() {
+        this._backdrop.hide();
+    }
+    /**
+     * Events tricks
+     * @return {?}
+     */
+    focusOtherModal() {
+        if (this._element.nativeElement.parentElement == null) {
+            return;
+        }
+        const /** @type {?} */ otherOpenedModals = this._element.nativeElement.parentElement.querySelectorAll('.in[bsModal]');
+        if (!otherOpenedModals.length) {
+            return;
+        }
+        otherOpenedModals[otherOpenedModals.length - 1].focus();
+    }
+    /**
+     * \@internal
+     * @return {?}
+     */
+    resetAdjustments() {
+        this._renderer.setStyle(this._element.nativeElement, 'paddingLeft', '');
+        this._renderer.setStyle(this._element.nativeElement, 'paddingRight', '');
+    }
+    /**
+     * \@internal
+     * @return {?}
+     */
+    checkScrollbar() {
+        this.isBodyOverflowing = document.body.clientWidth < window.innerWidth;
+        this.scrollbarWidth = this.getScrollbarWidth();
+    }
+    /**
+     * @return {?}
+     */
+    setScrollbar() {
+        if (!document) {
+            return;
+        }
+        this.originalBodyPadding = parseInt(window
+            .getComputedStyle(document.body)
+            .getPropertyValue('padding-right') || 0, 10);
+        if (this.isBodyOverflowing) {
+            document.body.style.paddingRight = `${this.originalBodyPadding +
+                this.scrollbarWidth}px`;
+        }
+    }
+    /**
+     * @return {?}
+     */
+    resetScrollbar() {
+        document.body.style.paddingRight = `${this.originalBodyPadding}px`;
+    }
+    /**
+     * @return {?}
+     */
+    getScrollbarWidth() {
+        const /** @type {?} */ scrollDiv = this._renderer.createElement('div');
+        this._renderer.addClass(scrollDiv, CLASS_NAME.SCROLLBAR_MEASURER);
+        this._renderer.appendChild(document.body, scrollDiv);
+        const /** @type {?} */ scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
+        this._renderer.removeChild(document.body, scrollDiv);
+        return scrollbarWidth;
+    }
+}
+ModalDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[bsModal]',
+                exportAs: 'bs-modal'
+            },] }
+];
+/** @nocollapse */
+ModalDirective.ctorParameters = () => [
+    { type: ElementRef, },
+    { type: ViewContainerRef, },
+    { type: Renderer2, },
+    { type: ComponentLoaderFactory, },
+];
+ModalDirective.propDecorators = {
+    "config": [{ type: Input },],
+    "onShow": [{ type: Output },],
+    "onShown": [{ type: Output },],
+    "onHide": [{ type: Output },],
+    "onHidden": [{ type: Output },],
+    "onClick": [{ type: HostListener, args: ['click', ['$event'],] },],
+    "onEsc": [{ type: HostListener, args: ['keydown.esc', ['$event'],] },],
+};
+function ModalDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    ModalDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    ModalDirective.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    ModalDirective.propDecorators;
+    /**
+     * This event fires immediately when the `show` instance method is called.
+     * @type {?}
+     */
+    ModalDirective.prototype.onShow;
+    /**
+     * This event is fired when the modal has been made visible to the user
+     * (will wait for CSS transitions to complete)
+     * @type {?}
+     */
+    ModalDirective.prototype.onShown;
+    /**
+     * This event is fired immediately when
+     * the hide instance method has been called.
+     * @type {?}
+     */
+    ModalDirective.prototype.onHide;
+    /**
+     * This event is fired when the modal has finished being
+     * hidden from the user (will wait for CSS transitions to complete).
+     * @type {?}
+     */
+    ModalDirective.prototype.onHidden;
+    /**
+     * This field contains last dismiss reason.
+     * Possible values: `backdrop-click`, `esc` and `null`
+     * (if modal was closed by direct call of `.hide()`).
+     * @type {?}
+     */
+    ModalDirective.prototype.dismissReason;
+    /** @type {?} */
+    ModalDirective.prototype._config;
+    /** @type {?} */
+    ModalDirective.prototype._isShown;
+    /** @type {?} */
+    ModalDirective.prototype.isBodyOverflowing;
+    /** @type {?} */
+    ModalDirective.prototype.originalBodyPadding;
+    /** @type {?} */
+    ModalDirective.prototype.scrollbarWidth;
+    /** @type {?} */
+    ModalDirective.prototype.timerHideModal;
+    /** @type {?} */
+    ModalDirective.prototype.timerRmBackDrop;
+    /** @type {?} */
+    ModalDirective.prototype.backdrop;
+    /** @type {?} */
+    ModalDirective.prototype._backdrop;
+    /** @type {?} */
+    ModalDirective.prototype.isNested;
+    /** @type {?} */
+    ModalDirective.prototype._element;
+    /** @type {?} */
+    ModalDirective.prototype._renderer;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.directive.js","sourceRoot":"ng://ngx-bootstrap/modal/","sources":["modal.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* 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"]}

package/modal/esm2015/modal.module.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { NgModule } from '@angular/core';
+import { ModalBackdropComponent } from './modal-backdrop.component';
+import { ModalDirective } from './modal.directive';
+import { PositioningService } from 'ngx-bootstrap/positioning';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { ModalContainerComponent } from './modal-container.component';
+import { BsModalService } from './bs-modal.service';
+export class ModalModule {
+    /**
+     * @return {?}
+     */
+    static forRoot() {
+        return {
+            ngModule: ModalModule,
+            providers: [BsModalService, ComponentLoaderFactory, PositioningService]
+        };
+    }
+}
+ModalModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    ModalBackdropComponent,
+                    ModalDirective,
+                    ModalContainerComponent
+                ],
+                exports: [ModalBackdropComponent, ModalDirective],
+                entryComponents: [ModalBackdropComponent, ModalContainerComponent]
+            },] }
+];
+function ModalModule_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    ModalModule.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    ModalModule.ctorParameters;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/modal/esm2015/models/index.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @record
+ */
+export function ClassName() { }
+function ClassName_tsickle_Closure_declarations() {
+    /** @type {?} */
+    ClassName.prototype.SCROLLBAR_MEASURER;
+    /** @type {?} */
+    ClassName.prototype.BACKDROP;
+    /** @type {?} */
+    ClassName.prototype.OPEN;
+    /** @type {?} */
+    ClassName.prototype.FADE;
+    /** @type {?} */
+    ClassName.prototype.IN;
+    /** @type {?} */
+    ClassName.prototype.SHOW;
+}
+/**
+ * @record
+ */
+export function Selector() { }
+function Selector_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Selector.prototype.DIALOG;
+    /** @type {?} */
+    Selector.prototype.DATA_TOGGLE;
+    /** @type {?} */
+    Selector.prototype.DATA_DISMISS;
+    /** @type {?} */
+    Selector.prototype.FIXED_CONTENT;
+}
+/**
+ * @record
+ */
+export function TransitionDurations() { }
+function TransitionDurations_tsickle_Closure_declarations() {
+    /** @type {?} */
+    TransitionDurations.prototype.MODAL;
+    /** @type {?} */
+    TransitionDurations.prototype.BACKDROP;
+}
+/**
+ * @record
+ */
+export function DismissReasons() { }
+function DismissReasons_tsickle_Closure_declarations() {
+    /** @type {?} */
+    DismissReasons.prototype.BACKRDOP;
+    /** @type {?} */
+    DismissReasons.prototype.ESC;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL21vZGFsLyIsInNvdXJjZXMiOlsibW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENsYXNzTmFtZSB7XG4gIFNDUk9MTEJBUl9NRUFTVVJFUjogc3RyaW5nO1xuICBCQUNLRFJPUDogc3RyaW5nO1xuICBPUEVOOiBzdHJpbmc7XG4gIEZBREU6IHN0cmluZztcbiAgSU46IHN0cmluZztcbiAgU0hPVzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNlbGVjdG9yIHtcbiAgRElBTE9HOiBzdHJpbmc7XG4gIERBVEFfVE9HR0xFOiBzdHJpbmc7XG4gIERBVEFfRElTTUlTUzogc3RyaW5nO1xuICBGSVhFRF9DT05URU5UOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHJhbnNpdGlvbkR1cmF0aW9ucyB7XG4gIE1PREFMOiBudW1iZXI7XG4gIEJBQ0tEUk9QOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGlzbWlzc1JlYXNvbnMge1xuICBCQUNLUkRPUDogc3RyaW5nO1xuICBFU0M6IHN0cmluZztcbn1cbiJdfQ==

package/modal/esm2015/ngx-bootstrap-modal.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { BsModalRef, ModalBackdropOptions, ModalContainerComponent, ModalBackdropComponent, ModalOptions, ModalDirective, ModalModule, BsModalService } from './public_api';
+export { CLASS_NAME as ɵa } from './modal-options.class';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWJvb3RzdHJhcC1tb2RhbC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvbW9kYWwvIiwic291cmNlcyI6WyJuZ3gtYm9vdHN0cmFwLW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSw2SkFBYyxjQUFjLENBQUM7QUFFN0IsT0FBTyxFQUFDLFVBQVUsSUFBSSxFQUFFLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcblxuZXhwb3J0IHtDTEFTU19OQU1FIGFzIMm1YX0gZnJvbSAnLi9tb2RhbC1vcHRpb25zLmNsYXNzJzsiXX0=

package/modal/esm2015/public_api.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { BsModalRef } from './bs-modal-ref.service';
+export { ModalBackdropOptions } from './modal-backdrop.options';
+export { ModalContainerComponent } from './modal-container.component';
+export { ModalBackdropComponent } from './modal-backdrop.component';
+export { ModalOptions } from './modal-options.class';
+export { ModalDirective } from './modal.directive';
+export { ModalModule } from './modal.module';
+export { BsModalService } from './bs-modal.service';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvbW9kYWwvIiwic291cmNlcyI6WyJwdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDcEQsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDaEUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDcEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3JELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQnNNb2RhbFJlZiB9IGZyb20gJy4vYnMtbW9kYWwtcmVmLnNlcnZpY2UnO1xuZXhwb3J0IHsgTW9kYWxCYWNrZHJvcE9wdGlvbnMgfSBmcm9tICcuL21vZGFsLWJhY2tkcm9wLm9wdGlvbnMnO1xuZXhwb3J0IHsgTW9kYWxDb250YWluZXJDb21wb25lbnQgfSBmcm9tICcuL21vZGFsLWNvbnRhaW5lci5jb21wb25lbnQnO1xuZXhwb3J0IHsgTW9kYWxCYWNrZHJvcENvbXBvbmVudCB9IGZyb20gJy4vbW9kYWwtYmFja2Ryb3AuY29tcG9uZW50JztcbmV4cG9ydCB7IE1vZGFsT3B0aW9ucyB9IGZyb20gJy4vbW9kYWwtb3B0aW9ucy5jbGFzcyc7XG5leHBvcnQgeyBNb2RhbERpcmVjdGl2ZSB9IGZyb20gJy4vbW9kYWwuZGlyZWN0aXZlJztcbmV4cG9ydCB7IE1vZGFsTW9kdWxlIH0gZnJvbSAnLi9tb2RhbC5tb2R1bGUnO1xuZXhwb3J0IHsgQnNNb2RhbFNlcnZpY2UgfSBmcm9tICcuL2JzLW1vZGFsLnNlcnZpY2UnO1xuIl19