@indice/ng-components 0.2.110 → 0.2.113

package/esm2020/lib/services/component-loader/component-loader.class.mjs

@@ -0,0 +1,188 @@
+import { ElementRef, TemplateRef, Injector, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ContentRef } from './content-ref.class';
+/**
+ * Provides ways of loading and handling dynamic content.
+ *
+ * @remarks
+ * Do NOT use this directly, create an instance through {@link ComponentLoaderFactory}
+ * You can use this loader in two ways:
+ * - Attaches a component to `ViewContainerRef`.
+ * - Attaches a component to `ViewContainerRef`. The attached component has a `<ng-content>` tag inside its view. The {@link ComponentLoaderOptions.content} will be drawn inside this tag.
+ *
+ * @internal
+ */
+export class ComponentLoader {
+    constructor(vcr, cfr, applicationRef, injector) {
+        this.vcr = vcr;
+        this.cfr = cfr;
+        this.applicationRef = applicationRef;
+        this.injector = injector;
+        /**
+         * Before content is shown event.
+         */
+        this.onBeforeShow = new Subject();
+        /**
+         * After show content event.
+         * @returns The id of newly created component ref.
+         */
+        this.onShown = new Subject();
+        /**
+         * Before content is hidden event.
+         * @returns The instance of attached component;
+         */
+        this.onBeforeHide = new Subject();
+        /**
+         * After content is hidden event.
+         * @returns The id of destroyed component ref.
+         */
+        this.onHidden = new Subject();
+        this.providers = [];
+        this.containerDefaultSelector = 'body';
+    }
+    /**
+     * Attaches component.
+     * @param componentType - The type component to attach.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    attach(componentType) {
+        this.componentFactory = this.cfr.resolveComponentFactory(componentType);
+        return this;
+    }
+    /**
+     * Body will be used in nothing is provided.
+     * @param container - The element in which dynamic content will be drawn inside to. For string case a query to the dom will be executed to find the element.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    to(container) {
+        this.container = container || this.container;
+        return this;
+    }
+    /**
+     * Adds provider to the providers array. These providers will be injected to the attached component.
+     *
+     * @see {@link https://angular.io/guide/glossary#di-token | Injection Token}
+     *
+     * @param provider - Provider to inject.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    provide(provider) {
+        this.providers.push(provider);
+        return this;
+    }
+    /**
+     * Attaches attached component to dom and any dynamic content if provided.
+     * @remarks
+     * Also triggers the {@link ComponentLoader.onBeforeShow} and {@link ComponentLoader.onShown} events.
+     *
+     * @param options - {@link ComponentLoaderOptions}.
+     * @returns A reference to the created content.
+     */
+    show(options = {}) {
+        if (this.componentRef) {
+            throw Error('Component is already shown');
+        }
+        if (!this.componentFactory) {
+            throw Error('You must attach a component');
+        }
+        this.onBeforeShow.next();
+        if (options.content) {
+            this.contentRef = this.getContentRef(options.content, options.context, options.initialState);
+        }
+        this.createComponentAndAttachToView(options);
+        this.appendContentToContainer();
+        this.markComponentsForCheck();
+        this.onShown.next(options.id);
+        return this.componentRef;
+    }
+    /**
+     * Removes attached component from dom.
+     * @remarks
+     * Also triggers the {@link ComponentLoader.onBeforeHide} and {@link ComponentLoader.onHidden} events.
+     *
+     * @param id - If provided it is returned through the {@link ComponentLoader.onHidden}.
+     * @returns Current instance of {@link ComponentLoader}
+     */
+    hide(id, result) {
+        if (!this.componentRef) {
+            throw Error('No attached component found to hide');
+        }
+        this.onBeforeHide.next(this.componentRef.instance);
+        const componentEl = this.componentRef.location.nativeElement;
+        componentEl.parentNode.removeChild(componentEl);
+        if (this.contentRef?.componentRef) {
+            this.contentRef.componentRef.destroy();
+        }
+        if (this.vcr && this.contentRef?.viewRef) {
+            this.vcr.remove(this.vcr.indexOf(this.contentRef.viewRef));
+        }
+        if (this.contentRef?.viewRef) {
+            this.contentRef.viewRef.destroy();
+        }
+        this.contentRef = void 0;
+        this.componentRef = void 0;
+        this.onHidden.next(id ? { id, result } : null);
+        return this;
+    }
+    getInnerComponent() {
+        return this.innerComponent;
+    }
+    markComponentsForCheck() {
+        if (this.contentRef?.componentRef) {
+            this.innerComponent = this.contentRef.componentRef.instance;
+            this.contentRef.componentRef.changeDetectorRef.markForCheck();
+            this.contentRef.componentRef.changeDetectorRef.detectChanges();
+        }
+        this.componentRef.changeDetectorRef.markForCheck();
+        this.componentRef.changeDetectorRef.detectChanges();
+    }
+    createComponentAndAttachToView(options) {
+        const injector = Injector.create({
+            providers: this.providers,
+            parent: this.injector,
+        });
+        this.componentRef = this.componentFactory.create(injector, this.contentRef?.nodes);
+        this.applicationRef.attachView(this.componentRef.hostView);
+        this.instance = this.componentRef.instance;
+        Object.assign(this.componentRef.instance, options);
+    }
+    appendContentToContainer() {
+        if (this.container instanceof ElementRef) {
+            this.container.nativeElement.appendChild(this.componentRef?.location.nativeElement);
+        }
+        if (typeof this.container === 'string' && typeof document !== 'undefined') {
+            const selectedElement = document.querySelector(this.container) || document.querySelector(this.containerDefaultSelector);
+            if (!selectedElement) {
+                return;
+            }
+            selectedElement.appendChild(this.componentRef?.location.nativeElement);
+        }
+    }
+    getContentRef(content, context, initialState) {
+        //TemplateRef case
+        if (content instanceof TemplateRef) {
+            if (this.vcr) {
+                const viewRef = this.vcr.createEmbeddedView(content, context);
+                viewRef.markForCheck();
+                return new ContentRef([viewRef.rootNodes], viewRef);
+            }
+            const viewRef = content.createEmbeddedView({});
+            this.applicationRef.attachView(viewRef);
+            return new ContentRef([viewRef.rootNodes], viewRef);
+        }
+        //Component case
+        if (typeof content === 'function') {
+            const contentCf = this.cfr.resolveComponentFactory(content);
+            const injector = Injector.create({
+                providers: this.providers,
+                parent: this.injector,
+            });
+            const componentRef = contentCf.create(injector);
+            Object.assign(componentRef.instance, initialState);
+            this.applicationRef.attachView(componentRef.hostView);
+            return new ContentRef([[componentRef.location.nativeElement]], componentRef.hostView, componentRef);
+        }
+        throw Error('Unsupported content type');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-loader.class.js","sourceRoot":"","sources":["../../../../../../projects/ng-components/src/lib/services/component-loader/component-loader.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ComponentFactoryResolver,\r\n  ViewContainerRef,\r\n  ComponentFactory,\r\n  Type,\r\n  ElementRef,\r\n  StaticProvider,\r\n  TemplateRef,\r\n  ComponentRef,\r\n  ApplicationRef,\r\n  Injector,\r\n} from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { ComponentLoaderOptions } from './component-loader-options.class';\r\nimport { ContentRef } from './content-ref.class';\r\n\r\n/**\r\n * Provides ways of loading and handling dynamic content.\r\n *\r\n * @remarks\r\n * Do NOT use this directly, create an instance through {@link ComponentLoaderFactory}\r\n * You can use this loader in two ways:\r\n * - Attaches a component to `ViewContainerRef`.\r\n * - Attaches a component to `ViewContainerRef`. The attached component has a `<ng-content>` tag inside its view. The {@link ComponentLoaderOptions.content} will be drawn inside this tag.\r\n *\r\n * @internal\r\n */\r\nexport class ComponentLoader<T> {\r\n  /**\r\n   * Before content is shown event.\r\n   */\r\n  onBeforeShow = new Subject();\r\n  /**\r\n   * After show content event.\r\n   * @returns The id of newly created component ref.\r\n   */\r\n  onShown = new Subject();\r\n  /**\r\n   * Before content is hidden event.\r\n   * @returns The instance of attached component;\r\n   */\r\n  onBeforeHide = new Subject();\r\n  /**\r\n   * After content is hidden event.\r\n   * @returns The id of destroyed component ref.\r\n   */\r\n  onHidden = new Subject();\r\n\r\n  public instance?: T;\r\n  public componentRef?: ComponentRef<T>;\r\n  private componentFactory?: ComponentFactory<T>;\r\n  private container: string | ElementRef | any;\r\n  private providers: StaticProvider[] = [];\r\n  private contentRef?: ContentRef;\r\n  private containerDefaultSelector = 'body';\r\n  private innerComponent?: ComponentRef<T>;\r\n  constructor(\r\n    private vcr: ViewContainerRef | undefined,\r\n    private cfr: ComponentFactoryResolver,\r\n    private applicationRef: ApplicationRef,\r\n    private injector: Injector\r\n  ) {}\r\n\r\n  /**\r\n   * Attaches component.\r\n   * @param componentType - The type component to attach.\r\n   * @returns Current instance of {@link ComponentLoader}\r\n   */\r\n  public attach(componentType: Type<T>): ComponentLoader<T> {\r\n    this.componentFactory = this.cfr.resolveComponentFactory<T>(componentType);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Body will be used in nothing is provided.\r\n   * @param container - The element in which dynamic content will be drawn inside to. For string case a query to the dom will be executed to find the element.\r\n   * @returns Current instance of {@link ComponentLoader}\r\n   */\r\n  public to(container?: string | ElementRef): ComponentLoader<T> {\r\n    this.container = container || this.container;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Adds provider to the providers array. These providers will be injected to the attached component.\r\n   *\r\n   * @see {@link https://angular.io/guide/glossary#di-token | Injection Token}\r\n   *\r\n   * @param provider - Provider to inject.\r\n   * @returns Current instance of {@link ComponentLoader}\r\n   */\r\n  public provide(provider: StaticProvider): ComponentLoader<T> {\r\n    this.providers.push(provider);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Attaches attached component to dom and any dynamic content if provided.\r\n   * @remarks\r\n   * Also triggers the {@link ComponentLoader.onBeforeShow} and {@link ComponentLoader.onShown} events.\r\n   *\r\n   * @param options - {@link ComponentLoaderOptions}.\r\n   * @returns A reference to the created content.\r\n   */\r\n  public show(options: ComponentLoaderOptions = {}): ComponentRef<T> | undefined {\r\n    if (this.componentRef) {\r\n      throw Error('Component is already shown');\r\n    }\r\n    if (!this.componentFactory) {\r\n      throw Error('You must attach a component');\r\n    }\r\n    this.onBeforeShow.next();\r\n\r\n    if (options.content) {\r\n      this.contentRef = this.getContentRef(options.content, options.context, options.initialState);\r\n    }\r\n    this.createComponentAndAttachToView(options);\r\n    this.appendContentToContainer();\r\n    this.markComponentsForCheck();\r\n\r\n    this.onShown.next(options.id);\r\n\r\n    return this.componentRef;\r\n  }\r\n\r\n  /**\r\n   * Removes attached component from dom.\r\n   * @remarks\r\n   * Also triggers the {@link ComponentLoader.onBeforeHide} and {@link ComponentLoader.onHidden} events.\r\n   *\r\n   * @param id - If provided it is returned through the {@link ComponentLoader.onHidden}.\r\n   * @returns Current instance of {@link ComponentLoader}\r\n   */\r\n  public hide(id?: number | string, result?: any): ComponentLoader<T> {\r\n    if (!this.componentRef) {\r\n      throw Error('No attached component found to hide');\r\n    }\r\n\r\n    this.onBeforeHide.next(this.componentRef.instance);\r\n\r\n    const componentEl = this.componentRef.location.nativeElement;\r\n    componentEl.parentNode.removeChild(componentEl);\r\n    if (this.contentRef?.componentRef) {\r\n      this.contentRef.componentRef.destroy();\r\n    }\r\n    if (this.vcr && this.contentRef?.viewRef) {\r\n      this.vcr.remove(this.vcr.indexOf(this.contentRef.viewRef));\r\n    }\r\n    if (this.contentRef?.viewRef) {\r\n      this.contentRef.viewRef.destroy();\r\n    }\r\n    this.contentRef = void 0;\r\n    this.componentRef = void 0;\r\n\r\n    this.onHidden.next(id ? { id, result } : null);\r\n\r\n    return this;\r\n  }\r\n\r\n  getInnerComponent(): ComponentRef<T> | undefined {\r\n    return this.innerComponent;\r\n  }\r\n\r\n  private markComponentsForCheck() {\r\n    if (this.contentRef?.componentRef) {\r\n      this.innerComponent = this.contentRef.componentRef.instance;\r\n      this.contentRef.componentRef.changeDetectorRef.markForCheck();\r\n      this.contentRef.componentRef.changeDetectorRef.detectChanges();\r\n    }\r\n    this.componentRef!.changeDetectorRef.markForCheck();\r\n    this.componentRef!.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  private createComponentAndAttachToView(options: ComponentLoaderOptions) {\r\n    const injector = Injector.create({\r\n      providers: this.providers,\r\n      parent: this.injector,\r\n    });\r\n    this.componentRef = this.componentFactory!.create(injector, this.contentRef?.nodes);\r\n    this.applicationRef.attachView(this.componentRef.hostView);\r\n    this.instance = this.componentRef.instance;\r\n    Object.assign(this.componentRef.instance, options);\r\n  }\r\n\r\n  private appendContentToContainer() {\r\n    if (this.container instanceof ElementRef) {\r\n      this.container.nativeElement.appendChild(this.componentRef?.location.nativeElement);\r\n    }\r\n    if (typeof this.container === 'string' && typeof document !== 'undefined') {\r\n      const selectedElement = document.querySelector(this.container) || document.querySelector(this.containerDefaultSelector);\r\n      if (!selectedElement) {\r\n        return;\r\n      }\r\n      selectedElement.appendChild(this.componentRef?.location.nativeElement);\r\n    }\r\n  }\r\n\r\n  private getContentRef(content?: string | TemplateRef<any>, context?: any, initialState?: any): ContentRef {\r\n    //TemplateRef case\r\n    if (content instanceof TemplateRef) {\r\n      if (this.vcr) {\r\n        const viewRef = this.vcr.createEmbeddedView<TemplateRef<T>>(content, context);\r\n        viewRef.markForCheck();\r\n        return new ContentRef([viewRef.rootNodes], viewRef);\r\n      }\r\n      const viewRef = content.createEmbeddedView({});\r\n      this.applicationRef.attachView(viewRef);\r\n      return new ContentRef([viewRef.rootNodes], viewRef);\r\n    }\r\n\r\n    //Component case\r\n    if (typeof content === 'function') {\r\n      const contentCf = this.cfr.resolveComponentFactory(content);\r\n      const injector = Injector.create({\r\n        providers: this.providers,\r\n        parent: this.injector,\r\n      });\r\n      const componentRef = contentCf.create(injector);\r\n      Object.assign(componentRef.instance, initialState);\r\n      this.applicationRef.attachView(componentRef.hostView);\r\n      return new ContentRef([[componentRef.location.nativeElement]], componentRef.hostView, componentRef);\r\n    }\r\n\r\n    throw Error('Unsupported content type');\r\n  }\r\n}\r\n"]}

package/esm2020/lib/services/component-loader/component-loader.factory.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { ComponentLoader } from './component-loader.class';
+import * as i0 from "@angular/core";
+/**
+ * Use to create instances of {@link ComponentLoader}.
+ *
+ * @public
+ */
+export class ComponentLoaderFactory {
+    constructor(componentFactoryResolver, injector, applicationRef) {
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.injector = injector;
+        this.applicationRef = applicationRef;
+    }
+    /**
+     * Returns a new instance of {@link ComponentLoader}
+     * @param viewContainerRef - The view container the dynamic content will be attached to.
+     * @returns A new instance of {@link ComponentLoader}.
+     *
+     * @public
+     */
+    createLoader(viewContainerRef) {
+        return new ComponentLoader(viewContainerRef, this.componentFactoryResolver, this.applicationRef, this.injector);
+    }
+}
+ComponentLoaderFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ComponentLoaderFactory, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.Injector }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Injectable });
+ComponentLoaderFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ComponentLoaderFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ComponentLoaderFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.Injector }, { type: i0.ApplicationRef }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/modal-service/modal-backdrop-component.mjs

@@ -0,0 +1,44 @@
+import { Component, ViewEncapsulation } from '@angular/core';
+import { animationTime, cssClassNames } from './modal-styles.class';
+import * as i0 from "@angular/core";
+/**
+ * Background layer for modals.
+ * Override class name to theme it.
+ * @see {@link cssClassNames}
+ * @internal
+ */
+export class ModalBackdropComponent {
+    constructor(element, renderer) {
+        this.element = element;
+        this.renderer = renderer;
+        this.animationsEnabled = false;
+    }
+    ngOnInit() {
+        if (this.animationsEnabled) {
+            this.renderer.addClass(this.element.nativeElement, cssClassNames.fade);
+            this.reflow(this.element.nativeElement);
+        }
+        this.renderer.addClass(this.element.nativeElement, cssClassNames.show);
+    }
+    hide() {
+        this.renderer.removeClass(this.element.nativeElement, cssClassNames.show);
+        setTimeout(() => this.backdropLoader?.hide(), this.animationsEnabled ? animationTime.backdrop : 0);
+    }
+    reflow(element) {
+        ((bs) => bs)(element.offsetHeight);
+    }
+}
+ModalBackdropComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalBackdropComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+ModalBackdropComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: ModalBackdropComponent, selector: "lib-modal-backdrop", host: { classAttribute: "modal-backdrop" }, ngImport: i0, template: '', isInline: true, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalBackdropComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-modal-backdrop',
+                    encapsulation: ViewEncapsulation.None,
+                    template: '',
+                    host: {
+                        class: cssClassNames.backdrop,
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/modal-service/modal-container-component.mjs

@@ -0,0 +1,126 @@
+import { Component, HostListener } from '@angular/core';
+import { animationTime, cssClassNames } from './modal-styles.class';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-options.class";
+/**
+ * Modal container component.
+ * @remarks
+ * All dynamic content `TemplateRef` or `Component` case will be drawn inside this.
+ * You can override css classes to theme it {@link cssClassNames}
+ * @internal
+ */
+export class ModalContainerComponent {
+    constructor(options, _element, renderer) {
+        this._element = _element;
+        this.renderer = renderer;
+        this.isShown = false;
+        this.animationsEnabled = false;
+        this.isModalHiding = false;
+        this.clickStartedInContent = false;
+        this.config = Object.assign({}, options);
+    }
+    ngOnInit() {
+        if (this.animationsEnabled) {
+            this.renderer.addClass(this._element.nativeElement, cssClassNames.fade);
+        }
+        this.renderer.setStyle(this._element.nativeElement, 'display', 'block');
+        setTimeout(() => {
+            this.isShown = true;
+            this.renderer.addClass(this._element.nativeElement, cssClassNames.show);
+        }, this.animationsEnabled ? animationTime.backdrop : 0);
+        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.hide();
+    }
+    onPopState() {
+        this.hide();
+    }
+    onEsc(event) {
+        if (!this.isShown) {
+            return;
+        }
+        if (event.keyCode === 27 || event.key === 'Escape' || event.key === 'Esc') {
+            event.preventDefault();
+        }
+        if (this.config.keyboard && this.config.id === this.modalService?.getActiveModal().config.id) {
+            this.hide();
+        }
+    }
+    ngOnDestroy() {
+        if (this.isShown) {
+            this._hide();
+        }
+    }
+    hide(result) {
+        if (this.isModalHiding || !this.isShown) {
+            return;
+        }
+        if (this.config.closeInterceptor) {
+            this.config.closeInterceptor().then(() => this._hide(), () => undefined);
+            return;
+        }
+        this._hide(result);
+    }
+    _hide(result) {
+        this.isModalHiding = true;
+        this.renderer.removeClass(this._element.nativeElement, cssClassNames.show);
+        setTimeout(() => {
+            this.isShown = false;
+            this.modalService?.hide(this.config.id, result);
+            this.isModalHiding = false;
+        }, this.animationsEnabled ? animationTime.modal : 0);
+    }
+}
+ModalContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalContainerComponent, deps: [{ token: i1.ModalOptions }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+ModalContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.0", type: ModalContainerComponent, selector: "lib-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 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-modal-container',
+                    template: `
+    <div [class]="'modal-dialog' + (config.class ? ' ' + config.class : '')" role="document" focusTrap>
+      <div class="modal-content">
+        <ng-content></ng-content>
+      </div>
+    </div>
+  `,
+                    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":["../../../../../../projects/ng-components/src/lib/services/modal-service/modal-container-component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, HostListener, OnDestroy, OnInit, Renderer2 } from '@angular/core';\r\nimport { animationTime, cssClassNames } from './modal-styles.class';\r\nimport { ModalOptions } from './modal-options.class';\r\nimport { ModalService } from './modal-service';\r\n\r\n/**\r\n * Modal container component.\r\n * @remarks\r\n * All dynamic content `TemplateRef` or `Component` case will be drawn inside this.\r\n * You can override css classes to theme it {@link cssClassNames}\r\n * @internal\r\n */\r\n@Component({\r\n  selector: 'lib-modal-container',\r\n  template: `\r\n    <div [class]=\"'modal-dialog' + (config.class ? ' ' + config.class : '')\" role=\"document\" focusTrap>\r\n      <div class=\"modal-content\">\r\n        <ng-content></ng-content>\r\n      </div>\r\n    </div>\r\n  `,\r\n  host: {\r\n    class: 'modal',\r\n    role: 'dialog',\r\n    tabindex: '-1',\r\n    '[attr.aria-modal]': 'true',\r\n    '[attr.aria-labelledby]': 'config.ariaLabelledBy',\r\n    '[attr.aria-describedby]': 'config.ariaDescribedby',\r\n  },\r\n})\r\nexport class ModalContainerComponent implements OnInit, OnDestroy {\r\n  public level?: number;\r\n  public config: ModalOptions;\r\n  public modalService?: ModalService;\r\n  private isShown = false;\r\n  private animationsEnabled = false;\r\n  private isModalHiding = false;\r\n  private clickStartedInContent = false;\r\n  constructor(options: ModalOptions, protected _element: ElementRef, private renderer: Renderer2) {\r\n    this.config = Object.assign({}, options);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (this.animationsEnabled) {\r\n      this.renderer.addClass(this._element.nativeElement, cssClassNames.fade);\r\n    }\r\n    this.renderer.setStyle(this._element.nativeElement, 'display', 'block');\r\n    setTimeout(\r\n      () => {\r\n        this.isShown = true;\r\n        this.renderer.addClass(this._element.nativeElement, cssClassNames.show);\r\n      },\r\n      this.animationsEnabled ? animationTime.backdrop : 0\r\n    );\r\n    if (this._element.nativeElement) {\r\n      this._element.nativeElement.focus();\r\n    }\r\n  }\r\n\r\n  @HostListener('mousedown', ['$event'])\r\n  onClickStarted(event: MouseEvent): void {\r\n    this.clickStartedInContent = event.target !== this._element.nativeElement;\r\n  }\r\n\r\n  @HostListener('click', ['$event'])\r\n  onClickStop(event: MouseEvent): void {\r\n    const clickedInBackdrop = event.target === this._element.nativeElement && !this.clickStartedInContent;\r\n    if (this.config.ignoreBackdropClick || this.config.backdrop === 'static' || !clickedInBackdrop) {\r\n      this.clickStartedInContent = false;\r\n      return;\r\n    }\r\n    this.hide();\r\n  }\r\n\r\n  @HostListener('window:popstate')\r\n  onPopState(): void {\r\n    this.hide();\r\n  }\r\n\r\n  @HostListener('window:keydown.esc', ['$event'])\r\n  onEsc(event: KeyboardEvent): void {\r\n    if (!this.isShown) {\r\n      return;\r\n    }\r\n    if (event.keyCode === 27 || event.key === 'Escape' || event.key === 'Esc') {\r\n      event.preventDefault();\r\n    }\r\n    if (this.config.keyboard && this.config.id === this.modalService?.getActiveModal().config.id) {\r\n      this.hide();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.isShown) {\r\n      this._hide();\r\n    }\r\n  }\r\n\r\n  hide(result?: any): void {\r\n    if (this.isModalHiding || !this.isShown) {\r\n      return;\r\n    }\r\n    if (this.config.closeInterceptor) {\r\n      this.config.closeInterceptor().then(\r\n        () => this._hide(),\r\n        () => undefined\r\n      );\r\n      return;\r\n    }\r\n    this._hide(result);\r\n  }\r\n\r\n  private _hide(result?: any): void {\r\n    this.isModalHiding = true;\r\n    this.renderer.removeClass(this._element.nativeElement, cssClassNames.show);\r\n    setTimeout(\r\n      () => {\r\n        this.isShown = false;\r\n        this.modalService?.hide(this.config.id, result);\r\n        this.isModalHiding = false;\r\n      },\r\n      this.animationsEnabled ? animationTime.modal : 0\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2020/lib/services/modal-service/modal-options.class.mjs

@@ -0,0 +1,34 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Modals option can be passed to a specific modal from {@link ModalService.show} or set globbaly using the injection token {@link MODAL_CONFIG_DEFAULT_OVERRIDE}.
+ * @remarks
+ * Modal specific options are merged with global options.
+ * @see {@link modalConfigDefaults} for defaults.
+ * @public
+ */
+export class ModalOptions {
+}
+ModalOptions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalOptions, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ModalOptions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalOptions });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: ModalOptions, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Default option values.
+ */
+export const modalConfigDefaults = {
+    backdrop: true,
+    keyboard: true,
+    show: false,
+    ignoreBackdropClick: false,
+    class: '',
+    animated: true,
+    initialState: {},
+    closeInterceptor: void 0,
+};
+/**
+ * Use this injection token to set global options.
+ */
+export const MODAL_CONFIG_DEFAULT_OVERRIDE = new InjectionToken('override-default-config');
+//# sourceMappingURL=data:application/json;base64,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