@spartan-ng/brain 0.0.1-alpha.373 → 0.0.1-alpha.379

package/fesm2022/spartan-ng-brain-dialog.mjs

@@ -0,0 +1,617 @@
+import * as i0 from '@angular/core';
+import { inject, Directive, Input, RendererFactory2, Injector, signal, computed, runInInjectionContext, effect, Injectable, ViewContainerRef, EventEmitter, booleanAttribute, numberAttribute, Component, ChangeDetectionStrategy, ViewEncapsulation, Output, TemplateRef, input, NgModule } from '@angular/core';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Subject, take, takeUntil, filter } from 'rxjs';
+import { provideExposesStateProviderExisting, provideCustomClassSettableExisting } from '@spartan-ng/ui-core';
+import { OverlayPositionBuilder, ScrollStrategyOptions } from '@angular/cdk/overlay';
+import { DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
+
+// brn-dialog-utils.ts
+const cssClassesToArray = (classes, defaultClass = '') => {
+    if (typeof classes === 'string') {
+        const splitClasses = classes.trim().split(' ');
+        if (splitClasses.length === 0) {
+            return [defaultClass];
+        }
+        return splitClasses;
+    }
+    return classes ?? [];
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class BrnDialogRef {
+    _cdkDialogRef;
+    _open;
+    state;
+    dialogId;
+    _options;
+    _closing$ = new Subject();
+    closing$ = this._closing$.asObservable();
+    closed$;
+    _previousTimeout;
+    get open() {
+        return this.state() === 'open';
+    }
+    constructor(_cdkDialogRef, _open, state, dialogId, _options) {
+        this._cdkDialogRef = _cdkDialogRef;
+        this._open = _open;
+        this.state = state;
+        this.dialogId = dialogId;
+        this._options = _options;
+        this.closed$ = this._cdkDialogRef.closed.pipe(take(1));
+    }
+    close(result, delay = this._options?.closeDelay ?? 0) {
+        if (!this.open || this._options?.disableClose)
+            return;
+        this._closing$.next();
+        this._open.set(false);
+        if (this._previousTimeout) {
+            clearTimeout(this._previousTimeout);
+        }
+        this._previousTimeout = setTimeout(() => {
+            this._cdkDialogRef.close(result);
+        }, delay);
+    }
+    setPanelClass(paneClass) {
+        this._cdkDialogRef.config.panelClass = cssClassesToArray(paneClass);
+    }
+    setOverlayClass(overlayClass) {
+        this._cdkDialogRef.config.backdropClass = cssClassesToArray(overlayClass);
+    }
+    setAriaDescribedBy(ariaDescribedBy) {
+        this._cdkDialogRef.config.ariaDescribedBy = ariaDescribedBy;
+    }
+    setAriaLabelledBy(ariaLabelledBy) {
+        this._cdkDialogRef.config.ariaLabelledBy = ariaLabelledBy;
+    }
+    setAriaLabel(ariaLabel) {
+        this._cdkDialogRef.config.ariaLabel = ariaLabel;
+    }
+}
+
+class BrnDialogCloseDirective {
+    _brnDialogRef = inject(BrnDialogRef);
+    _delay;
+    set delay(value) {
+        this._delay = coerceNumberProperty(value);
+    }
+    close() {
+        this._brnDialogRef.close(undefined, this._delay);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogCloseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnDialogCloseDirective, isStandalone: true, selector: "button[brnDialogClose]", inputs: { delay: "delay" }, host: { listeners: { "click": "close()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogCloseDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[brnDialogClose]',
+                    standalone: true,
+                    host: {
+                        '(click)': 'close()',
+                    },
+                }]
+        }], propDecorators: { delay: [{
+                type: Input
+            }] } });
+
+const DEFAULT_BRN_DIALOG_OPTIONS = {
+    role: 'dialog',
+    attachPositions: [],
+    attachTo: null,
+    autoFocus: 'first-tabbable',
+    backdropClass: '',
+    closeDelay: 0,
+    closeOnBackdropClick: true,
+    closeOnOutsidePointerEvents: false,
+    hasBackdrop: true,
+    panelClass: '',
+    positionStrategy: null,
+    restoreFocus: true,
+    scrollStrategy: null,
+    disableClose: false,
+    ariaLabel: undefined,
+    ariaModal: true,
+};
+
+let dialogSequence = 0;
+/** @deprecated `injectBrnDialogCtx` will no longer be supported once components are stable. Use `injectBrnDialogContext` instead.  */
+const injectBrnDialogCtx = () => {
+    return inject(DIALOG_DATA);
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const injectBrnDialogContext = (options = {}) => {
+    return inject(DIALOG_DATA, options);
+};
+class BrnDialogService {
+    _cdkDialog = inject(Dialog);
+    _rendererFactory = inject(RendererFactory2);
+    _renderer = this._rendererFactory.createRenderer(null, null);
+    _positionBuilder = inject(OverlayPositionBuilder);
+    _sso = inject(ScrollStrategyOptions);
+    _injector = inject(Injector);
+    open(content, vcr, context, options) {
+        if (options?.id && this._cdkDialog.getDialogById(options.id)) {
+            throw new Error(`Dialog with ID: ${options.id} already exists`);
+        }
+        const positionStrategy = options?.positionStrategy ??
+            (options?.attachTo && options?.attachPositions && options?.attachPositions?.length > 0
+                ? this._positionBuilder?.flexibleConnectedTo(options.attachTo).withPositions(options.attachPositions ?? [])
+                : this._positionBuilder.global().centerHorizontally().centerVertically());
+        let brnDialogRef;
+        let effectRef;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const contextOrData = {
+            ...context,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            close: (result = undefined) => brnDialogRef.close(result, options?.closeDelay),
+        };
+        const destroyed$ = new Subject();
+        const open = signal(true);
+        const state = computed(() => (open() ? 'open' : 'closed'));
+        const dialogId = dialogSequence++;
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const cdkDialogRef = this._cdkDialog.open(content, {
+            id: options?.id ?? `brn-dialog-${dialogId}`,
+            role: options?.role,
+            viewContainerRef: vcr,
+            templateContext: () => ({
+                $implicit: contextOrData,
+            }),
+            data: contextOrData,
+            hasBackdrop: options?.hasBackdrop,
+            panelClass: cssClassesToArray(options?.panelClass),
+            backdropClass: cssClassesToArray(options?.backdropClass, 'bg-transparent'),
+            positionStrategy,
+            scrollStrategy: options?.scrollStrategy ?? this._sso?.block(),
+            restoreFocus: options?.restoreFocus,
+            disableClose: true,
+            autoFocus: options?.autoFocus ?? 'first-tabbable',
+            ariaDescribedBy: options?.ariaDescribedBy ?? `brn-dialog-description-${dialogId}`,
+            ariaLabelledBy: options?.ariaLabelledBy ?? `brn-dialog-title-${dialogId}`,
+            ariaLabel: options?.ariaLabel,
+            ariaModal: options?.ariaModal,
+            providers: (cdkDialogRef) => {
+                brnDialogRef = new BrnDialogRef(cdkDialogRef, open, state, dialogId, options);
+                runInInjectionContext(this._injector, () => {
+                    effectRef = effect(() => {
+                        if (overlay) {
+                            this._renderer.setAttribute(overlay, 'data-state', state());
+                        }
+                        if (backdrop) {
+                            this._renderer.setAttribute(backdrop, 'data-state', state());
+                        }
+                    });
+                });
+                const providers = [
+                    {
+                        provide: BrnDialogRef,
+                        useValue: brnDialogRef,
+                    },
+                ];
+                if (options?.providers) {
+                    if (typeof options.providers === 'function') {
+                        providers.push(...options.providers());
+                    }
+                    if (Array.isArray(options.providers)) {
+                        providers.push(...options.providers);
+                    }
+                }
+                return providers;
+            },
+        });
+        const overlay = cdkDialogRef.overlayRef.overlayElement;
+        const backdrop = cdkDialogRef.overlayRef.backdropElement;
+        if (options?.closeOnOutsidePointerEvents) {
+            cdkDialogRef.outsidePointerEvents.pipe(takeUntil(destroyed$)).subscribe(() => {
+                brnDialogRef.close(undefined, options?.closeDelay);
+            });
+        }
+        if (options?.closeOnBackdropClick) {
+            cdkDialogRef.backdropClick.pipe(takeUntil(destroyed$)).subscribe(() => {
+                brnDialogRef.close(undefined, options?.closeDelay);
+            });
+        }
+        if (!options?.disableClose) {
+            cdkDialogRef.keydownEvents
+                .pipe(filter((e) => e.key === 'Escape'), takeUntil(destroyed$))
+                .subscribe(() => {
+                brnDialogRef.close(undefined, options?.closeDelay);
+            });
+        }
+        cdkDialogRef.closed.pipe(takeUntil(destroyed$)).subscribe(() => {
+            effectRef?.destroy();
+            destroyed$.next();
+        });
+        return brnDialogRef;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class BrnDialogComponent {
+    _dialogService = inject(BrnDialogService);
+    _vcr = inject(ViewContainerRef);
+    positionBuilder = inject(OverlayPositionBuilder);
+    ssos = inject(ScrollStrategyOptions);
+    _injector = inject(Injector);
+    _context = {};
+    _options = {
+        ...DEFAULT_BRN_DIALOG_OPTIONS,
+    };
+    _contentTemplate;
+    _dialogRef = signal(undefined);
+    _dialogStateEffectRef;
+    state = computed(() => this._dialogRef()?.state() ?? 'closed');
+    closed = new EventEmitter();
+    stateChanged = new EventEmitter();
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    set newState(state) {
+        if (state === 'open') {
+            this.open();
+        }
+        if (state === 'closed') {
+            this.close(this._options.closeDelay);
+        }
+    }
+    set role(role) {
+        this._options.role = role;
+    }
+    set hasBackdrop(hasBackdrop) {
+        this._options.hasBackdrop = hasBackdrop;
+    }
+    set positionStrategy(positionStrategy) {
+        this._options.positionStrategy = positionStrategy;
+    }
+    set scrollStrategy(scrollStrategy) {
+        if (scrollStrategy === 'close') {
+            this._options.scrollStrategy = this.ssos.close();
+        }
+        else if (scrollStrategy === 'reposition') {
+            this._options.scrollStrategy = this.ssos.reposition();
+        }
+        else {
+            this._options.scrollStrategy = scrollStrategy;
+        }
+    }
+    set restoreFocus(restoreFocus) {
+        this._options.restoreFocus = restoreFocus;
+    }
+    set closeOnOutsidePointerEvents(closeOnOutsidePointerEvents) {
+        this._options.closeOnOutsidePointerEvents = closeOnOutsidePointerEvents;
+    }
+    set closeOnBackdropClick(closeOnBackdropClick) {
+        this._options.closeOnBackdropClick = closeOnBackdropClick;
+    }
+    set attachTo(attachTo) {
+        this._options.attachTo = attachTo;
+    }
+    set attachPositions(attachPositions) {
+        this._options.attachPositions = attachPositions;
+    }
+    set autoFocus(autoFocus) {
+        this._options.autoFocus = autoFocus;
+    }
+    set closeDelay(closeDelay) {
+        this._options.closeDelay = closeDelay;
+    }
+    set disableClose(disableClose) {
+        this._options.disableClose = disableClose;
+    }
+    /* eslint-disable-next-line @angular-eslint/no-input-rename */
+    set ariaDescribedBy(ariaDescribedBy) {
+        this.setAriaDescribedBy(ariaDescribedBy);
+    }
+    /* eslint-disable-next-line @angular-eslint/no-input-rename */
+    set ariaLabelledBy(ariaLabelledBy) {
+        this.setAriaLabelledBy(ariaLabelledBy);
+    }
+    set ariaLabel(ariaLabel) {
+        this.setAriaLabel(ariaLabel);
+    }
+    set ariaModal(isModal) {
+        this.setAriaModal(isModal);
+    }
+    open() {
+        if (!this._contentTemplate || this._dialogRef())
+            return;
+        this._dialogStateEffectRef?.destroy();
+        const dialogRef = this._dialogService.open(this._contentTemplate, this._vcr, this._context, this._options);
+        this._dialogRef.set(dialogRef);
+        runInInjectionContext(this._injector, () => {
+            this._dialogStateEffectRef = effect(() => this.stateChanged.emit(dialogRef.state()));
+        });
+        dialogRef.closed$.pipe(take(1)).subscribe((result) => {
+            this._dialogRef.set(undefined);
+            this.closed.emit(result);
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    close(result, delay) {
+        this._dialogRef()?.close(result, delay ?? this._options.closeDelay);
+    }
+    registerTemplate(template) {
+        this._contentTemplate = template;
+    }
+    setOverlayClass(overlayClass) {
+        this._options.backdropClass = overlayClass ?? '';
+        this._dialogRef()?.setOverlayClass(overlayClass);
+    }
+    setPanelClass(panelClass) {
+        this._options.panelClass = panelClass ?? '';
+        this._dialogRef()?.setPanelClass(panelClass);
+    }
+    setContext(context) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        this._context = { ...this._context, ...context };
+    }
+    setAriaDescribedBy(ariaDescribedBy) {
+        this._options = { ...this._options, ariaDescribedBy };
+        this._dialogRef()?.setAriaDescribedBy(ariaDescribedBy);
+    }
+    setAriaLabelledBy(ariaLabelledBy) {
+        this._options = { ...this._options, ariaLabelledBy };
+        this._dialogRef()?.setAriaLabelledBy(ariaLabelledBy);
+    }
+    setAriaLabel(ariaLabel) {
+        this._options = { ...this._options, ariaLabel };
+        this._dialogRef()?.setAriaLabel(ariaLabel);
+    }
+    setAriaModal(ariaModal) {
+        this._options = { ...this._options, ariaModal };
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.5", type: BrnDialogComponent, isStandalone: true, selector: "brn-dialog", inputs: { newState: ["state", "newState"], role: "role", hasBackdrop: ["hasBackdrop", "hasBackdrop", booleanAttribute], positionStrategy: "positionStrategy", scrollStrategy: "scrollStrategy", restoreFocus: "restoreFocus", closeOnOutsidePointerEvents: ["closeOnOutsidePointerEvents", "closeOnOutsidePointerEvents", booleanAttribute], closeOnBackdropClick: ["closeOnBackdropClick", "closeOnBackdropClick", booleanAttribute], attachTo: "attachTo", attachPositions: "attachPositions", autoFocus: "autoFocus", closeDelay: ["closeDelay", "closeDelay", numberAttribute], disableClose: ["disableClose", "disableClose", booleanAttribute], ariaDescribedBy: ["aria-describedby", "ariaDescribedBy"], ariaLabelledBy: ["aria-labelledby", "ariaLabelledBy"], ariaLabel: ["aria-label", "ariaLabel"], ariaModal: ["aria-modal", "ariaModal", booleanAttribute] }, outputs: { closed: "closed", stateChanged: "stateChanged" }, exportAs: ["brnDialog"], ngImport: i0, template: `
+		<ng-content />
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-dialog',
+                    standalone: true,
+                    template: `
+		<ng-content />
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                    exportAs: 'brnDialog',
+                }]
+        }], propDecorators: { closed: [{
+                type: Output
+            }], stateChanged: [{
+                type: Output
+            }], newState: [{
+                type: Input,
+                args: ['state']
+            }], role: [{
+                type: Input
+            }], hasBackdrop: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], positionStrategy: [{
+                type: Input
+            }], scrollStrategy: [{
+                type: Input
+            }], restoreFocus: [{
+                type: Input
+            }], closeOnOutsidePointerEvents: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], closeOnBackdropClick: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], attachTo: [{
+                type: Input
+            }], attachPositions: [{
+                type: Input
+            }], autoFocus: [{
+                type: Input
+            }], closeDelay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], disableClose: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], ariaDescribedBy: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], ariaLabelledBy: [{
+                type: Input,
+                args: ['aria-labelledby']
+            }], ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], ariaModal: [{
+                type: Input,
+                args: [{
+                        alias: 'aria-modal',
+                        transform: booleanAttribute,
+                    }]
+            }] } });
+
+class BrnDialogContentDirective {
+    _brnDialog = inject(BrnDialogComponent, { optional: true });
+    _brnDialogRef = inject(BrnDialogRef, { optional: true });
+    _template = inject(TemplateRef);
+    state = computed(() => this._brnDialog?.state() ?? this._brnDialogRef?.state() ?? 'closed');
+    set class(newClass) {
+        if (!this._brnDialog)
+            return;
+        this._brnDialog.setPanelClass(newClass);
+    }
+    set context(context) {
+        if (!this._brnDialog)
+            return;
+        this._brnDialog.setContext(context);
+    }
+    constructor() {
+        if (!this._brnDialog)
+            return;
+        this._brnDialog.registerTemplate(this._template);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogContentDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnDialogContentDirective, isStandalone: true, selector: "[brnDialogContent]", inputs: { class: "class", context: "context" }, providers: [provideExposesStateProviderExisting((() => BrnDialogContentDirective))], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnDialogContent]',
+                    standalone: true,
+                    providers: [provideExposesStateProviderExisting((() => BrnDialogContentDirective))],
+                }]
+        }], ctorParameters: () => [], propDecorators: { class: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }] } });
+
+class BrnDialogDescriptionDirective {
+    _brnDialogRef = inject(BrnDialogRef);
+    _id = signal(`brn-dialog-description-${this._brnDialogRef?.dialogId}`);
+    constructor() {
+        effect(() => {
+            this._brnDialogRef.setAriaDescribedBy(this._id());
+        });
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogDescriptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnDialogDescriptionDirective, isStandalone: true, selector: "[brnDialogDescription]", host: { properties: { "id": "_id()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogDescriptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnDialogDescription]',
+                    standalone: true,
+                    host: {
+                        '[id]': '_id()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+
+class BrnDialogOverlayComponent {
+    _brnDialog = inject(BrnDialogComponent);
+    set class(newClass) {
+        this._brnDialog.setOverlayClass(newClass);
+    }
+    setClassToCustomElement(newClass) {
+        this._brnDialog.setOverlayClass(newClass);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogOverlayComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.5", type: BrnDialogOverlayComponent, isStandalone: true, selector: "brn-dialog-overlay", inputs: { class: "class" }, providers: [provideCustomClassSettableExisting((() => BrnDialogOverlayComponent))], ngImport: i0, template: '', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogOverlayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-dialog-overlay',
+                    standalone: true,
+                    template: '',
+                    providers: [provideCustomClassSettableExisting((() => BrnDialogOverlayComponent))],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], propDecorators: { class: [{
+                type: Input
+            }] } });
+
+class BrnDialogTitleDirective {
+    _brnDialogRef = inject(BrnDialogRef);
+    _id = signal(`brn-dialog-title-${this._brnDialogRef?.dialogId}`);
+    constructor() {
+        effect(() => {
+            this._brnDialogRef.setAriaLabelledBy(this._id());
+        });
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogTitleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnDialogTitleDirective, isStandalone: true, selector: "[brnDialogTitle]", host: { properties: { "id": "_id()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogTitleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnDialogTitle]',
+                    standalone: true,
+                    host: {
+                        '[id]': '_id()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+
+let idSequence = 0;
+class BrnDialogTriggerDirective {
+    _brnDialog = inject(BrnDialogComponent, { optional: true });
+    _brnDialogRef = inject(BrnDialogRef, { optional: true });
+    id = input(`brn-dialog-trigger-${idSequence++}`);
+    state = this._brnDialogRef?.state ?? signal('closed');
+    dialogId = `brn-dialog-${this._brnDialogRef?.dialogId ?? idSequence++}`;
+    set brnDialogTriggerFor(brnDialog) {
+        this._brnDialog = brnDialog;
+    }
+    open() {
+        this._brnDialog?.open();
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnDialogTriggerDirective, isStandalone: true, selector: "button[brnDialogTrigger],button[brnDialogTriggerFor]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, brnDialogTriggerFor: { classPropertyName: "brnDialogTriggerFor", publicName: "brnDialogTriggerFor", isSignal: false, isRequired: false, transformFunction: null } }, host: { attributes: { "aria-haspopup": "dialog" }, listeners: { "click": "open()" }, properties: { "id": "id()", "attr.aria-expanded": "state() === 'open' ? 'true': 'false'", "attr.data-state": "state()", "attr.aria-controls": "dialogId" } }, exportAs: ["brnDialogTrigger"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[brnDialogTrigger],button[brnDialogTriggerFor]',
+                    standalone: true,
+                    host: {
+                        '[id]': 'id()',
+                        '(click)': 'open()',
+                        'aria-haspopup': 'dialog',
+                        '[attr.aria-expanded]': "state() === 'open' ? 'true': 'false'",
+                        '[attr.data-state]': 'state()',
+                        '[attr.aria-controls]': 'dialogId',
+                    },
+                    exportAs: 'brnDialogTrigger',
+                }]
+        }], propDecorators: { brnDialogTriggerFor: [{
+                type: Input
+            }] } });
+
+const BrnDialogImports = [
+    BrnDialogComponent,
+    BrnDialogOverlayComponent,
+    BrnDialogTriggerDirective,
+    BrnDialogCloseDirective,
+    BrnDialogContentDirective,
+    BrnDialogTitleDirective,
+    BrnDialogDescriptionDirective,
+];
+class BrnDialogModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogModule, imports: [BrnDialogComponent,
+            BrnDialogOverlayComponent,
+            BrnDialogTriggerDirective,
+            BrnDialogCloseDirective,
+            BrnDialogContentDirective,
+            BrnDialogTitleDirective,
+            BrnDialogDescriptionDirective], exports: [BrnDialogComponent,
+            BrnDialogOverlayComponent,
+            BrnDialogTriggerDirective,
+            BrnDialogCloseDirective,
+            BrnDialogContentDirective,
+            BrnDialogTitleDirective,
+            BrnDialogDescriptionDirective] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnDialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...BrnDialogImports],
+                    exports: [...BrnDialogImports],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BrnDialogCloseDirective, BrnDialogComponent, BrnDialogContentDirective, BrnDialogDescriptionDirective, BrnDialogImports, BrnDialogModule, BrnDialogOverlayComponent, BrnDialogRef, BrnDialogService, BrnDialogTitleDirective, BrnDialogTriggerDirective, DEFAULT_BRN_DIALOG_OPTIONS, cssClassesToArray, injectBrnDialogContext, injectBrnDialogCtx };
+//# sourceMappingURL=spartan-ng-brain-dialog.mjs.map