ngx-bootstrap 10.2.1 → 11.0.0

package/modal/esm2022/bs-modal.service.mjs

@@ -0,0 +1,225 @@
+import { Injectable, EventEmitter, RendererFactory2, Inject, Optional } from '@angular/core';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { ModalBackdropComponent } from './modal-backdrop.component';
+import { ModalContainerComponent } from './modal-container.component';
+import { CLASS_NAME, modalConfigDefaults, ModalOptions, TRANSITION_DURATIONS, MODAL_CONFIG_DEFAULT_OVERRIDE } from './modal-options.class';
+import { BsModalRef } from './bs-modal-ref.service';
+import { document } from 'ngx-bootstrap/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-bootstrap/component-loader";
+import * as i2 from "./modal-options.class";
+let currentId = 1;
+export class BsModalService {
+    constructor(rendererFactory, clf, modalDefaultOption) {
+        this.clf = clf;
+        this.modalDefaultOption = modalDefaultOption;
+        this.onShow = new EventEmitter();
+        this.onShown = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.onHidden = new EventEmitter();
+        this.isBodyOverflowing = false;
+        this.originalBodyPadding = 0;
+        this.scrollbarWidth = 0;
+        this.modalsCount = 0;
+        this.loaders = [];
+        this._focusEl = null;
+        this._backdropLoader = this.clf.createLoader();
+        this._renderer = rendererFactory.createRenderer(null, null);
+        this.config = modalDefaultOption ?
+            (Object.assign({}, modalConfigDefaults, modalDefaultOption)) :
+            modalConfigDefaults;
+    }
+    /** Shows a modal */
+    show(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content, config) {
+        this._focusEl = document.activeElement;
+        this.modalsCount++;
+        this._createLoaders();
+        // must be different per every show() call
+        const id = config?.id || currentId++;
+        this.config = this.modalDefaultOption ?
+            Object.assign({}, modalConfigDefaults, this.modalDefaultOption, config) :
+            Object.assign({}, modalConfigDefaults, config);
+        this.config.id = id;
+        this._showBackdrop();
+        this.lastDismissReason = void 0;
+        return this._showModal(content);
+    }
+    hide(id) {
+        if (this.modalsCount === 1 || id == null) {
+            this._hideBackdrop();
+            this.resetScrollbar();
+        }
+        this.modalsCount = this.modalsCount >= 1 && id != null ? this.modalsCount - 1 : 0;
+        setTimeout(() => {
+            this._hideModal(id);
+            this.removeLoaders(id);
+        }, this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0);
+        if (this._focusEl) {
+            this._focusEl.focus();
+        }
+    }
+    _showBackdrop() {
+        const isBackdropEnabled = this.config.backdrop === true || this.config.backdrop === 'static';
+        const 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;
+            }
+        }
+    }
+    _hideBackdrop() {
+        if (!this.backdropRef) {
+            return;
+        }
+        this.backdropRef.instance.isShown = false;
+        const duration = this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0;
+        setTimeout(() => this.removeBackdrop(), duration);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _showModal(content) {
+        const modalLoader = this.loaders[this.loaders.length - 1];
+        if (this.config && this.config.providers) {
+            for (const provider of this.config.providers) {
+                modalLoader.provide(provider);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bsModalRef = new BsModalRef();
+        const modalContainerRef = modalLoader
+            .provide({ provide: ModalOptions, useValue: this.config })
+            .provide({ provide: BsModalRef, useValue: bsModalRef })
+            .attach(ModalContainerComponent)
+            .to('body');
+        bsModalRef.hide = () => this.hide(bsModalRef.id);
+        bsModalRef.setClass = (newClass) => {
+            if (modalContainerRef.instance) {
+                modalContainerRef.instance.config.class = newClass;
+            }
+        };
+        bsModalRef.onHidden = new EventEmitter();
+        bsModalRef.onHide = new EventEmitter();
+        this.copyEvent(modalLoader.onBeforeHide, bsModalRef.onHide);
+        this.copyEvent(modalLoader.onHidden, bsModalRef.onHidden);
+        // call 'show' method after assign setClass in bsModalRef.
+        // it makes modal component's bsModalRef available to call setClass method
+        modalContainerRef.show({
+            content,
+            isAnimated: this.config.animated,
+            initialState: this.config.initialState,
+            bsModalService: this,
+            id: this.config.id
+        });
+        if (modalContainerRef.instance) {
+            modalContainerRef.instance.level = this.getModalsCount();
+            bsModalRef.content = modalLoader.getInnerComponent();
+            bsModalRef.id = modalContainerRef.instance.config?.id;
+        }
+        return bsModalRef;
+    }
+    _hideModal(id) {
+        if (id != null) {
+            const indexToRemove = this.loaders.findIndex(loader => loader.instance?.config.id === id);
+            const modalLoader = this.loaders[indexToRemove];
+            if (modalLoader) {
+                modalLoader.hide(id);
+            }
+        }
+        else {
+            this.loaders.forEach((loader) => {
+                if (loader.instance) {
+                    loader.hide(loader.instance.config.id);
+                }
+            });
+        }
+    }
+    getModalsCount() {
+        return this.modalsCount;
+    }
+    setDismissReason(reason) {
+        this.lastDismissReason = reason;
+    }
+    removeBackdrop() {
+        this._renderer.removeClass(document.body, CLASS_NAME.OPEN);
+        this._renderer.setStyle(document.body, 'overflow-y', '');
+        this._backdropLoader.hide();
+        this.backdropRef = void 0;
+    }
+    /** Checks if the body is overflowing and sets scrollbar width */
+    /** @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;
+    }
+    _createLoaders() {
+        const loader = this.clf.createLoader();
+        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);
+    }
+    removeLoaders(id) {
+        if (id != null) {
+            const indexToRemove = this.loaders.findIndex(loader => loader.instance?.config.id === id);
+            if (indexToRemove >= 0) {
+                this.loaders.splice(indexToRemove, 1);
+                this.loaders.forEach((loader, i) => {
+                    if (loader.instance) {
+                        loader.instance.level = i + 1;
+                    }
+                });
+            }
+        }
+        else {
+            this.loaders.splice(0, this.loaders.length);
+        }
+    }
+    copyEvent(from, to) {
+        from.subscribe((data) => {
+            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' }); }
+}
+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: i2.ModalOptions, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MODAL_CONFIG_DEFAULT_OVERRIDE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-modal.service.js","sourceRoot":"","sources":["../../../../src/modal/bs-modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentRef,\n  Injectable,\n  TemplateRef,\n  EventEmitter,\n  Renderer2,\n  RendererFactory2,\n  Inject,\n  Optional\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  MODAL_CONFIG_DEFAULT_OVERRIDE\n} from './modal-options.class';\nimport { BsModalRef } from './bs-modal-ref.service';\nimport { document } from 'ngx-bootstrap/utils';\n\nlet currentId = 1;\n\n@Injectable({providedIn: 'platform'})\nexport class BsModalService {\n  // constructor props\n  config: ModalOptions;\n\n  onShow = new EventEmitter();\n  onShown = new EventEmitter();\n  onHide = new EventEmitter();\n  onHidden = 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?: string;\n\n  private loaders: ComponentLoader<ModalContainerComponent>[] = [];\n\n  private _renderer: Renderer2;\n  private _focusEl: Element | null = null;\n\n  constructor(\n    rendererFactory: RendererFactory2,\n    private clf: ComponentLoaderFactory,\n    @Optional() @Inject(MODAL_CONFIG_DEFAULT_OVERRIDE) private modalDefaultOption: ModalOptions) {\n    this._backdropLoader = this.clf.createLoader<ModalBackdropComponent>();\n    this._renderer = rendererFactory.createRenderer(null, null);\n    this.config = modalDefaultOption ?\n      (Object.assign({}, modalConfigDefaults, modalDefaultOption)) :\n      modalConfigDefaults;\n  }\n\n  /** Shows a modal */\n  show<T>(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    content: string | TemplateRef<any> | { new(...args: any[]): T },\n    config?: ModalOptions<T>\n  ): BsModalRef<T> {\n    this._focusEl = document.activeElement;\n    this.modalsCount++;\n    this._createLoaders();\n\n    // must be different per every show() call\n    const id = config?.id || currentId++;\n    this.config = this.modalDefaultOption ?\n      Object.assign({}, modalConfigDefaults, this.modalDefaultOption, config) :\n      Object.assign({}, modalConfigDefaults, config);\n    this.config.id = id;\n    this._showBackdrop();\n    this.lastDismissReason = void 0;\n\n    return this._showModal<T>(content);\n  }\n\n  hide(id?: number | string) {\n    if (this.modalsCount === 1 || id == null) {\n      this._hideBackdrop();\n      this.resetScrollbar();\n    }\n    this.modalsCount = this.modalsCount >= 1 && id != null ? this.modalsCount - 1 : 0;\n    setTimeout(() => {\n      this._hideModal(id);\n      this.removeLoaders(id);\n    }, this.config.animated ? TRANSITION_DURATIONS.BACKDROP : 0);\n\n    if (this._focusEl) {\n      (this._focusEl as HTMLElement).focus();\n    }\n  }\n\n  _showBackdrop(): void {\n    const isBackdropEnabled =\n      this.config.backdrop === true || 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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  _showModal<T>(content: any): BsModalRef<T> {\n    const modalLoader = this.loaders[this.loaders.length - 1];\n    if (this.config && this.config.providers) {\n      for (const provider of this.config.providers) {\n        modalLoader.provide(provider);\n      }\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const bsModalRef = new BsModalRef<any>();\n    const modalContainerRef = modalLoader\n      .provide({ provide: ModalOptions, useValue: this.config })\n      .provide({ provide: BsModalRef, useValue: bsModalRef })\n      .attach(ModalContainerComponent)\n      .to('body');\n    bsModalRef.hide = () => this.hide(bsModalRef.id);\n    bsModalRef.setClass = (newClass: string) => {\n      if (modalContainerRef.instance) {\n        modalContainerRef.instance.config.class = newClass;\n      }\n    };\n\n    bsModalRef.onHidden = new EventEmitter<unknown>();\n    bsModalRef.onHide = new EventEmitter<unknown>();\n\n    this.copyEvent(modalLoader.onBeforeHide, bsModalRef.onHide);\n    this.copyEvent(modalLoader.onHidden, bsModalRef.onHidden);\n    // call 'show' method after assign setClass in bsModalRef.\n    // it makes modal component's bsModalRef available to call setClass method\n    modalContainerRef.show({\n      content,\n      isAnimated: this.config.animated,\n      initialState: this.config.initialState,\n      bsModalService: this,\n      id: this.config.id\n    });\n\n    if (modalContainerRef.instance) {\n      modalContainerRef.instance.level = this.getModalsCount();\n      bsModalRef.content = modalLoader.getInnerComponent();\n      bsModalRef.id = modalContainerRef.instance.config?.id;\n    }\n\n    return bsModalRef;\n  }\n\n  _hideModal(id?: number | string): void {\n    if (id != null) {\n      const indexToRemove = this.loaders.findIndex(loader => loader.instance?.config.id === id);\n      const modalLoader = this.loaders[indexToRemove];\n      if (modalLoader) {\n        modalLoader.hide(id);\n      }\n    } else {\n      this.loaders.forEach(\n        (loader: ComponentLoader<ModalContainerComponent>) => {\n          if (loader.instance) {\n            loader.hide(loader.instance.config.id);\n          }\n        }\n      );\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._renderer.removeClass(document.body, CLASS_NAME.OPEN);\n    this._renderer.setStyle(document.body, 'overflow-y', '');\n    this._backdropLoader.hide();\n    this.backdropRef = void 0;\n  }\n\n  /** Checks if the body is overflowing and sets scrollbar width */\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    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(id?: number | string): void {\n    if (id != null) {\n      const indexToRemove = this.loaders.findIndex(loader => loader.instance?.config.id === id);\n      if (indexToRemove >= 0) {\n        this.loaders.splice(indexToRemove, 1);\n        this.loaders.forEach(\n          (loader: ComponentLoader<ModalContainerComponent>, i: number) => {\n            if (loader.instance) {\n              loader.instance.level = i + 1;\n            }\n          }\n        );\n      }\n    } else {\n      this.loaders.splice(0, this.loaders.length);\n    }\n  }\n\n  private copyEvent(from: EventEmitter<unknown>, to: EventEmitter<unknown>) {\n    from.subscribe((data) => {\n      to.emit(this.lastDismissReason || data);\n    });\n  }\n}\n"]}

package/modal/esm2022/modal-backdrop.component.mjs

@@ -0,0 +1,50 @@
+import { Component, ElementRef, Renderer2 } from '@angular/core';
+import { CLASS_NAME } from './modal-options.class';
+import { Utils } from 'ngx-bootstrap/utils';
+import * as i0 from "@angular/core";
+/** This component will be added as background layout for modals if enabled */
+export class ModalBackdropComponent {
+    get isAnimated() {
+        return this._isAnimated;
+    }
+    set isAnimated(value) {
+        this._isAnimated = value;
+    }
+    get isShown() {
+        return this._isShown;
+    }
+    set isShown(value) {
+        this._isShown = value;
+        if (value) {
+            this.renderer.addClass(this.element.nativeElement, `${CLASS_NAME.SHOW}`);
+        }
+        else {
+            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}`);
+            Utils.reflow(this.element.nativeElement);
+        }
+        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 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalBackdropComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bs-modal-backdrop',
+                    template: ' ',
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: { class: CLASS_NAME.BACKDROP }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtYmFja2Ryb3AuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21vZGFsL21vZGFsLWJhY2tkcm9wLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBVSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFHNUMsOEVBQThFO0FBTzlFLE1BQU0sT0FBTyxzQkFBc0I7SUFDakMsSUFBSSxVQUFVO1FBQ1osT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUFJLFVBQVUsQ0FBQyxLQUFjO1FBQzNCLElBQUksQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFDO0lBQzNCLENBQUM7SUFFRCxJQUFJLE9BQU87UUFDVCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUM7SUFDdkIsQ0FBQztJQUVELElBQUksT0FBTyxDQUFDLEtBQWM7UUFDeEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUM7UUFDdEIsSUFBSSxLQUFLLEVBQUU7WUFDVCxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FDcEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLEVBQzFCLEdBQUcsVUFBVSxDQUFDLElBQUksRUFBRSxDQUNyQixDQUFDO1NBQ0g7YUFBTTtZQUNMLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxDQUN2QixJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFDMUIsR0FBRyxVQUFVLENBQUMsSUFBSSxFQUFFLENBQ3JCLENBQUM7U0FDSDtJQUNILENBQUM7SUFRRCxZQUFZLE9BQW1CLEVBQUUsUUFBbUI7UUFIMUMsZ0JBQVcsR0FBRyxLQUFLLENBQUM7UUFDcEIsYUFBUSxHQUFHLEtBQUssQ0FBQztRQUd6QixJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUN2QixJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztJQUMzQixDQUFDO0lBRUQsUUFBUTtRQUNOLElBQUksSUFBSSxDQUFDLFVBQVUsRUFBRTtZQUNuQixJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FDcEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLEVBQzFCLEdBQUcsVUFBVSxDQUFDLElBQUksRUFBRSxDQUNyQixDQUFDO1lBQ0YsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1NBQzFDO1FBQ0QsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7SUFDdEIsQ0FBQzs4R0FoRFUsc0JBQXNCO2tHQUF0QixzQkFBc0IscUdBSnZCLEdBQUc7OzJGQUlGLHNCQUFzQjtrQkFObEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsbUJBQW1CO29CQUM3QixRQUFRLEVBQUUsR0FBRztvQkFDYixxRUFBcUU7b0JBQ3JFLElBQUksRUFBRSxFQUFFLEtBQUssRUFBRSxVQUFVLENBQUMsUUFBUSxFQUFFO2lCQUNyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgRWxlbWVudFJlZiwgT25Jbml0LCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQ0xBU1NfTkFNRSB9IGZyb20gJy4vbW9kYWwtb3B0aW9ucy5jbGFzcyc7XG5pbXBvcnQgeyBVdGlscyB9IGZyb20gJ25neC1ib290c3RyYXAvdXRpbHMnO1xuXG5cbi8qKiBUaGlzIGNvbXBvbmVudCB3aWxsIGJlIGFkZGVkIGFzIGJhY2tncm91bmQgbGF5b3V0IGZvciBtb2RhbHMgaWYgZW5hYmxlZCAqL1xuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYnMtbW9kYWwtYmFja2Ryb3AnLFxuICB0ZW1wbGF0ZTogJyAnLFxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQGFuZ3VsYXItZXNsaW50L25vLWhvc3QtbWV0YWRhdGEtcHJvcGVydHlcbiAgaG9zdDogeyBjbGFzczogQ0xBU1NfTkFNRS5CQUNLRFJPUCB9XG59KVxuZXhwb3J0IGNsYXNzIE1vZGFsQmFja2Ryb3BDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICBnZXQgaXNBbmltYXRlZCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5faXNBbmltYXRlZDtcbiAgfVxuXG4gIHNldCBpc0FuaW1hdGVkKHZhbHVlOiBib29sZWFuKSB7XG4gICAgdGhpcy5faXNBbmltYXRlZCA9IHZhbHVlO1xuICB9XG5cbiAgZ2V0IGlzU2hvd24oKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuX2lzU2hvd247XG4gIH1cblxuICBzZXQgaXNTaG93bih2YWx1ZTogYm9vbGVhbikge1xuICAgIHRoaXMuX2lzU2hvd24gPSB2YWx1ZTtcbiAgICBpZiAodmFsdWUpIHtcbiAgICAgIHRoaXMucmVuZGVyZXIuYWRkQ2xhc3MoXG4gICAgICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LFxuICAgICAgICBgJHtDTEFTU19OQU1FLlNIT1d9YFxuICAgICAgKTtcbiAgICB9IGVsc2Uge1xuICAgICAgdGhpcy5yZW5kZXJlci5yZW1vdmVDbGFzcyhcbiAgICAgICAgdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQsXG4gICAgICAgIGAke0NMQVNTX05BTUUuU0hPV31gXG4gICAgICApO1xuICAgIH1cbiAgfVxuXG4gIGVsZW1lbnQ6IEVsZW1lbnRSZWY7XG4gIHJlbmRlcmVyOiBSZW5kZXJlcjI7XG5cbiAgcHJvdGVjdGVkIF9pc0FuaW1hdGVkID0gZmFsc2U7XG4gIHByb3RlY3RlZCBfaXNTaG93biA9IGZhbHNlO1xuXG4gIGNvbnN0cnVjdG9yKGVsZW1lbnQ6IEVsZW1lbnRSZWYsIHJlbmRlcmVyOiBSZW5kZXJlcjIpIHtcbiAgICB0aGlzLmVsZW1lbnQgPSBlbGVtZW50O1xuICAgIHRoaXMucmVuZGVyZXIgPSByZW5kZXJlcjtcbiAgfVxuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIGlmICh0aGlzLmlzQW5pbWF0ZWQpIHtcbiAgICAgIHRoaXMucmVuZGVyZXIuYWRkQ2xhc3MoXG4gICAgICAgIHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LFxuICAgICAgICBgJHtDTEFTU19OQU1FLkZBREV9YFxuICAgICAgKTtcbiAgICAgIFV0aWxzLnJlZmxvdyh0aGlzLmVsZW1lbnQubmF0aXZlRWxlbWVudCk7XG4gICAgfVxuICAgIHRoaXMuaXNTaG93biA9IHRydWU7XG4gIH1cbn1cbiJdfQ==

package/modal/esm2022/modal-container.component.mjs

@@ -0,0 +1,151 @@
+import { Component, ElementRef, HostListener, Renderer2 } from '@angular/core';
+import { CLASS_NAME, DISMISS_REASONS, ModalOptions, TRANSITION_DURATIONS } from './modal-options.class';
+import { document } from 'ngx-bootstrap/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-options.class";
+import * as i2 from "ngx-bootstrap/focus-trap";
+export class ModalContainerComponent {
+    constructor(options, _element, _renderer) {
+        this._element = _element;
+        this._renderer = _renderer;
+        this.isShown = false;
+        this.isAnimated = false;
+        this._focusEl = null;
+        this.isModalHiding = false;
+        this.clickStartedInContent = false;
+        this.config = Object.assign({}, options);
+    }
+    ngOnInit() {
+        this._focusEl = document.activeElement;
+        if (this.isAnimated) {
+            this._renderer.addClass(this._element.nativeElement, CLASS_NAME.FADE);
+        }
+        this._renderer.setStyle(this._element.nativeElement, 'display', 'block');
+        setTimeout(() => {
+            this.isShown = true;
+            this._renderer.addClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        }, this.isAnimated ? TRANSITION_DURATIONS.BACKDROP : 0);
+        if (document && document.body) {
+            if (this.bsModalService && this.bsModalService.getModalsCount() === 1) {
+                this.bsModalService.checkScrollbar();
+                this.bsModalService.setScrollbar();
+            }
+            this._renderer.addClass(document.body, CLASS_NAME.OPEN);
+            this._renderer.setStyle(document.body, 'overflow-y', 'hidden');
+        }
+        if (this._element.nativeElement) {
+            this._element.nativeElement.focus();
+        }
+    }
+    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.bsModalService?.setDismissReason(DISMISS_REASONS.BACKRDOP);
+        this.hide();
+    }
+    onPopState() {
+        this.bsModalService?.setDismissReason(DISMISS_REASONS.BACK);
+        this.hide();
+    }
+    onEsc(event) {
+        if (!this.isShown) {
+            return;
+        }
+        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();
+        }
+    }
+    ngOnDestroy() {
+        if (this.isShown) {
+            this._hide();
+        }
+    }
+    hide() {
+        if (this.isModalHiding) {
+            return;
+        }
+        if (this.config.closeInterceptor) {
+            this.config.closeInterceptor().then(() => this._hide(), () => undefined);
+            return;
+        }
+        this._hide();
+    }
+    _hide() {
+        this.isModalHiding = true;
+        this._renderer.removeClass(this._element.nativeElement, CLASS_NAME.SHOW);
+        setTimeout(() => {
+            this.isShown = false;
+            if (document &&
+                document.body &&
+                this.bsModalService?.getModalsCount() === 1) {
+                this._renderer.removeClass(document.body, CLASS_NAME.OPEN);
+                this._renderer.setStyle(document.body, 'overflow-y', '');
+            }
+            this.bsModalService?.hide(this.config.id);
+            this.isModalHiding = false;
+            if (this._focusEl) {
+                this._focusEl.focus();
+            }
+        }, this.isAnimated ? TRANSITION_DURATIONS.MODAL : 0);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.4", ngImport: i0, type: ModalContainerComponent, deps: [{ token: i1.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>
+      <div class="modal-content">
+        <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: "16.1.4", ngImport: i0, type: ModalContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'modal-container',
+                    template: `
+    <div [class]="'modal-dialog' + (config.class ? ' ' + config.class : '')"
+         role="document"
+         focusTrap>
+      <div class="modal-content">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `,
+                    // eslint-disable-next-line @angular-eslint/no-host-metadata-property
+                    host: {
+                        class: 'modal',
+                        role: 'dialog',
+                        tabindex: '-1',
+                        '[attr.aria-modal]': 'true',
+                        '[attr.aria-labelledby]': 'config.ariaLabelledBy',
+                        '[attr.aria-describedby]': 'config.ariaDescribedby'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ModalOptions }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { onClickStarted: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], onClickStop: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], onPopState: [{
+                type: HostListener,
+                args: ['window:popstate']
+            }], onEsc: [{
+                type: HostListener,
+                args: ['window:keydown.esc', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-container.component.js","sourceRoot":"","sources":["../../../../src/modal/modal-container.component.ts"],"names":[],"mappings":"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","sourcesContent":["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 { document } from 'ngx-bootstrap/utils';\n\n@Component({\n  selector: 'modal-container',\n  template: `\n    <div [class]=\"'modal-dialog' + (config.class ? ' ' + config.class : '')\"\n         role=\"document\"\n         focusTrap>\n      <div class=\"modal-content\">\n        <ng-content></ng-content>\n      </div>\n    </div>\n  `,\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    class: 'modal',\n    role: 'dialog',\n    tabindex: '-1',\n    '[attr.aria-modal]': 'true',\n    '[attr.aria-labelledby]': 'config.ariaLabelledBy',\n    '[attr.aria-describedby]': 'config.ariaDescribedby'\n  }\n})\nexport class ModalContainerComponent implements OnInit, OnDestroy {\n  config: ModalOptions;\n  isShown = false;\n  level?: number;\n  isAnimated = false;\n  bsModalService?: BsModalService;\n  _focusEl: Element | null = null;\n  private isModalHiding = false;\n  private clickStartedInContent = 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    this._focusEl = document.activeElement;\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        CLASS_NAME.SHOW\n      );\n    }, this.isAnimated ? TRANSITION_DURATIONS.BACKDROP : 0);\n    if (document && document.body) {\n      if (this.bsModalService && this.bsModalService.getModalsCount() === 1) {\n        this.bsModalService.checkScrollbar();\n        this.bsModalService.setScrollbar();\n      }\n      this._renderer.addClass(document.body, CLASS_NAME.OPEN);\n      this._renderer.setStyle(document.body, 'overflow-y', 'hidden');\n    }\n    if (this._element.nativeElement) {\n      this._element.nativeElement.focus();\n    }\n  }\n\n  @HostListener('mousedown', ['$event'])\n  onClickStarted(event: MouseEvent): void {\n    this.clickStartedInContent = event.target !== this._element.nativeElement;\n  }\n\n  @HostListener('click', ['$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.bsModalService?.setDismissReason(DISMISS_REASONS.BACKRDOP);\n    this.hide();\n  }\n\n  @HostListener('window:popstate')\n  onPopState(): void {\n    this.bsModalService?.setDismissReason(DISMISS_REASONS.BACK);\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    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) {\n      return;\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 _hide(): void {\n    this.isModalHiding = true;\n    this._renderer.removeClass(\n      this._element.nativeElement,\n      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        this._renderer.setStyle(document.body, 'overflow-y', '');\n      }\n      this.bsModalService?.hide(this.config.id);\n      this.isModalHiding = false;\n      if (this._focusEl) {\n        (this._focusEl as HTMLElement).focus();\n      }\n    }, this.isAnimated ? TRANSITION_DURATIONS.MODAL : 0);\n  }\n}\n"]}

package/modal/{esm2020 → esm2022}/modal-options.class.mjs

@@ -1,10 +1,10 @@
 import { Injectable, InjectionToken } from '@angular/core';
 import * as i0 from "@angular/core";
 export 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' }]
         }] });
@@ -43,4 +43,4 @@ export const DISMISS_REASONS = {
     ESC: 'esc',
     BACK: 'browser-back-navigation-clicked'
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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