ng-hub-ui-modal 1.0.0

package/esm2022/lib/modal-ref.mjs

@@ -0,0 +1,216 @@
+import { of, Subject, zip } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { isDefined, isPromise } from 'ng-hub-ui-utils';
+/**
+ * A reference to the currently opened (active) modal.
+ *
+ * Instances of this class can be injected into your component passed as modal content.
+ * So you can `.update()`, `.close()` or `.dismiss()` the modal window from your component.
+ */
+export class HubActiveModal {
+    /**
+     * Updates options of an opened modal.
+     *
+     * @since 14.2.0
+     */
+    update(options) { }
+    /**
+     * Closes the modal with an optional `result` value.
+     *
+     * The `HubModalRef.result` promise will be resolved with the provided value.
+     */
+    close(result) { }
+    /**
+     * Dismisses the modal with an optional `reason` value.
+     *
+     * The `HubModalRef.result` promise will be rejected with the provided value.
+     */
+    dismiss(reason) { }
+}
+const WINDOW_ATTRIBUTES = [
+    'animation',
+    'ariaLabelledBy',
+    'ariaDescribedBy',
+    'backdrop',
+    'centered',
+    'fullscreen',
+    'keyboard',
+    'scrollable',
+    'size',
+    'windowClass',
+    'modalDialogClass'
+];
+const BACKDROP_ATTRIBUTES = ['animation', 'backdropClass'];
+/**
+ * A reference to the newly opened modal returned by the `HubModal.open()` method.
+ */
+export class HubModalRef {
+    _applyWindowOptions(windowInstance, options) {
+        WINDOW_ATTRIBUTES.forEach((optionName) => {
+            if (isDefined(options[optionName])) {
+                windowInstance[optionName] = options[optionName];
+            }
+        });
+    }
+    _applyBackdropOptions(backdropInstance, options) {
+        BACKDROP_ATTRIBUTES.forEach((optionName) => {
+            if (isDefined(options[optionName])) {
+                backdropInstance[optionName] = options[optionName];
+            }
+        });
+    }
+    /**
+     * Updates options of an opened modal.
+     *
+     * @since 14.2.0
+     */
+    update(options) {
+        this._applyWindowOptions(this._windowCmptRef.instance, options);
+        if (this._backdropCmptRef && this._backdropCmptRef.instance) {
+            this._applyBackdropOptions(this._backdropCmptRef.instance, options);
+        }
+    }
+    /**
+     * The instance of a component used for the modal content.
+     *
+     * When a `TemplateRef` is used as the content or when the modal is closed, will return `undefined`.
+     */
+    get componentInstance() {
+        if (this._contentRef && this._contentRef.componentRef) {
+            return this._contentRef.componentRef.instance;
+        }
+    }
+    /**
+     * The observable that emits when the modal is closed via the `.close()` method.
+     *
+     * It will emit the result passed to the `.close()` method.
+     *
+     * @since 8.0.0
+     */
+    get closed() {
+        return this._closed.asObservable().pipe(takeUntil(this._hidden));
+    }
+    /**
+     * The observable that emits when the modal is dismissed via the `.dismiss()` method.
+     *
+     * It will emit the reason passed to the `.dismissed()` method by the user, or one of the internal
+     * reasons like backdrop click or ESC key press.
+     *
+     * @since 8.0.0
+     */
+    get dismissed() {
+        return this._dismissed.asObservable().pipe(takeUntil(this._hidden));
+    }
+    /**
+     * The observable that emits when both modal window and backdrop are closed and animations were finished.
+     * At this point modal and backdrop elements will be removed from the DOM tree.
+     *
+     * This observable will be completed after emitting.
+     *
+     * @since 8.0.0
+     */
+    get hidden() {
+        return this._hidden.asObservable();
+    }
+    /**
+     * The observable that emits when modal is fully visible and animation was finished.
+     * Modal DOM element is always available synchronously after calling 'modal.open()' service.
+     *
+     * This observable will be completed after emitting.
+     * It will not emit, if modal is closed before open animation is finished.
+     *
+     * @since 8.0.0
+     */
+    get shown() {
+        return this._windowCmptRef.instance.shown.asObservable();
+    }
+    constructor(_windowCmptRef, _contentRef, _backdropCmptRef, _beforeDismiss) {
+        this._windowCmptRef = _windowCmptRef;
+        this._contentRef = _contentRef;
+        this._backdropCmptRef = _backdropCmptRef;
+        this._beforeDismiss = _beforeDismiss;
+        this._closed = new Subject();
+        this._dismissed = new Subject();
+        this._hidden = new Subject();
+        _windowCmptRef.instance.dismissEvent.subscribe((reason) => {
+            this.dismiss(reason);
+        });
+        this.result = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this.result.then(null, () => { });
+    }
+    /**
+     * Closes the modal with an optional `result` value.
+     *
+     * The `HubMobalRef.result` promise will be resolved with the provided value.
+     */
+    close(result) {
+        if (this._windowCmptRef) {
+            this._closed.next(result);
+            this._resolve(result);
+            this._removeModalElements();
+        }
+    }
+    _dismiss(reason) {
+        this._dismissed.next(reason);
+        this._reject(reason);
+        this._removeModalElements();
+    }
+    /**
+     * Dismisses the modal with an optional `reason` value.
+     *
+     * The `HubModalRef.result` promise will be rejected with the provided value.
+     */
+    dismiss(reason) {
+        if (this._windowCmptRef) {
+            if (!this._beforeDismiss) {
+                this._dismiss(reason);
+            }
+            else {
+                const dismiss = this._beforeDismiss();
+                if (isPromise(dismiss)) {
+                    dismiss.then((result) => {
+                        if (result !== false) {
+                            this._dismiss(reason);
+                        }
+                    }, () => { });
+                }
+                else if (dismiss !== false) {
+                    this._dismiss(reason);
+                }
+            }
+        }
+    }
+    _removeModalElements() {
+        const windowTransition$ = this._windowCmptRef.instance.hide();
+        const backdropTransition$ = this._backdropCmptRef
+            ? this._backdropCmptRef.instance.hide()
+            : of(undefined);
+        // hiding window
+        windowTransition$.subscribe(() => {
+            const { nativeElement } = this._windowCmptRef.location;
+            nativeElement.parentNode.removeChild(nativeElement);
+            this._windowCmptRef.destroy();
+            this._contentRef?.viewRef?.destroy();
+            this._windowCmptRef = null;
+            this._contentRef = null;
+        });
+        // hiding backdrop
+        backdropTransition$.subscribe(() => {
+            if (this._backdropCmptRef) {
+                const { nativeElement } = this._backdropCmptRef.location;
+                nativeElement.parentNode.removeChild(nativeElement);
+                this._backdropCmptRef.destroy();
+                this._backdropCmptRef = null;
+            }
+        });
+        // all done
+        zip(windowTransition$, backdropTransition$).subscribe(() => {
+            this._hidden.next();
+            this._hidden.complete();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-ref.js","sourceRoot":"","sources":["../../../../projects/modal/src/lib/modal-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\nimport { Observable, of, Subject, zip } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { HubModalBackdrop } from './modal-backdrop';\nimport { HubModalWindow } from './modal-window';\nimport { HubModalOptions, HubModalUpdatableOptions } from './modal-config';\nimport { ContentRef, isDefined, isPromise } from 'ng-hub-ui-utils';\n\n/**\n * A reference to the currently opened (active) modal.\n *\n * Instances of this class can be injected into your component passed as modal content.\n * So you can `.update()`, `.close()` or `.dismiss()` the modal window from your component.\n */\nexport class HubActiveModal {\n\t/**\n\t * Updates options of an opened modal.\n\t *\n\t * @since 14.2.0\n\t */\n\tupdate(options: HubModalUpdatableOptions): void {}\n\t/**\n\t * Closes the modal with an optional `result` value.\n\t *\n\t * The `HubModalRef.result` promise will be resolved with the provided value.\n\t */\n\tclose(result?: any): void {}\n\n\t/**\n\t * Dismisses the modal with an optional `reason` value.\n\t *\n\t * The `HubModalRef.result` promise will be rejected with the provided value.\n\t */\n\tdismiss(reason?: any): void {}\n}\n\nconst WINDOW_ATTRIBUTES: string[] = [\n\t'animation',\n\t'ariaLabelledBy',\n\t'ariaDescribedBy',\n\t'backdrop',\n\t'centered',\n\t'fullscreen',\n\t'keyboard',\n\t'scrollable',\n\t'size',\n\t'windowClass',\n\t'modalDialogClass'\n];\nconst BACKDROP_ATTRIBUTES: string[] = ['animation', 'backdropClass'];\n\n/**\n * A reference to the newly opened modal returned by the `HubModal.open()` method.\n */\nexport class HubModalRef {\n\tprivate _closed = new Subject<any>();\n\tprivate _dismissed = new Subject<any>();\n\tprivate _hidden = new Subject<void>();\n\tprivate _resolve!: (result?: any) => void;\n\tprivate _reject!: (reason?: any) => void;\n\n\tprivate _applyWindowOptions(\n\t\twindowInstance: HubModalWindow,\n\t\toptions: HubModalOptions\n\t): void {\n\t\tWINDOW_ATTRIBUTES.forEach((optionName: string) => {\n\t\t\tif (isDefined(options[optionName])) {\n\t\t\t\twindowInstance[optionName] = options[optionName];\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate _applyBackdropOptions(\n\t\tbackdropInstance: HubModalBackdrop,\n\t\toptions: HubModalOptions\n\t): void {\n\t\tBACKDROP_ATTRIBUTES.forEach((optionName: string) => {\n\t\t\tif (isDefined(options[optionName])) {\n\t\t\t\tbackdropInstance[optionName] = options[optionName];\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Updates options of an opened modal.\n\t *\n\t * @since 14.2.0\n\t */\n\tupdate(options: HubModalUpdatableOptions): void {\n\t\tthis._applyWindowOptions(this._windowCmptRef.instance, options);\n\t\tif (this._backdropCmptRef && this._backdropCmptRef.instance) {\n\t\t\tthis._applyBackdropOptions(this._backdropCmptRef.instance, options);\n\t\t}\n\t}\n\n\t/**\n\t * The instance of a component used for the modal content.\n\t *\n\t * When a `TemplateRef` is used as the content or when the modal is closed, will return `undefined`.\n\t */\n\tget componentInstance(): any {\n\t\tif (this._contentRef && this._contentRef.componentRef) {\n\t\t\treturn this._contentRef.componentRef.instance;\n\t\t}\n\t}\n\n\t/**\n\t * The promise that is resolved when the modal is closed and rejected when the modal is dismissed.\n\t */\n\tresult: Promise<any>;\n\n\t/**\n\t * The observable that emits when the modal is closed via the `.close()` method.\n\t *\n\t * It will emit the result passed to the `.close()` method.\n\t *\n\t * @since 8.0.0\n\t */\n\tget closed(): Observable<any> {\n\t\treturn this._closed.asObservable().pipe(takeUntil(this._hidden));\n\t}\n\n\t/**\n\t * The observable that emits when the modal is dismissed via the `.dismiss()` method.\n\t *\n\t * It will emit the reason passed to the `.dismissed()` method by the user, or one of the internal\n\t * reasons like backdrop click or ESC key press.\n\t *\n\t * @since 8.0.0\n\t */\n\tget dismissed(): Observable<any> {\n\t\treturn this._dismissed.asObservable().pipe(takeUntil(this._hidden));\n\t}\n\n\t/**\n\t * The observable that emits when both modal window and backdrop are closed and animations were finished.\n\t * At this point modal and backdrop elements will be removed from the DOM tree.\n\t *\n\t * This observable will be completed after emitting.\n\t *\n\t * @since 8.0.0\n\t */\n\tget hidden(): Observable<void> {\n\t\treturn this._hidden.asObservable();\n\t}\n\n\t/**\n\t * The observable that emits when modal is fully visible and animation was finished.\n\t * Modal DOM element is always available synchronously after calling 'modal.open()' service.\n\t *\n\t * This observable will be completed after emitting.\n\t * It will not emit, if modal is closed before open animation is finished.\n\t *\n\t * @since 8.0.0\n\t */\n\tget shown(): Observable<void> {\n\t\treturn this._windowCmptRef.instance.shown.asObservable();\n\t}\n\n\tconstructor(\n\t\tprivate _windowCmptRef: ComponentRef<HubModalWindow>,\n\t\tprivate _contentRef: ContentRef,\n\t\tprivate _backdropCmptRef?: ComponentRef<HubModalBackdrop>,\n\t\tprivate _beforeDismiss?: () => boolean | Promise<boolean>\n\t) {\n\t\t_windowCmptRef.instance.dismissEvent.subscribe((reason: any) => {\n\t\t\tthis.dismiss(reason);\n\t\t});\n\n\t\tthis.result = new Promise((resolve, reject) => {\n\t\t\tthis._resolve = resolve;\n\t\t\tthis._reject = reject;\n\t\t});\n\t\tthis.result.then(null, () => {});\n\t}\n\n\t/**\n\t * Closes the modal with an optional `result` value.\n\t *\n\t * The `HubMobalRef.result` promise will be resolved with the provided value.\n\t */\n\tclose(result?: any): void {\n\t\tif (this._windowCmptRef) {\n\t\t\tthis._closed.next(result);\n\t\t\tthis._resolve(result);\n\t\t\tthis._removeModalElements();\n\t\t}\n\t}\n\n\tprivate _dismiss(reason?: any) {\n\t\tthis._dismissed.next(reason);\n\t\tthis._reject(reason);\n\t\tthis._removeModalElements();\n\t}\n\n\t/**\n\t * Dismisses the modal with an optional `reason` value.\n\t *\n\t * The `HubModalRef.result` promise will be rejected with the provided value.\n\t */\n\tdismiss(reason?: any): void {\n\t\tif (this._windowCmptRef) {\n\t\t\tif (!this._beforeDismiss) {\n\t\t\t\tthis._dismiss(reason);\n\t\t\t} else {\n\t\t\t\tconst dismiss = this._beforeDismiss();\n\t\t\t\tif (isPromise(dismiss)) {\n\t\t\t\t\tdismiss.then(\n\t\t\t\t\t\t(result) => {\n\t\t\t\t\t\t\tif (result !== false) {\n\t\t\t\t\t\t\t\tthis._dismiss(reason);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t\t() => {}\n\t\t\t\t\t);\n\t\t\t\t} else if (dismiss !== false) {\n\t\t\t\t\tthis._dismiss(reason);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate _removeModalElements() {\n\t\tconst windowTransition$ = this._windowCmptRef.instance.hide();\n\t\tconst backdropTransition$ = this._backdropCmptRef\n\t\t\t? this._backdropCmptRef.instance.hide()\n\t\t\t: of(undefined);\n\n\t\t// hiding window\n\t\twindowTransition$.subscribe(() => {\n\t\t\tconst { nativeElement } = this._windowCmptRef.location;\n\t\t\tnativeElement.parentNode.removeChild(nativeElement);\n\t\t\tthis._windowCmptRef.destroy();\n\t\t\tthis._contentRef?.viewRef?.destroy();\n\n\t\t\tthis._windowCmptRef = <any>null;\n\t\t\tthis._contentRef = <any>null;\n\t\t});\n\n\t\t// hiding backdrop\n\t\tbackdropTransition$.subscribe(() => {\n\t\t\tif (this._backdropCmptRef) {\n\t\t\t\tconst { nativeElement } = this._backdropCmptRef.location;\n\t\t\t\tnativeElement.parentNode.removeChild(nativeElement);\n\t\t\t\tthis._backdropCmptRef.destroy();\n\t\t\t\tthis._backdropCmptRef = <any>null;\n\t\t\t}\n\t\t});\n\n\t\t// all done\n\t\tzip(windowTransition$, backdropTransition$).subscribe(() => {\n\t\t\tthis._hidden.next();\n\t\t\tthis._hidden.complete();\n\t\t});\n\t}\n}\n"]}

package/esm2022/lib/modal-stack.mjs

@@ -0,0 +1,294 @@
+import { DOCUMENT } from '@angular/common';
+import { ApplicationRef, createComponent, EnvironmentInjector, EventEmitter, inject, Injectable, Injector, NgZone, TemplateRef } from '@angular/core';
+import { ContentRef, hubFocusTrap, isDefined, isString, ScrollBar } from 'ng-hub-ui-utils';
+import { Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { HubModalBackdrop } from './modal-backdrop';
+import { HubActiveModal, HubModalRef } from './modal-ref';
+import { HubModalWindow } from './modal-window';
+import * as i0 from "@angular/core";
+export class HubModalStack {
+    constructor() {
+        this._applicationRef = inject(ApplicationRef);
+        this._injector = inject(Injector);
+        this._environmentInjector = inject(EnvironmentInjector);
+        this._document = inject(DOCUMENT);
+        this._scrollBar = inject(ScrollBar);
+        this._activeWindowCmptHasChanged = new Subject();
+        this._ariaHiddenValues = new Map();
+        this._scrollBarRestoreFn = null;
+        this._modalRefs = [];
+        this._windowCmpts = [];
+        this._activeInstances = new EventEmitter();
+        const ngZone = inject(NgZone);
+        // Trap focus on active WindowCmpt
+        this._activeWindowCmptHasChanged.subscribe(() => {
+            if (this._windowCmpts.length) {
+                const activeWindowCmpt = this._windowCmpts[this._windowCmpts.length - 1];
+                hubFocusTrap(ngZone, activeWindowCmpt.location.nativeElement, this._activeWindowCmptHasChanged);
+                this._revertAriaHidden();
+                this._setAriaHidden(activeWindowCmpt.location.nativeElement);
+            }
+        });
+    }
+    _restoreScrollBar() {
+        const scrollBarRestoreFn = this._scrollBarRestoreFn;
+        if (scrollBarRestoreFn) {
+            this._scrollBarRestoreFn = null;
+            scrollBarRestoreFn();
+        }
+    }
+    _hideScrollBar() {
+        if (!this._scrollBarRestoreFn) {
+            this._scrollBarRestoreFn = this._scrollBar.hide();
+        }
+    }
+    open(contentInjector, content, options) {
+        const containerEl = options.container instanceof HTMLElement
+            ? options.container
+            : isDefined(options.container)
+                ? this._document.querySelector(options.container)
+                : this._document.body;
+        if (!containerEl) {
+            throw new Error(`The specified modal container "${options.container || 'body'}" was not found in the DOM.`);
+        }
+        this._hideScrollBar();
+        const activeModal = new HubActiveModal();
+        contentInjector = options.injector || contentInjector;
+        const environmentInjector = contentInjector.get(EnvironmentInjector, null) ||
+            this._environmentInjector;
+        const contentRef = this._getContentRef(contentInjector, environmentInjector, content, activeModal, options);
+        const backdropCmptRef = options.backdrop !== false
+            ? this._attachBackdrop(containerEl)
+            : undefined;
+        const windowCmptRef = this._attachWindowComponent(containerEl, contentRef.nodes, options);
+        const hubModalRef = new HubModalRef(windowCmptRef, contentRef, backdropCmptRef, options.beforeDismiss);
+        this._registerModalRef(hubModalRef);
+        this._registerWindowCmpt(windowCmptRef);
+        // We have to cleanup DOM after the last modal when BOTH 'hidden' was emitted and 'result' promise was resolved:
+        // - with animations OFF, 'hidden' emits synchronously, then 'result' is resolved asynchronously
+        // - with animations ON, 'result' is resolved asynchronously, then 'hidden' emits asynchronously
+        hubModalRef.hidden.pipe(take(1)).subscribe(() => Promise.resolve(true).then(() => {
+            if (!this._modalRefs.length) {
+                this._document.body.classList.remove('modal-open');
+                this._restoreScrollBar();
+                this._revertAriaHidden();
+            }
+        }));
+        activeModal.close = (result) => {
+            hubModalRef.close(result);
+        };
+        activeModal.dismiss = (reason) => {
+            hubModalRef.dismiss(reason);
+        };
+        activeModal.update = (options) => {
+            hubModalRef.update(options);
+        };
+        hubModalRef.update(options);
+        if (this._modalRefs.length === 1) {
+            this._document.body.classList.add('modal-open');
+        }
+        if (backdropCmptRef && backdropCmptRef.instance) {
+            backdropCmptRef.changeDetectorRef.detectChanges();
+        }
+        windowCmptRef.changeDetectorRef.detectChanges();
+        return hubModalRef;
+    }
+    get activeInstances() {
+        return this._activeInstances;
+    }
+    dismissAll(reason) {
+        this._modalRefs.forEach((hubModalRef) => hubModalRef.dismiss(reason));
+    }
+    hasOpenModals() {
+        return this._modalRefs.length > 0;
+    }
+    _attachBackdrop(containerEl) {
+        let backdropCmptRef = createComponent(HubModalBackdrop, {
+            environmentInjector: this._applicationRef.injector,
+            elementInjector: this._injector
+        });
+        this._applicationRef.attachView(backdropCmptRef.hostView);
+        containerEl.appendChild(backdropCmptRef.location.nativeElement);
+        return backdropCmptRef;
+    }
+    _attachWindowComponent(containerEl, [headerNodes, bodyNodes, footerNodes], options) {
+        const singleContent = !options.headerSelector && !options.footerSelector;
+        let windowCmptRef = createComponent(HubModalWindow, {
+            environmentInjector: this._applicationRef.injector,
+            elementInjector: this._injector,
+            projectableNodes: singleContent
+                ? [bodyNodes]
+                : [[], headerNodes, bodyNodes, footerNodes]
+        });
+        Object.assign(windowCmptRef.instance, { singleContent });
+        this._applicationRef.attachView(windowCmptRef.hostView);
+        containerEl.appendChild(windowCmptRef.location.nativeElement);
+        return windowCmptRef;
+    }
+    _getContentRef(contentInjector, environmentInjector, content, activeModal, options) {
+        if (!content) {
+            return new ContentRef([]);
+        }
+        else if (content instanceof TemplateRef) {
+            return this._createFromTemplateRef(content, activeModal, options);
+        }
+        else if (isString(content)) {
+            return this._createFromString(content);
+        }
+        else {
+            return this._createFromComponent(contentInjector, environmentInjector, content, activeModal, options);
+        }
+    }
+    _createFromTemplateRef(templateRef, activeModal, options) {
+        const context = {
+            $implicit: activeModal,
+            close(result) {
+                activeModal.close(result);
+            },
+            dismiss(reason) {
+                activeModal.dismiss(reason);
+            }
+        };
+        const viewRef = templateRef.createEmbeddedView(context);
+        this._applicationRef.attachView(viewRef);
+        const containerNode = document.createElement('ng-container');
+        containerNode.append(...viewRef.rootNodes);
+        this._addDismissEventListener(containerNode, context, options);
+        return new ContentRef([
+            options.headerSelector
+                ? extractAndRemoveNodesBySelector(containerNode, options.headerSelector)
+                : [],
+            containerNode.childNodes,
+            options.footerSelector
+                ? extractAndRemoveNodesBySelector(containerNode, options.footerSelector)
+                : []
+        ], viewRef);
+    }
+    _createFromString(content) {
+        const component = this._document.createTextNode(`${content}`);
+        return new ContentRef([[component]]);
+    }
+    _createFromComponent(contentInjector, environmentInjector, componentType, context, options) {
+        const elementInjector = Injector.create({
+            providers: [{ provide: HubActiveModal, useValue: context }],
+            parent: contentInjector
+        });
+        const componentRef = createComponent(componentType, {
+            environmentInjector,
+            elementInjector
+        });
+        const componentNativeEl = componentRef.location.nativeElement;
+        if (options.scrollable) {
+            componentNativeEl.classList.add('component-host-scrollable');
+        }
+        this._applicationRef.attachView(componentRef.hostView);
+        this._addDismissEventListener(componentNativeEl, context, options);
+        // FIXME: we should here get rid of the component nativeElement
+        // and use `[Array.from(componentNativeEl.childNodes)]` instead and remove the above CSS class.
+        return new ContentRef([
+            options.headerSelector
+                ? extractAndRemoveNodesBySelector(componentNativeEl, options.headerSelector)
+                : [],
+            componentNativeEl.childNodes,
+            options.footerSelector
+                ? extractAndRemoveNodesBySelector(componentNativeEl, options.footerSelector)
+                : []
+        ], componentRef.hostView, componentRef);
+    }
+    _setAriaHidden(element) {
+        const parent = element.parentElement;
+        if (parent && element !== this._document.body) {
+            Array.from(parent.children).forEach((sibling) => {
+                if (sibling !== element && sibling.nodeName !== 'SCRIPT') {
+                    this._ariaHiddenValues.set(sibling, sibling.getAttribute('aria-hidden'));
+                    sibling.setAttribute('aria-hidden', 'true');
+                }
+            });
+            this._setAriaHidden(parent);
+        }
+    }
+    _revertAriaHidden() {
+        this._ariaHiddenValues.forEach((value, element) => {
+            if (value) {
+                element.setAttribute('aria-hidden', value);
+            }
+            else {
+                element.removeAttribute('aria-hidden');
+            }
+        });
+        this._ariaHiddenValues.clear();
+    }
+    _registerModalRef(hubModalRef) {
+        const unregisterModalRef = () => {
+            const index = this._modalRefs.indexOf(hubModalRef);
+            if (index > -1) {
+                this._modalRefs.splice(index, 1);
+                this._activeInstances.emit(this._modalRefs);
+            }
+        };
+        this._modalRefs.push(hubModalRef);
+        this._activeInstances.emit(this._modalRefs);
+        hubModalRef.result.then(unregisterModalRef, unregisterModalRef);
+    }
+    _registerWindowCmpt(hubWindowCmpt) {
+        this._windowCmpts.push(hubWindowCmpt);
+        this._activeWindowCmptHasChanged.next();
+        hubWindowCmpt.onDestroy(() => {
+            const index = this._windowCmpts.indexOf(hubWindowCmpt);
+            if (index > -1) {
+                this._windowCmpts.splice(index, 1);
+                this._activeWindowCmptHasChanged.next();
+            }
+        });
+    }
+    /**
+     * Attaches click event listeners to elements within a container based on a specified dismiss selector to dismiss a modal.
+     *
+     * @param {HTMLElement} container - The `container` parameter is an HTMLElement that represents the DOM element which contains the
+     * modal content.
+     * @param {HubActiveModal} context - The `context` parameter in the `_addDismissEventListener` function refers to the active modal
+     * instance that is being displayed. It is used to call the `dismiss` method on the modal instance when a dismissible element is
+     * clicked.
+     * @param {HubModalOptions} options - The `options` parameter is an object that contains configuration options for the modal. It
+     * may include properties such as `dismissSelector`, which is used to specify a CSS selector for elements that, when clicked, will
+     * dismiss the modal by calling the `dismiss` method on the `context` object.
+     */
+    _addDismissEventListener(container, context, options) {
+        if (options.dismissSelector) {
+            const dismissaable = container.querySelectorAll(options.dismissSelector);
+            for (const item of Array.from(dismissaable)) {
+                item.addEventListener('click', () => context.dismiss());
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModalStack, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModalStack, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModalStack, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Extracts child nodes matching a selector from a container element, removes those nodes from the DOM, and returns them as an array.
+ *
+ * @param {HTMLElement} container - The `container` parameter in the `extractAndRemoveNodesBySelector` function is an HTMLElement
+ * that represents the parent element within which we want to search for nodes matching a specific selector and remove them.
+ * @param {string} selector - The `selector` parameter in the `extractAndRemoveNodesBySelector` function is a string that
+ * represents a CSS selector. This selector is used to query and select specific elements within the `container` HTMLElement.
+ *
+ * @returns An array of nodes that were extracted from the container element based on the provided selector, and then removes those
+ * nodes from the DOM.
+ */
+function extractAndRemoveNodesBySelector(container, selector) {
+    let containerNodes = container.querySelectorAll(selector);
+    const nodes = Array.from(containerNodes).reduce((acc, c) => {
+        return [...acc, ...Array.from(c.childNodes)];
+    }, []);
+    // Selecciona los nodos dentro del contenedor que coincidan con el selector
+    const nodesToRemove = container.querySelectorAll(selector);
+    // Convertir NodeList a array y eliminar cada nodo del DOM
+    Array.from(nodesToRemove).forEach((node) => node.remove());
+    return nodes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-stack.js","sourceRoot":"","sources":["../../../../projects/modal/src/lib/modal-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n\tApplicationRef,\n\tComponentRef,\n\tcreateComponent,\n\tEnvironmentInjector,\n\tEventEmitter,\n\tinject,\n\tInjectable,\n\tInjector,\n\tNgZone,\n\tTemplateRef,\n\tType\n} from '@angular/core';\nimport {\n\tContentRef,\n\thubFocusTrap,\n\tisDefined,\n\tisString,\n\tScrollBar\n} from 'ng-hub-ui-utils';\nimport { Subject } from 'rxjs';\nimport { take } from 'rxjs/operators';\nimport { HubModalBackdrop } from './modal-backdrop';\nimport { HubModalOptions, HubModalUpdatableOptions } from './modal-config';\nimport { HubActiveModal, HubModalRef } from './modal-ref';\nimport { HubModalWindow } from './modal-window';\n\n@Injectable({ providedIn: 'root' })\nexport class HubModalStack {\n\tprivate _applicationRef = inject(ApplicationRef);\n\tprivate _injector = inject(Injector);\n\tprivate _environmentInjector = inject(EnvironmentInjector);\n\tprivate _document = inject(DOCUMENT);\n\tprivate _scrollBar = inject(ScrollBar);\n\n\tprivate _activeWindowCmptHasChanged = new Subject<void>();\n\tprivate _ariaHiddenValues: Map<Element, string | null> = new Map();\n\tprivate _scrollBarRestoreFn: null | (() => void) = null;\n\tprivate _modalRefs: HubModalRef[] = [];\n\tprivate _windowCmpts: ComponentRef<HubModalWindow>[] = [];\n\tprivate _activeInstances: EventEmitter<HubModalRef[]> = new EventEmitter();\n\n\tconstructor() {\n\t\tconst ngZone = inject(NgZone);\n\n\t\t// Trap focus on active WindowCmpt\n\t\tthis._activeWindowCmptHasChanged.subscribe(() => {\n\t\t\tif (this._windowCmpts.length) {\n\t\t\t\tconst activeWindowCmpt =\n\t\t\t\t\tthis._windowCmpts[this._windowCmpts.length - 1];\n\t\t\t\thubFocusTrap(\n\t\t\t\t\tngZone,\n\t\t\t\t\tactiveWindowCmpt.location.nativeElement,\n\t\t\t\t\tthis._activeWindowCmptHasChanged\n\t\t\t\t);\n\t\t\t\tthis._revertAriaHidden();\n\t\t\t\tthis._setAriaHidden(activeWindowCmpt.location.nativeElement);\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate _restoreScrollBar() {\n\t\tconst scrollBarRestoreFn = this._scrollBarRestoreFn;\n\t\tif (scrollBarRestoreFn) {\n\t\t\tthis._scrollBarRestoreFn = null;\n\t\t\tscrollBarRestoreFn();\n\t\t}\n\t}\n\n\tprivate _hideScrollBar() {\n\t\tif (!this._scrollBarRestoreFn) {\n\t\t\tthis._scrollBarRestoreFn = this._scrollBar.hide();\n\t\t}\n\t}\n\n\topen(\n\t\tcontentInjector: Injector,\n\t\tcontent: any,\n\t\toptions: HubModalOptions\n\t): HubModalRef {\n\t\tconst containerEl =\n\t\t\toptions.container instanceof HTMLElement\n\t\t\t\t? options.container\n\t\t\t\t: isDefined(options.container)\n\t\t\t\t? this._document.querySelector(options.container!)\n\t\t\t\t: this._document.body;\n\n\t\tif (!containerEl) {\n\t\t\tthrow new Error(\n\t\t\t\t`The specified modal container \"${\n\t\t\t\t\toptions.container || 'body'\n\t\t\t\t}\" was not found in the DOM.`\n\t\t\t);\n\t\t}\n\n\t\tthis._hideScrollBar();\n\n\t\tconst activeModal = new HubActiveModal();\n\n\t\tcontentInjector = options.injector || contentInjector;\n\t\tconst environmentInjector =\n\t\t\tcontentInjector.get(EnvironmentInjector, null) ||\n\t\t\tthis._environmentInjector;\n\t\tconst contentRef = this._getContentRef(\n\t\t\tcontentInjector,\n\t\t\tenvironmentInjector,\n\t\t\tcontent,\n\t\t\tactiveModal,\n\t\t\toptions\n\t\t);\n\n\t\tconst backdropCmptRef: ComponentRef<HubModalBackdrop> | undefined =\n\t\t\toptions.backdrop !== false\n\t\t\t\t? this._attachBackdrop(containerEl)\n\t\t\t\t: undefined;\n\t\tconst windowCmptRef: ComponentRef<HubModalWindow> =\n\t\t\tthis._attachWindowComponent(containerEl, contentRef.nodes, options);\n\t\tconst hubModalRef: HubModalRef = new HubModalRef(\n\t\t\twindowCmptRef,\n\t\t\tcontentRef,\n\t\t\tbackdropCmptRef,\n\t\t\toptions.beforeDismiss\n\t\t);\n\n\t\tthis._registerModalRef(hubModalRef);\n\t\tthis._registerWindowCmpt(windowCmptRef);\n\n\t\t// We have to cleanup DOM after the last modal when BOTH 'hidden' was emitted and 'result' promise was resolved:\n\t\t// - with animations OFF, 'hidden' emits synchronously, then 'result' is resolved asynchronously\n\t\t// - with animations ON, 'result' is resolved asynchronously, then 'hidden' emits asynchronously\n\t\thubModalRef.hidden.pipe(take(1)).subscribe(() =>\n\t\t\tPromise.resolve(true).then(() => {\n\t\t\t\tif (!this._modalRefs.length) {\n\t\t\t\t\tthis._document.body.classList.remove('modal-open');\n\t\t\t\t\tthis._restoreScrollBar();\n\t\t\t\t\tthis._revertAriaHidden();\n\t\t\t\t}\n\t\t\t})\n\t\t);\n\n\t\tactiveModal.close = (result: any) => {\n\t\t\thubModalRef.close(result);\n\t\t};\n\t\tactiveModal.dismiss = (reason: any) => {\n\t\t\thubModalRef.dismiss(reason);\n\t\t};\n\n\t\tactiveModal.update = (options: HubModalUpdatableOptions) => {\n\t\t\thubModalRef.update(options);\n\t\t};\n\n\t\thubModalRef.update(options);\n\t\tif (this._modalRefs.length === 1) {\n\t\t\tthis._document.body.classList.add('modal-open');\n\t\t}\n\n\t\tif (backdropCmptRef && backdropCmptRef.instance) {\n\t\t\tbackdropCmptRef.changeDetectorRef.detectChanges();\n\t\t}\n\t\twindowCmptRef.changeDetectorRef.detectChanges();\n\t\treturn hubModalRef;\n\t}\n\n\tget activeInstances() {\n\t\treturn this._activeInstances;\n\t}\n\n\tdismissAll(reason?: any) {\n\t\tthis._modalRefs.forEach((hubModalRef) => hubModalRef.dismiss(reason));\n\t}\n\n\thasOpenModals(): boolean {\n\t\treturn this._modalRefs.length > 0;\n\t}\n\n\tprivate _attachBackdrop(\n\t\tcontainerEl: Element\n\t): ComponentRef<HubModalBackdrop> {\n\t\tlet backdropCmptRef = createComponent(HubModalBackdrop, {\n\t\t\tenvironmentInjector: this._applicationRef.injector,\n\t\t\telementInjector: this._injector\n\t\t});\n\t\tthis._applicationRef.attachView(backdropCmptRef.hostView);\n\t\tcontainerEl.appendChild(backdropCmptRef.location.nativeElement);\n\t\treturn backdropCmptRef;\n\t}\n\n\tprivate _attachWindowComponent(\n\t\tcontainerEl: Element,\n\t\t[headerNodes, bodyNodes, footerNodes]: Node[][],\n\t\toptions: HubModalOptions\n\t): ComponentRef<HubModalWindow> {\n\t\tconst singleContent =\n\t\t\t!options.headerSelector && !options.footerSelector;\n\t\tlet windowCmptRef = createComponent(HubModalWindow, {\n\t\t\tenvironmentInjector: this._applicationRef.injector,\n\t\t\telementInjector: this._injector,\n\t\t\tprojectableNodes: singleContent\n\t\t\t\t? [bodyNodes]\n\t\t\t\t: [[], headerNodes, bodyNodes, footerNodes]\n\t\t});\n\n\t\tObject.assign(windowCmptRef.instance, { singleContent });\n\n\t\tthis._applicationRef.attachView(windowCmptRef.hostView);\n\t\tcontainerEl.appendChild(windowCmptRef.location.nativeElement);\n\t\treturn windowCmptRef;\n\t}\n\n\tprivate _getContentRef(\n\t\tcontentInjector: Injector,\n\t\tenvironmentInjector: EnvironmentInjector,\n\t\tcontent: Type<any> | TemplateRef<any> | string,\n\t\tactiveModal: HubActiveModal,\n\t\toptions: HubModalOptions\n\t): ContentRef {\n\t\tif (!content) {\n\t\t\treturn new ContentRef([]);\n\t\t} else if (content instanceof TemplateRef) {\n\t\t\treturn this._createFromTemplateRef(content, activeModal, options);\n\t\t} else if (isString(content)) {\n\t\t\treturn this._createFromString(content);\n\t\t} else {\n\t\t\treturn this._createFromComponent(\n\t\t\t\tcontentInjector,\n\t\t\t\tenvironmentInjector,\n\t\t\t\tcontent,\n\t\t\t\tactiveModal,\n\t\t\t\toptions\n\t\t\t);\n\t\t}\n\t}\n\n\tprivate _createFromTemplateRef(\n\t\ttemplateRef: TemplateRef<any>,\n\t\tactiveModal: HubActiveModal,\n\t\toptions: HubModalOptions\n\t): ContentRef {\n\t\tconst context = {\n\t\t\t$implicit: activeModal,\n\t\t\tclose(result) {\n\t\t\t\tactiveModal.close(result);\n\t\t\t},\n\t\t\tdismiss(reason) {\n\t\t\t\tactiveModal.dismiss(reason);\n\t\t\t}\n\t\t};\n\t\tconst viewRef = templateRef.createEmbeddedView(context);\n\t\tthis._applicationRef.attachView(viewRef);\n\n\t\tconst containerNode = document.createElement('ng-container');\n\t\tcontainerNode.append(...viewRef.rootNodes);\n\n\t\tthis._addDismissEventListener(containerNode, context as any, options);\n\n\t\treturn new ContentRef(\n\t\t\t[\n\t\t\t\toptions.headerSelector\n\t\t\t\t\t? extractAndRemoveNodesBySelector(\n\t\t\t\t\t\t\tcontainerNode,\n\t\t\t\t\t\t\toptions.headerSelector\n\t\t\t\t\t  )\n\t\t\t\t\t: [],\n\t\t\t\tcontainerNode.childNodes as any,\n\t\t\t\toptions.footerSelector\n\t\t\t\t\t? extractAndRemoveNodesBySelector(\n\t\t\t\t\t\t\tcontainerNode,\n\t\t\t\t\t\t\toptions.footerSelector\n\t\t\t\t\t  )\n\t\t\t\t\t: []\n\t\t\t],\n\t\t\tviewRef\n\t\t);\n\t}\n\n\tprivate _createFromString(content: string): ContentRef {\n\t\tconst component = this._document.createTextNode(`${content}`);\n\t\treturn new ContentRef([[component]]);\n\t}\n\n\tprivate _createFromComponent(\n\t\tcontentInjector: Injector,\n\t\tenvironmentInjector: EnvironmentInjector,\n\t\tcomponentType: Type<any>,\n\t\tcontext: HubActiveModal,\n\t\toptions: HubModalOptions\n\t): ContentRef {\n\t\tconst elementInjector = Injector.create({\n\t\t\tproviders: [{ provide: HubActiveModal, useValue: context }],\n\t\t\tparent: contentInjector\n\t\t});\n\t\tconst componentRef = createComponent(componentType, {\n\t\t\tenvironmentInjector,\n\t\t\telementInjector\n\t\t});\n\t\tconst componentNativeEl: HTMLElement =\n\t\t\tcomponentRef.location.nativeElement;\n\t\tif (options.scrollable) {\n\t\t\tcomponentNativeEl.classList.add('component-host-scrollable');\n\t\t}\n\t\tthis._applicationRef.attachView(componentRef.hostView);\n\n\t\tthis._addDismissEventListener(componentNativeEl, context, options);\n\n\t\t// FIXME: we should here get rid of the component nativeElement\n\t\t// and use `[Array.from(componentNativeEl.childNodes)]` instead and remove the above CSS class.\n\t\treturn new ContentRef(\n\t\t\t[\n\t\t\t\toptions.headerSelector\n\t\t\t\t\t? extractAndRemoveNodesBySelector(\n\t\t\t\t\t\t\tcomponentNativeEl,\n\t\t\t\t\t\t\toptions.headerSelector\n\t\t\t\t\t  )\n\t\t\t\t\t: [],\n\t\t\t\tcomponentNativeEl.childNodes as any,\n\t\t\t\toptions.footerSelector\n\t\t\t\t\t? extractAndRemoveNodesBySelector(\n\t\t\t\t\t\t\tcomponentNativeEl,\n\t\t\t\t\t\t\toptions.footerSelector\n\t\t\t\t\t  )\n\t\t\t\t\t: []\n\t\t\t],\n\t\t\tcomponentRef.hostView,\n\t\t\tcomponentRef\n\t\t);\n\t}\n\n\tprivate _setAriaHidden(element: Element) {\n\t\tconst parent = element.parentElement;\n\t\tif (parent && element !== this._document.body) {\n\t\t\tArray.from(parent.children).forEach((sibling) => {\n\t\t\t\tif (sibling !== element && sibling.nodeName !== 'SCRIPT') {\n\t\t\t\t\tthis._ariaHiddenValues.set(\n\t\t\t\t\t\tsibling,\n\t\t\t\t\t\tsibling.getAttribute('aria-hidden')\n\t\t\t\t\t);\n\t\t\t\t\tsibling.setAttribute('aria-hidden', 'true');\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tthis._setAriaHidden(parent);\n\t\t}\n\t}\n\n\tprivate _revertAriaHidden() {\n\t\tthis._ariaHiddenValues.forEach((value, element) => {\n\t\t\tif (value) {\n\t\t\t\telement.setAttribute('aria-hidden', value);\n\t\t\t} else {\n\t\t\t\telement.removeAttribute('aria-hidden');\n\t\t\t}\n\t\t});\n\t\tthis._ariaHiddenValues.clear();\n\t}\n\n\tprivate _registerModalRef(hubModalRef: HubModalRef) {\n\t\tconst unregisterModalRef = () => {\n\t\t\tconst index = this._modalRefs.indexOf(hubModalRef);\n\t\t\tif (index > -1) {\n\t\t\t\tthis._modalRefs.splice(index, 1);\n\t\t\t\tthis._activeInstances.emit(this._modalRefs);\n\t\t\t}\n\t\t};\n\t\tthis._modalRefs.push(hubModalRef);\n\t\tthis._activeInstances.emit(this._modalRefs);\n\t\thubModalRef.result.then(unregisterModalRef, unregisterModalRef);\n\t}\n\n\tprivate _registerWindowCmpt(hubWindowCmpt: ComponentRef<HubModalWindow>) {\n\t\tthis._windowCmpts.push(hubWindowCmpt);\n\t\tthis._activeWindowCmptHasChanged.next();\n\n\t\thubWindowCmpt.onDestroy(() => {\n\t\t\tconst index = this._windowCmpts.indexOf(hubWindowCmpt);\n\t\t\tif (index > -1) {\n\t\t\t\tthis._windowCmpts.splice(index, 1);\n\t\t\t\tthis._activeWindowCmptHasChanged.next();\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Attaches click event listeners to elements within a container based on a specified dismiss selector to dismiss a modal.\n\t *\n\t * @param {HTMLElement} container - The `container` parameter is an HTMLElement that represents the DOM element which contains the\n\t * modal content.\n\t * @param {HubActiveModal} context - The `context` parameter in the `_addDismissEventListener` function refers to the active modal\n\t * instance that is being displayed. It is used to call the `dismiss` method on the modal instance when a dismissible element is\n\t * clicked.\n\t * @param {HubModalOptions} options - The `options` parameter is an object that contains configuration options for the modal. It\n\t * may include properties such as `dismissSelector`, which is used to specify a CSS selector for elements that, when clicked, will\n\t * dismiss the modal by calling the `dismiss` method on the `context` object.\n\t */\n\tprivate _addDismissEventListener(\n\t\tcontainer: HTMLElement,\n\t\tcontext: HubActiveModal,\n\t\toptions: HubModalOptions\n\t) {\n\t\tif (options.dismissSelector) {\n\t\t\tconst dismissaable: NodeListOf<Element> =\n\t\t\t\tcontainer.querySelectorAll(options.dismissSelector);\n\t\t\tfor (const item of Array.from(dismissaable)) {\n\t\t\t\titem.addEventListener('click', () => context.dismiss());\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Extracts child nodes matching a selector from a container element, removes those nodes from the DOM, and returns them as an array.\n *\n * @param {HTMLElement} container - The `container` parameter in the `extractAndRemoveNodesBySelector` function is an HTMLElement\n * that represents the parent element within which we want to search for nodes matching a specific selector and remove them.\n * @param {string} selector - The `selector` parameter in the `extractAndRemoveNodesBySelector` function is a string that\n * represents a CSS selector. This selector is used to query and select specific elements within the `container` HTMLElement.\n *\n * @returns An array of nodes that were extracted from the container element based on the provided selector, and then removes those\n * nodes from the DOM.\n */\nfunction extractAndRemoveNodesBySelector(\n\tcontainer: HTMLElement,\n\tselector: string\n): Array<Node> {\n\tlet containerNodes = container.querySelectorAll(selector);\n\n\tconst nodes = Array.from(containerNodes).reduce((acc, c) => {\n\t\treturn [...acc, ...Array.from(c.childNodes)];\n\t}, [] as Array<Node>);\n\n\t// Selecciona los nodos dentro del contenedor que coincidan con el selector\n\tconst nodesToRemove = container.querySelectorAll<HTMLElement>(selector);\n\n\t// Convertir NodeList a array y eliminar cada nodo del DOM\n\tArray.from(nodesToRemove).forEach((node) => node.remove());\n\treturn nodes;\n}\n"]}