ng-hub-ui-modal 1.0.0

package/esm2022/lib/modal-window.mjs

@@ -0,0 +1,275 @@
+import { DOCUMENT, NgIf } from '@angular/common';
+import { Component, ElementRef, EventEmitter, inject, Input, NgZone, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { fromEvent, Subject, zip } from 'rxjs';
+import { filter, switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { ModalDismissReasons } from './modal-dismiss-reasons';
+import { isString, reflow, getFocusableBoundaryElements, hubRunTransition } from 'ng-hub-ui-utils';
+import * as i0 from "@angular/core";
+export class HubModalWindow {
+    constructor() {
+        this._document = inject(DOCUMENT);
+        this._elRef = inject((ElementRef));
+        this._zone = inject(NgZone);
+        this._closed$ = new Subject();
+        this._elWithFocus = null; // element that is focused prior to modal opening
+        this.backdrop = true;
+        this.keyboard = true;
+        this.dismissEvent = new EventEmitter();
+        this.shown = new Subject();
+        this.hidden = new Subject();
+    }
+    get fullscreenClass() {
+        return this.fullscreen === true
+            ? ' modal-fullscreen'
+            : isString(this.fullscreen)
+                ? ` modal-fullscreen-${this.fullscreen}-down`
+                : '';
+    }
+    dismiss(reason) {
+        this.dismissEvent.emit(reason);
+    }
+    ngOnInit() {
+        this._elWithFocus = this._document.activeElement;
+        this._zone.onStable
+            .asObservable()
+            .pipe(take(1))
+            .subscribe(() => {
+            this._show();
+        });
+    }
+    ngOnDestroy() {
+        this._disableEventHandling();
+    }
+    hide() {
+        const { nativeElement } = this._elRef;
+        const context = {
+            animation: this.animation,
+            runningTransition: 'stop'
+        };
+        const windowTransition$ = hubRunTransition(this._zone, nativeElement, () => nativeElement.classList.remove('show'), context);
+        const dialogTransition$ = hubRunTransition(this._zone, this._dialogEl.nativeElement, () => { }, context);
+        const transitions$ = zip(windowTransition$, dialogTransition$);
+        transitions$.subscribe(() => {
+            this.hidden.next();
+            this.hidden.complete();
+        });
+        this._disableEventHandling();
+        this._restoreFocus();
+        return transitions$;
+    }
+    _show() {
+        const context = {
+            animation: this.animation,
+            runningTransition: 'continue'
+        };
+        const windowTransition$ = hubRunTransition(this._zone, this._elRef.nativeElement, (element, animation) => {
+            if (animation) {
+                reflow(element);
+            }
+            element.classList.add('show');
+        }, context);
+        const dialogTransition$ = hubRunTransition(this._zone, this._dialogEl.nativeElement, () => { }, context);
+        zip(windowTransition$, dialogTransition$).subscribe(() => {
+            this.shown.next();
+            this.shown.complete();
+        });
+        this._enableEventHandling();
+        this._setFocus();
+    }
+    _enableEventHandling() {
+        const { nativeElement } = this._elRef;
+        this._zone.runOutsideAngular(() => {
+            fromEvent(nativeElement, 'keydown')
+                .pipe(takeUntil(this._closed$), filter((e) => e.key === 'Escape'))
+                .subscribe((event) => {
+                if (this.keyboard) {
+                    requestAnimationFrame(() => {
+                        if (!event.defaultPrevented) {
+                            this._zone.run(() => this.dismiss(ModalDismissReasons.ESC));
+                        }
+                    });
+                }
+                else if (this.backdrop === 'static') {
+                    this._bumpBackdrop();
+                }
+            });
+            // We're listening to 'mousedown' and 'mouseup' to prevent modal from closing when pressing the mouse
+            // inside the modal dialog and releasing it outside
+            let preventClose = false;
+            fromEvent(this._dialogEl.nativeElement, 'mousedown')
+                .pipe(takeUntil(this._closed$), tap(() => (preventClose = false)), switchMap(() => fromEvent(nativeElement, 'mouseup').pipe(takeUntil(this._closed$), take(1))), filter(({ target }) => nativeElement === target))
+                .subscribe(() => {
+                preventClose = true;
+            });
+            // We're listening to 'click' to dismiss modal on modal window click, except when:
+            // 1. clicking on modal dialog itself
+            // 2. closing was prevented by mousedown/up handlers
+            // 3. clicking on scrollbar when the viewport is too small and modal doesn't fit (click is not triggered at all)
+            fromEvent(nativeElement, 'click')
+                .pipe(takeUntil(this._closed$))
+                .subscribe(({ target }) => {
+                if (nativeElement === target) {
+                    if (this.backdrop === 'static') {
+                        this._bumpBackdrop();
+                    }
+                    else if (this.backdrop === true && !preventClose) {
+                        this._zone.run(() => this.dismiss(ModalDismissReasons.BACKDROP_CLICK));
+                    }
+                }
+                preventClose = false;
+            });
+        });
+    }
+    _disableEventHandling() {
+        this._closed$.next();
+    }
+    _setFocus() {
+        const { nativeElement } = this._elRef;
+        if (!nativeElement.contains(document.activeElement)) {
+            const autoFocusable = nativeElement.querySelector(`[hubAutofocus]`);
+            const firstFocusable = getFocusableBoundaryElements(nativeElement)[0];
+            const elementToFocus = autoFocusable || firstFocusable || nativeElement;
+            elementToFocus.focus();
+        }
+    }
+    _restoreFocus() {
+        const body = this._document.body;
+        const elWithFocus = this._elWithFocus;
+        let elementToFocus;
+        if (elWithFocus && elWithFocus['focus'] && body.contains(elWithFocus)) {
+            elementToFocus = elWithFocus;
+        }
+        else {
+            elementToFocus = body;
+        }
+        this._zone.runOutsideAngular(() => {
+            setTimeout(() => elementToFocus.focus());
+            this._elWithFocus = null;
+        });
+    }
+    _bumpBackdrop() {
+        if (this.backdrop === 'static') {
+            hubRunTransition(this._zone, this._elRef.nativeElement, ({ classList }) => {
+                classList.add('modal-static');
+                return () => classList.remove('modal-static');
+            }, { animation: this.animation, runningTransition: 'continue' });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModalWindow, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.5", type: HubModalWindow, isStandalone: true, selector: "hub-modal-window", inputs: { animation: "animation", ariaLabelledBy: "ariaLabelledBy", ariaDescribedBy: "ariaDescribedBy", backdrop: "backdrop", centered: "centered", fullscreen: "fullscreen", keyboard: "keyboard", scrollable: "scrollable", size: "size", windowClass: "windowClass", modalDialogClass: "modalDialogClass" }, outputs: { dismissEvent: "dismiss" }, host: { attributes: { "role": "dialog", "tabindex": "-1" }, properties: { "class": "\"modal d-block\" + (windowClass ? \" \" + windowClass : \"\")", "class.fade": "animation", "attr.aria-modal": "true", "attr.aria-labelledby": "ariaLabelledBy", "attr.aria-describedby": "ariaDescribedBy" } }, viewQueries: [{ propertyName: "_dialogEl", first: true, predicate: ["dialog"], descendants: true, static: true }], ngImport: i0, template: `
+		<div
+			#dialog
+			[class]="
+				'modal-dialog' +
+				(size ? ' modal-' + size : '') +
+				(centered ? ' modal-dialog-centered' : '') +
+				fullscreenClass +
+				(scrollable ? ' modal-dialog-scrollable' : '') +
+				(modalDialogClass ? ' ' + modalDialogClass : '')
+			"
+			role="document"
+		>
+			<div class="modal-content">
+				<ng-container *ngIf="singleContent; else multipleContent">
+					<ng-content></ng-content>
+				</ng-container>
+				<ng-template #multipleContent>
+					<div class="modal-header">
+						<ng-content />
+						<button
+							type="button"
+							class="btn-close"
+							data-bs-dismiss="modal"
+							aria-label="Close"
+							(click)="dismiss(null)"
+						></button>
+					</div>
+					<div class="modal-body">
+						<ng-content />
+					</div>
+					<div class="modal-footer">
+						<ng-content />
+					</div>
+				</ng-template>
+			</div>
+		</div>
+	`, isInline: true, styles: ["hub-modal-window .component-host-scrollable{display:flex;flex-direction:column;overflow:hidden}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModalWindow, decorators: [{
+            type: Component,
+            args: [{ selector: 'hub-modal-window', standalone: true, imports: [NgIf], host: {
+                        '[class]': '"modal d-block" + (windowClass ? " " + windowClass : "")',
+                        '[class.fade]': 'animation',
+                        role: 'dialog',
+                        tabindex: '-1',
+                        '[attr.aria-modal]': 'true',
+                        '[attr.aria-labelledby]': 'ariaLabelledBy',
+                        '[attr.aria-describedby]': 'ariaDescribedBy'
+                    }, template: `
+		<div
+			#dialog
+			[class]="
+				'modal-dialog' +
+				(size ? ' modal-' + size : '') +
+				(centered ? ' modal-dialog-centered' : '') +
+				fullscreenClass +
+				(scrollable ? ' modal-dialog-scrollable' : '') +
+				(modalDialogClass ? ' ' + modalDialogClass : '')
+			"
+			role="document"
+		>
+			<div class="modal-content">
+				<ng-container *ngIf="singleContent; else multipleContent">
+					<ng-content></ng-content>
+				</ng-container>
+				<ng-template #multipleContent>
+					<div class="modal-header">
+						<ng-content />
+						<button
+							type="button"
+							class="btn-close"
+							data-bs-dismiss="modal"
+							aria-label="Close"
+							(click)="dismiss(null)"
+						></button>
+					</div>
+					<div class="modal-body">
+						<ng-content />
+					</div>
+					<div class="modal-footer">
+						<ng-content />
+					</div>
+				</ng-template>
+			</div>
+		</div>
+	`, encapsulation: ViewEncapsulation.None, styles: ["hub-modal-window .component-host-scrollable{display:flex;flex-direction:column;overflow:hidden}\n"] }]
+        }], propDecorators: { _dialogEl: [{
+                type: ViewChild,
+                args: ['dialog', { static: true }]
+            }], animation: [{
+                type: Input
+            }], ariaLabelledBy: [{
+                type: Input
+            }], ariaDescribedBy: [{
+                type: Input
+            }], backdrop: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], fullscreen: [{
+                type: Input
+            }], keyboard: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], windowClass: [{
+                type: Input
+            }], modalDialogClass: [{
+                type: Input
+            }], dismissEvent: [{
+                type: Output,
+                args: ['dismiss']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-window.js","sourceRoot":"","sources":["../../../../projects/modal/src/lib/modal-window.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT, NgIf } from '@angular/common';\nimport {\n\tComponent,\n\tElementRef,\n\tEventEmitter,\n\tinject,\n\tInput,\n\tNgZone,\n\tOnDestroy,\n\tOnInit,\n\tOutput,\n\tViewChild,\n\tViewEncapsulation\n} from '@angular/core';\nimport { fromEvent, Observable, Subject, zip } from 'rxjs';\nimport { filter, switchMap, take, takeUntil, tap } from 'rxjs/operators';\nimport { ModalDismissReasons } from './modal-dismiss-reasons';\nimport {\n\tisString,\n\treflow,\n\tgetFocusableBoundaryElements,\n\thubRunTransition,\n\tTransitionOptions\n} from 'ng-hub-ui-utils';\n\n@Component({\n\tselector: 'hub-modal-window',\n\tstandalone: true,\n\timports: [NgIf],\n\thost: {\n\t\t'[class]': '\"modal d-block\" + (windowClass ? \" \" + windowClass : \"\")',\n\t\t'[class.fade]': 'animation',\n\t\trole: 'dialog',\n\t\ttabindex: '-1',\n\t\t'[attr.aria-modal]': 'true',\n\t\t'[attr.aria-labelledby]': 'ariaLabelledBy',\n\t\t'[attr.aria-describedby]': 'ariaDescribedBy'\n\t},\n\ttemplate: `\n\t\t<div\n\t\t\t#dialog\n\t\t\t[class]=\"\n\t\t\t\t'modal-dialog' +\n\t\t\t\t(size ? ' modal-' + size : '') +\n\t\t\t\t(centered ? ' modal-dialog-centered' : '') +\n\t\t\t\tfullscreenClass +\n\t\t\t\t(scrollable ? ' modal-dialog-scrollable' : '') +\n\t\t\t\t(modalDialogClass ? ' ' + modalDialogClass : '')\n\t\t\t\"\n\t\t\trole=\"document\"\n\t\t>\n\t\t\t<div class=\"modal-content\">\n\t\t\t\t<ng-container *ngIf=\"singleContent; else multipleContent\">\n\t\t\t\t\t<ng-content></ng-content>\n\t\t\t\t</ng-container>\n\t\t\t\t<ng-template #multipleContent>\n\t\t\t\t\t<div class=\"modal-header\">\n\t\t\t\t\t\t<ng-content />\n\t\t\t\t\t\t<button\n\t\t\t\t\t\t\ttype=\"button\"\n\t\t\t\t\t\t\tclass=\"btn-close\"\n\t\t\t\t\t\t\tdata-bs-dismiss=\"modal\"\n\t\t\t\t\t\t\taria-label=\"Close\"\n\t\t\t\t\t\t\t(click)=\"dismiss(null)\"\n\t\t\t\t\t\t></button>\n\t\t\t\t\t</div>\n\t\t\t\t\t<div class=\"modal-body\">\n\t\t\t\t\t\t<ng-content />\n\t\t\t\t\t</div>\n\t\t\t\t\t<div class=\"modal-footer\">\n\t\t\t\t\t\t<ng-content />\n\t\t\t\t\t</div>\n\t\t\t\t</ng-template>\n\t\t\t</div>\n\t\t</div>\n\t`,\n\tencapsulation: ViewEncapsulation.None,\n\tstyleUrl: './modal.scss'\n})\nexport class HubModalWindow implements OnInit, OnDestroy {\n\tprivate _document = inject(DOCUMENT);\n\tprivate _elRef = inject(ElementRef<HTMLElement>);\n\tprivate _zone = inject(NgZone);\n\n\tprivate _closed$ = new Subject<void>();\n\tprivate _elWithFocus: Element | null = null; // element that is focused prior to modal opening\n\n\t@ViewChild('dialog', { static: true })\n\tprivate _dialogEl: ElementRef<HTMLElement>;\n\n\t@Input() animation: boolean;\n\t@Input() ariaLabelledBy: string;\n\t@Input() ariaDescribedBy: string;\n\t@Input() backdrop: boolean | string = true;\n\t@Input() centered: string;\n\t@Input() fullscreen: string | boolean;\n\t@Input() keyboard = true;\n\t@Input() scrollable: string;\n\t@Input() size: string;\n\t@Input() windowClass: string;\n\t@Input() modalDialogClass: string;\n\n\tsingleContent!: boolean;\n\n\t@Output('dismiss') dismissEvent = new EventEmitter();\n\n\tshown = new Subject<void>();\n\thidden = new Subject<void>();\n\n\tget fullscreenClass(): string {\n\t\treturn this.fullscreen === true\n\t\t\t? ' modal-fullscreen'\n\t\t\t: isString(this.fullscreen)\n\t\t\t? ` modal-fullscreen-${this.fullscreen}-down`\n\t\t\t: '';\n\t}\n\n\tdismiss(reason): void {\n\t\tthis.dismissEvent.emit(reason);\n\t}\n\n\tngOnInit() {\n\t\tthis._elWithFocus = this._document.activeElement;\n\t\tthis._zone.onStable\n\t\t\t.asObservable()\n\t\t\t.pipe(take(1))\n\t\t\t.subscribe(() => {\n\t\t\t\tthis._show();\n\t\t\t});\n\t}\n\n\tngOnDestroy() {\n\t\tthis._disableEventHandling();\n\t}\n\n\thide(): Observable<any> {\n\t\tconst { nativeElement } = this._elRef;\n\t\tconst context: TransitionOptions<any> = {\n\t\t\tanimation: this.animation,\n\t\t\trunningTransition: 'stop'\n\t\t};\n\n\t\tconst windowTransition$ = hubRunTransition(\n\t\t\tthis._zone,\n\t\t\tnativeElement,\n\t\t\t() => nativeElement.classList.remove('show'),\n\t\t\tcontext\n\t\t);\n\t\tconst dialogTransition$ = hubRunTransition(\n\t\t\tthis._zone,\n\t\t\tthis._dialogEl.nativeElement,\n\t\t\t() => {},\n\t\t\tcontext\n\t\t);\n\n\t\tconst transitions$ = zip(windowTransition$, dialogTransition$);\n\t\ttransitions$.subscribe(() => {\n\t\t\tthis.hidden.next();\n\t\t\tthis.hidden.complete();\n\t\t});\n\n\t\tthis._disableEventHandling();\n\t\tthis._restoreFocus();\n\n\t\treturn transitions$;\n\t}\n\n\tprivate _show() {\n\t\tconst context: TransitionOptions<any> = {\n\t\t\tanimation: this.animation,\n\t\t\trunningTransition: 'continue'\n\t\t};\n\n\t\tconst windowTransition$ = hubRunTransition(\n\t\t\tthis._zone,\n\t\t\tthis._elRef.nativeElement,\n\t\t\t(element: HTMLElement, animation: boolean) => {\n\t\t\t\tif (animation) {\n\t\t\t\t\treflow(element);\n\t\t\t\t}\n\t\t\t\telement.classList.add('show');\n\t\t\t},\n\t\t\tcontext\n\t\t);\n\t\tconst dialogTransition$ = hubRunTransition(\n\t\t\tthis._zone,\n\t\t\tthis._dialogEl.nativeElement,\n\t\t\t() => {},\n\t\t\tcontext\n\t\t);\n\n\t\tzip(windowTransition$, dialogTransition$).subscribe(() => {\n\t\t\tthis.shown.next();\n\t\t\tthis.shown.complete();\n\t\t});\n\n\t\tthis._enableEventHandling();\n\t\tthis._setFocus();\n\t}\n\n\tprivate _enableEventHandling() {\n\t\tconst { nativeElement } = this._elRef;\n\t\tthis._zone.runOutsideAngular(() => {\n\t\t\tfromEvent<KeyboardEvent>(nativeElement, 'keydown')\n\t\t\t\t.pipe(\n\t\t\t\t\ttakeUntil(this._closed$),\n\t\t\t\t\tfilter((e) => e.key === 'Escape')\n\t\t\t\t)\n\t\t\t\t.subscribe((event) => {\n\t\t\t\t\tif (this.keyboard) {\n\t\t\t\t\t\trequestAnimationFrame(() => {\n\t\t\t\t\t\t\tif (!event.defaultPrevented) {\n\t\t\t\t\t\t\t\tthis._zone.run(() =>\n\t\t\t\t\t\t\t\t\tthis.dismiss(ModalDismissReasons.ESC)\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t} else if (this.backdrop === 'static') {\n\t\t\t\t\t\tthis._bumpBackdrop();\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t// We're listening to 'mousedown' and 'mouseup' to prevent modal from closing when pressing the mouse\n\t\t\t// inside the modal dialog and releasing it outside\n\t\t\tlet preventClose = false;\n\t\t\tfromEvent<MouseEvent>(this._dialogEl.nativeElement, 'mousedown')\n\t\t\t\t.pipe(\n\t\t\t\t\ttakeUntil(this._closed$),\n\t\t\t\t\ttap(() => (preventClose = false)),\n\t\t\t\t\tswitchMap(() =>\n\t\t\t\t\t\tfromEvent<MouseEvent>(nativeElement, 'mouseup').pipe(\n\t\t\t\t\t\t\ttakeUntil(this._closed$),\n\t\t\t\t\t\t\ttake(1)\n\t\t\t\t\t\t)\n\t\t\t\t\t),\n\t\t\t\t\tfilter(({ target }) => nativeElement === target)\n\t\t\t\t)\n\t\t\t\t.subscribe(() => {\n\t\t\t\t\tpreventClose = true;\n\t\t\t\t});\n\n\t\t\t// We're listening to 'click' to dismiss modal on modal window click, except when:\n\t\t\t// 1. clicking on modal dialog itself\n\t\t\t// 2. closing was prevented by mousedown/up handlers\n\t\t\t// 3. clicking on scrollbar when the viewport is too small and modal doesn't fit (click is not triggered at all)\n\t\t\tfromEvent<MouseEvent>(nativeElement, 'click')\n\t\t\t\t.pipe(takeUntil(this._closed$))\n\t\t\t\t.subscribe(({ target }) => {\n\t\t\t\t\tif (nativeElement === target) {\n\t\t\t\t\t\tif (this.backdrop === 'static') {\n\t\t\t\t\t\t\tthis._bumpBackdrop();\n\t\t\t\t\t\t} else if (this.backdrop === true && !preventClose) {\n\t\t\t\t\t\t\tthis._zone.run(() =>\n\t\t\t\t\t\t\t\tthis.dismiss(ModalDismissReasons.BACKDROP_CLICK)\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tpreventClose = false;\n\t\t\t\t});\n\t\t});\n\t}\n\n\tprivate _disableEventHandling() {\n\t\tthis._closed$.next();\n\t}\n\n\tprivate _setFocus() {\n\t\tconst { nativeElement } = this._elRef;\n\t\tif (!nativeElement.contains(document.activeElement)) {\n\t\t\tconst autoFocusable = nativeElement.querySelector(\n\t\t\t\t`[hubAutofocus]`\n\t\t\t) as HTMLElement;\n\t\t\tconst firstFocusable =\n\t\t\t\tgetFocusableBoundaryElements(nativeElement)[0];\n\n\t\t\tconst elementToFocus =\n\t\t\t\tautoFocusable || firstFocusable || nativeElement;\n\t\t\telementToFocus.focus();\n\t\t}\n\t}\n\n\tprivate _restoreFocus() {\n\t\tconst body = this._document.body;\n\t\tconst elWithFocus = this._elWithFocus;\n\n\t\tlet elementToFocus;\n\t\tif (elWithFocus && elWithFocus['focus'] && body.contains(elWithFocus)) {\n\t\t\telementToFocus = elWithFocus;\n\t\t} else {\n\t\t\telementToFocus = body;\n\t\t}\n\t\tthis._zone.runOutsideAngular(() => {\n\t\t\tsetTimeout(() => elementToFocus.focus());\n\t\t\tthis._elWithFocus = null;\n\t\t});\n\t}\n\n\tprivate _bumpBackdrop() {\n\t\tif (this.backdrop === 'static') {\n\t\t\thubRunTransition(\n\t\t\t\tthis._zone,\n\t\t\t\tthis._elRef.nativeElement,\n\t\t\t\t({ classList }) => {\n\t\t\t\t\tclassList.add('modal-static');\n\t\t\t\t\treturn () => classList.remove('modal-static');\n\t\t\t\t},\n\t\t\t\t{ animation: this.animation, runningTransition: 'continue' }\n\t\t\t);\n\t\t}\n\t}\n}\n"]}

package/esm2022/lib/modal.mjs

@@ -0,0 +1,59 @@
+import { inject, Injectable, Injector } from '@angular/core';
+import { HubModalConfig } from './modal-config';
+import { HubModalStack } from './modal-stack';
+import * as i0 from "@angular/core";
+/**
+ * A service for opening modal windows.
+ *
+ * Creating a modal is straightforward: create a component or a template and pass it as an argument to
+ * the `.open()` method.
+ */
+export class HubModal {
+    constructor() {
+        this._injector = inject(Injector);
+        this._modalStack = inject(HubModalStack);
+        this._config = inject(HubModalConfig);
+    }
+    /**
+     * Opens a new modal window with the specified content and supplied options.
+     *
+     * Content can be provided as a `TemplateRef` or a component type. If you pass a component type as content,
+     * then instances of those components can be injected with an instance of the `HubActiveModal` class. You can then
+     * use `HubActiveModal` methods to close / dismiss modals from "inside" of your component.
+     *
+     * Also see the [`HubModalOptions`](#/components/modal/api#HubModalOptions) for the list of supported options.
+     */
+    open(content, options = {}) {
+        const combinedOptions = { ...this._config, animation: this._config.animation, ...options };
+        return this._modalStack.open(this._injector, content, combinedOptions);
+    }
+    /**
+     * Returns an observable that holds the active modal instances.
+     */
+    get activeInstances() {
+        return this._modalStack.activeInstances;
+    }
+    /**
+     * Dismisses all currently displayed modal windows with the supplied reason.
+     *
+     * @since 3.1.0
+     */
+    dismissAll(reason) {
+        this._modalStack.dismissAll(reason);
+    }
+    /**
+     * Indicates if there are currently any open modal windows in the application.
+     *
+     * @since 3.3.0
+     */
+    hasOpenModals() {
+        return this._modalStack.hasOpenModals();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModal, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModal, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubModal, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ng-hub-ui-modal.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctaHViLXVpLW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbW9kYWwvc3JjL25nLWh1Yi11aS1tb2RhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of modal
+ */
+export * from './lib/modal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL21vZGFsL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG1vZGFsXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kYWwnO1xuIl19