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

package/esm2022/dialog/lib/brn-dialog-trigger.directive.mjs

@@ -0,0 +1,39 @@
+import { Directive, Input, inject, input, signal } from '@angular/core';
+import { BrnDialogRef } from './brn-dialog-ref';
+import { BrnDialogComponent } from './brn-dialog.component';
+import * as i0 from "@angular/core";
+let idSequence = 0;
+export 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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/dialog/lib/brn-dialog-utils.mjs

@@ -0,0 +1,12 @@
+// brn-dialog-utils.ts
+export const cssClassesToArray = (classes, defaultClass = '') => {
+    if (typeof classes === 'string') {
+        const splitClasses = classes.trim().split(' ');
+        if (splitClasses.length === 0) {
+            return [defaultClass];
+        }
+        return splitClasses;
+    }
+    return classes ?? [];
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLWRpYWxvZy11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYnJhaW4vZGlhbG9nL3NyYy9saWIvYnJuLWRpYWxvZy11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzQkFBc0I7QUFFdEIsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxPQUE2QyxFQUFFLFlBQVksR0FBRyxFQUFFLEVBQVksRUFBRTtJQUMvRyxJQUFJLE9BQU8sT0FBTyxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ2pDLE1BQU0sWUFBWSxHQUFHLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDL0MsSUFBSSxZQUFZLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQy9CLE9BQU8sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN2QixDQUFDO1FBQ0QsT0FBTyxZQUFZLENBQUM7SUFDckIsQ0FBQztJQUNELE9BQU8sT0FBTyxJQUFJLEVBQUUsQ0FBQztBQUN0QixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBicm4tZGlhbG9nLXV0aWxzLnRzXG5cbmV4cG9ydCBjb25zdCBjc3NDbGFzc2VzVG9BcnJheSA9IChjbGFzc2VzOiBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZCB8IG51bGwsIGRlZmF1bHRDbGFzcyA9ICcnKTogc3RyaW5nW10gPT4ge1xuXHRpZiAodHlwZW9mIGNsYXNzZXMgPT09ICdzdHJpbmcnKSB7XG5cdFx0Y29uc3Qgc3BsaXRDbGFzc2VzID0gY2xhc3Nlcy50cmltKCkuc3BsaXQoJyAnKTtcblx0XHRpZiAoc3BsaXRDbGFzc2VzLmxlbmd0aCA9PT0gMCkge1xuXHRcdFx0cmV0dXJuIFtkZWZhdWx0Q2xhc3NdO1xuXHRcdH1cblx0XHRyZXR1cm4gc3BsaXRDbGFzc2VzO1xuXHR9XG5cdHJldHVybiBjbGFzc2VzID8/IFtdO1xufTtcbiJdfQ==

package/esm2022/dialog/lib/brn-dialog.component.mjs

@@ -0,0 +1,208 @@
+import { OverlayPositionBuilder, ScrollStrategyOptions, } from '@angular/cdk/overlay';
+import { ChangeDetectionStrategy, Component, EventEmitter, Injector, Input, Output, ViewContainerRef, ViewEncapsulation, booleanAttribute, computed, effect, inject, numberAttribute, runInInjectionContext, signal, } from '@angular/core';
+import { take } from 'rxjs';
+import { DEFAULT_BRN_DIALOG_OPTIONS } from './brn-dialog-options';
+import { BrnDialogService } from './brn-dialog.service';
+import * as i0 from "@angular/core";
+export 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,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-dialog.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/dialog/src/lib/brn-dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AutoFocusTarget } from '@angular/cdk/dialog';\nimport {\n\ttype ConnectedPosition,\n\ttype FlexibleConnectedPositionStrategyOrigin,\n\tOverlayPositionBuilder,\n\ttype PositionStrategy,\n\ttype ScrollStrategy,\n\tScrollStrategyOptions,\n} from '@angular/cdk/overlay';\nimport {\n\tChangeDetectionStrategy,\n\tComponent,\n\ttype EffectRef,\n\ttype ElementRef,\n\tEventEmitter,\n\tInjector,\n\tInput,\n\tOutput,\n\ttype TemplateRef,\n\tViewContainerRef,\n\tViewEncapsulation,\n\tbooleanAttribute,\n\tcomputed,\n\teffect,\n\tinject,\n\tnumberAttribute,\n\trunInInjectionContext,\n\tsignal,\n} from '@angular/core';\nimport { take } from 'rxjs';\nimport { type BrnDialogOptions, DEFAULT_BRN_DIALOG_OPTIONS } from './brn-dialog-options';\nimport type { BrnDialogRef } from './brn-dialog-ref';\nimport type { BrnDialogState } from './brn-dialog-state';\nimport { BrnDialogService } from './brn-dialog.service';\n\n@Component({\n\tselector: 'brn-dialog',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ng-content />\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tencapsulation: ViewEncapsulation.None,\n\texportAs: 'brnDialog',\n})\nexport class BrnDialogComponent {\n\tprivate readonly _dialogService = inject(BrnDialogService);\n\tprivate readonly _vcr = inject(ViewContainerRef);\n\tpublic readonly positionBuilder = inject(OverlayPositionBuilder);\n\tpublic readonly ssos = inject(ScrollStrategyOptions);\n\tprivate readonly _injector = inject(Injector);\n\n\tprivate _context = {};\n\tprotected _options: Partial<BrnDialogOptions> = {\n\t\t...DEFAULT_BRN_DIALOG_OPTIONS,\n\t};\n\n\tprivate _contentTemplate: TemplateRef<unknown> | undefined;\n\tprivate readonly _dialogRef = signal<BrnDialogRef | undefined>(undefined);\n\tprivate _dialogStateEffectRef?: EffectRef;\n\n\tpublic readonly state = computed(() => this._dialogRef()?.state() ?? 'closed');\n\n\t@Output()\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tpublic readonly closed = new EventEmitter<any>();\n\n\t@Output()\n\tpublic readonly stateChanged = new EventEmitter<BrnDialogState>();\n\n\t// eslint-disable-next-line @angular-eslint/no-input-rename\n\t@Input('state')\n\tpublic set newState(state: BrnDialogState) {\n\t\tif (state === 'open') {\n\t\t\tthis.open();\n\t\t}\n\t\tif (state === 'closed') {\n\t\t\tthis.close(this._options.closeDelay);\n\t\t}\n\t}\n\n\t@Input()\n\tpublic set role(role: 'dialog' | 'alertdialog') {\n\t\tthis._options.role = role;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tpublic set hasBackdrop(hasBackdrop: boolean) {\n\t\tthis._options.hasBackdrop = hasBackdrop;\n\t}\n\n\t@Input()\n\tpublic set positionStrategy(positionStrategy: PositionStrategy) {\n\t\tthis._options.positionStrategy = positionStrategy;\n\t}\n\n\t@Input()\n\tpublic set scrollStrategy(scrollStrategy: ScrollStrategy | 'close' | 'reposition') {\n\t\tif (scrollStrategy === 'close') {\n\t\t\tthis._options.scrollStrategy = this.ssos.close();\n\t\t} else if (scrollStrategy === 'reposition') {\n\t\t\tthis._options.scrollStrategy = this.ssos.reposition();\n\t\t} else {\n\t\t\tthis._options.scrollStrategy = scrollStrategy;\n\t\t}\n\t}\n\n\t@Input()\n\tpublic set restoreFocus(restoreFocus: boolean | string | ElementRef) {\n\t\tthis._options.restoreFocus = restoreFocus;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tpublic set closeOnOutsidePointerEvents(closeOnOutsidePointerEvents: boolean) {\n\t\tthis._options.closeOnOutsidePointerEvents = closeOnOutsidePointerEvents;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tpublic set closeOnBackdropClick(closeOnBackdropClick: boolean) {\n\t\tthis._options.closeOnBackdropClick = closeOnBackdropClick;\n\t}\n\n\t@Input()\n\tpublic set attachTo(attachTo: FlexibleConnectedPositionStrategyOrigin | null | undefined) {\n\t\tthis._options.attachTo = attachTo;\n\t}\n\n\t@Input()\n\tpublic set attachPositions(attachPositions: ConnectedPosition[]) {\n\t\tthis._options.attachPositions = attachPositions;\n\t}\n\n\t@Input()\n\tpublic set autoFocus(autoFocus: AutoFocusTarget | string) {\n\t\tthis._options.autoFocus = autoFocus;\n\t}\n\n\t@Input({ transform: numberAttribute })\n\tpublic set closeDelay(closeDelay: number) {\n\t\tthis._options.closeDelay = closeDelay;\n\t}\n\n\t@Input({ transform: booleanAttribute })\n\tpublic set disableClose(disableClose: boolean) {\n\t\tthis._options.disableClose = disableClose;\n\t}\n\n\t/* eslint-disable-next-line @angular-eslint/no-input-rename */\n\t@Input('aria-describedby')\n\tpublic set ariaDescribedBy(ariaDescribedBy: string | null | undefined) {\n\t\tthis.setAriaDescribedBy(ariaDescribedBy);\n\t}\n\n\t/* eslint-disable-next-line @angular-eslint/no-input-rename */\n\t@Input('aria-labelledby')\n\tpublic set ariaLabelledBy(ariaLabelledBy: string | null | undefined) {\n\t\tthis.setAriaLabelledBy(ariaLabelledBy);\n\t}\n\n\t@Input('aria-label')\n\tpublic set ariaLabel(ariaLabel: string | null | undefined) {\n\t\tthis.setAriaLabel(ariaLabel);\n\t}\n\n\t@Input({\n\t\talias: 'aria-modal',\n\t\ttransform: booleanAttribute,\n\t})\n\tpublic set ariaModal(isModal: boolean) {\n\t\tthis.setAriaModal(isModal);\n\t}\n\n\tpublic open<DialogContext>() {\n\t\tif (!this._contentTemplate || this._dialogRef()) return;\n\n\t\tthis._dialogStateEffectRef?.destroy();\n\n\t\tconst dialogRef = this._dialogService.open<DialogContext>(\n\t\t\tthis._contentTemplate,\n\t\t\tthis._vcr,\n\t\t\tthis._context as DialogContext,\n\t\t\tthis._options,\n\t\t);\n\n\t\tthis._dialogRef.set(dialogRef);\n\n\t\trunInInjectionContext(this._injector, () => {\n\t\t\tthis._dialogStateEffectRef = effect(() => this.stateChanged.emit(dialogRef.state()));\n\t\t});\n\n\t\tdialogRef.closed$.pipe(take(1)).subscribe((result) => {\n\t\t\tthis._dialogRef.set(undefined);\n\t\t\tthis.closed.emit(result);\n\t\t});\n\t}\n\n\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\tpublic close(result: any, delay?: number) {\n\t\tthis._dialogRef()?.close(result, delay ?? this._options.closeDelay);\n\t}\n\n\tpublic registerTemplate(template: TemplateRef<unknown>) {\n\t\tthis._contentTemplate = template;\n\t}\n\n\tpublic setOverlayClass(overlayClass: string | null | undefined) {\n\t\tthis._options.backdropClass = overlayClass ?? '';\n\t\tthis._dialogRef()?.setOverlayClass(overlayClass);\n\t}\n\n\tpublic setPanelClass(panelClass: string | null | undefined) {\n\t\tthis._options.panelClass = panelClass ?? '';\n\t\tthis._dialogRef()?.setPanelClass(panelClass);\n\t}\n\n\tpublic setContext(context: unknown) {\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-expect-error\n\t\tthis._context = { ...this._context, ...context };\n\t}\n\n\tpublic setAriaDescribedBy(ariaDescribedBy: string | null | undefined) {\n\t\tthis._options = { ...this._options, ariaDescribedBy };\n\t\tthis._dialogRef()?.setAriaDescribedBy(ariaDescribedBy);\n\t}\n\n\tpublic setAriaLabelledBy(ariaLabelledBy: string | null | undefined) {\n\t\tthis._options = { ...this._options, ariaLabelledBy };\n\t\tthis._dialogRef()?.setAriaLabelledBy(ariaLabelledBy);\n\t}\n\n\tpublic setAriaLabel(ariaLabel: string | null | undefined) {\n\t\tthis._options = { ...this._options, ariaLabel };\n\t\tthis._dialogRef()?.setAriaLabel(ariaLabel);\n\t}\n\n\tpublic setAriaModal(ariaModal: boolean) {\n\t\tthis._options = { ...this._options, ariaModal };\n\t}\n}\n"]}

package/esm2022/dialog/lib/brn-dialog.service.mjs

@@ -0,0 +1,127 @@
+import { DIALOG_DATA, Dialog } from '@angular/cdk/dialog';
+import { OverlayPositionBuilder, ScrollStrategyOptions } from '@angular/cdk/overlay';
+import { Injectable, Injector, RendererFactory2, computed, effect, inject, runInInjectionContext, signal, } from '@angular/core';
+import { Subject, filter, takeUntil } from 'rxjs';
+import { BrnDialogRef } from './brn-dialog-ref';
+import { cssClassesToArray } from './brn-dialog-utils';
+import * as i0 from "@angular/core";
+let dialogSequence = 0;
+/** @deprecated `injectBrnDialogCtx` will no longer be supported once components are stable. Use `injectBrnDialogContext` instead.  */
+export const injectBrnDialogCtx = () => {
+    return inject(DIALOG_DATA);
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const injectBrnDialogContext = (options = {}) => {
+    return inject(DIALOG_DATA, options);
+};
+export 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' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-dialog.service.js","sourceRoot":"","sources":["../../../../../../libs/brain/dialog/src/lib/brn-dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DIALOG_DATA, Dialog } from '@angular/cdk/dialog';\nimport { type ComponentType, OverlayPositionBuilder, ScrollStrategyOptions } from '@angular/cdk/overlay';\nimport {\n\ttype EffectRef,\n\ttype InjectOptions,\n\tInjectable,\n\tInjector,\n\tRendererFactory2,\n\ttype StaticProvider,\n\ttype TemplateRef,\n\ttype ViewContainerRef,\n\tcomputed,\n\teffect,\n\tinject,\n\trunInInjectionContext,\n\tsignal,\n} from '@angular/core';\nimport { Subject, filter, takeUntil } from 'rxjs';\nimport type { BrnDialogOptions } from './brn-dialog-options';\nimport { BrnDialogRef } from './brn-dialog-ref';\nimport type { BrnDialogState } from './brn-dialog-state';\nimport { cssClassesToArray } from './brn-dialog-utils';\n\nlet dialogSequence = 0;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type BrnDialogContext<T> = T & { close: (result?: any) => void };\n\n/** @deprecated `injectBrnDialogCtx` will no longer be supported once components are stable. Use `injectBrnDialogContext` instead.  */\nexport const injectBrnDialogCtx = <T>(): BrnDialogContext<T> => {\n\treturn inject(DIALOG_DATA);\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const injectBrnDialogContext = <DialogContext = any>(options: InjectOptions = {}) => {\n\treturn inject(DIALOG_DATA, options) as DialogContext;\n};\n\n@Injectable({ providedIn: 'root' })\nexport class BrnDialogService {\n\tprivate readonly _cdkDialog = inject(Dialog);\n\tprivate readonly _rendererFactory = inject(RendererFactory2);\n\tprivate readonly _renderer = this._rendererFactory.createRenderer(null, null);\n\tprivate readonly _positionBuilder = inject(OverlayPositionBuilder);\n\tprivate readonly _sso = inject(ScrollStrategyOptions);\n\tprivate readonly _injector = inject(Injector);\n\n\tpublic open<DialogContext>(\n\t\tcontent: ComponentType<unknown> | TemplateRef<unknown>,\n\t\tvcr?: ViewContainerRef,\n\t\tcontext?: DialogContext,\n\t\toptions?: Partial<BrnDialogOptions>,\n\t) {\n\t\tif (options?.id && this._cdkDialog.getDialogById(options.id)) {\n\t\t\tthrow new Error(`Dialog with ID: ${options.id} already exists`);\n\t\t}\n\n\t\tconst positionStrategy =\n\t\t\toptions?.positionStrategy ??\n\t\t\t(options?.attachTo && options?.attachPositions && options?.attachPositions?.length > 0\n\t\t\t\t? this._positionBuilder?.flexibleConnectedTo(options.attachTo).withPositions(options.attachPositions ?? [])\n\t\t\t\t: this._positionBuilder.global().centerHorizontally().centerVertically());\n\n\t\tlet brnDialogRef!: BrnDialogRef;\n\t\tlet effectRef!: EffectRef;\n\n\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\tconst contextOrData: BrnDialogContext<any> = {\n\t\t\t...context,\n\t\t\t// eslint-disable-next-line @typescript-eslint/no-explicit-any\n\t\t\tclose: (result: any = undefined) => brnDialogRef.close(result, options?.closeDelay),\n\t\t};\n\n\t\tconst destroyed$ = new Subject<void>();\n\t\tconst open = signal<boolean>(true);\n\t\tconst state = computed<BrnDialogState>(() => (open() ? 'open' : 'closed'));\n\t\tconst dialogId = dialogSequence++;\n\n\t\t// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n\t\t// @ts-ignore\n\t\tconst cdkDialogRef = this._cdkDialog.open(content, {\n\t\t\tid: options?.id ?? `brn-dialog-${dialogId}`,\n\t\t\trole: options?.role,\n\t\t\tviewContainerRef: vcr,\n\t\t\ttemplateContext: () => ({\n\t\t\t\t$implicit: contextOrData,\n\t\t\t}),\n\t\t\tdata: contextOrData,\n\t\t\thasBackdrop: options?.hasBackdrop,\n\t\t\tpanelClass: cssClassesToArray(options?.panelClass),\n\t\t\tbackdropClass: cssClassesToArray(options?.backdropClass, 'bg-transparent'),\n\t\t\tpositionStrategy,\n\t\t\tscrollStrategy: options?.scrollStrategy ?? this._sso?.block(),\n\t\t\trestoreFocus: options?.restoreFocus,\n\t\t\tdisableClose: true,\n\t\t\tautoFocus: options?.autoFocus ?? 'first-tabbable',\n\t\t\tariaDescribedBy: options?.ariaDescribedBy ?? `brn-dialog-description-${dialogId}`,\n\t\t\tariaLabelledBy: options?.ariaLabelledBy ?? `brn-dialog-title-${dialogId}`,\n\t\t\tariaLabel: options?.ariaLabel,\n\t\t\tariaModal: options?.ariaModal,\n\t\t\tproviders: (cdkDialogRef) => {\n\t\t\t\tbrnDialogRef = new BrnDialogRef(cdkDialogRef, open, state, dialogId, options as BrnDialogOptions);\n\n\t\t\t\trunInInjectionContext(this._injector, () => {\n\t\t\t\t\teffectRef = effect(() => {\n\t\t\t\t\t\tif (overlay) {\n\t\t\t\t\t\t\tthis._renderer.setAttribute(overlay, 'data-state', state());\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (backdrop) {\n\t\t\t\t\t\t\tthis._renderer.setAttribute(backdrop, 'data-state', state());\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t});\n\n\t\t\t\tconst providers: StaticProvider[] = [\n\t\t\t\t\t{\n\t\t\t\t\t\tprovide: BrnDialogRef,\n\t\t\t\t\t\tuseValue: brnDialogRef,\n\t\t\t\t\t},\n\t\t\t\t];\n\n\t\t\t\tif (options?.providers) {\n\t\t\t\t\tif (typeof options.providers === 'function') {\n\t\t\t\t\t\tproviders.push(...options.providers());\n\t\t\t\t\t}\n\n\t\t\t\t\tif (Array.isArray(options.providers)) {\n\t\t\t\t\t\tproviders.push(...options.providers);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn providers;\n\t\t\t},\n\t\t});\n\n\t\tconst overlay = cdkDialogRef.overlayRef.overlayElement;\n\t\tconst backdrop = cdkDialogRef.overlayRef.backdropElement;\n\n\t\tif (options?.closeOnOutsidePointerEvents) {\n\t\t\tcdkDialogRef.outsidePointerEvents.pipe(takeUntil(destroyed$)).subscribe(() => {\n\t\t\t\tbrnDialogRef.close(undefined, options?.closeDelay);\n\t\t\t});\n\t\t}\n\n\t\tif (options?.closeOnBackdropClick) {\n\t\t\tcdkDialogRef.backdropClick.pipe(takeUntil(destroyed$)).subscribe(() => {\n\t\t\t\tbrnDialogRef.close(undefined, options?.closeDelay);\n\t\t\t});\n\t\t}\n\n\t\tif (!options?.disableClose) {\n\t\t\tcdkDialogRef.keydownEvents\n\t\t\t\t.pipe(\n\t\t\t\t\tfilter((e) => e.key === 'Escape'),\n\t\t\t\t\ttakeUntil(destroyed$),\n\t\t\t\t)\n\t\t\t\t.subscribe(() => {\n\t\t\t\t\tbrnDialogRef.close(undefined, options?.closeDelay);\n\t\t\t\t});\n\t\t}\n\n\t\tcdkDialogRef.closed.pipe(takeUntil(destroyed$)).subscribe(() => {\n\t\t\teffectRef?.destroy();\n\t\t\tdestroyed$.next();\n\t\t});\n\n\t\treturn brnDialogRef;\n\t}\n}\n"]}

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

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

package/esm2022/form-field/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib/brn-form-field-control';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL2Zvcm0tZmllbGQvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9icm4tZm9ybS1maWVsZC1jb250cm9sJztcbiJdfQ==

package/esm2022/form-field/lib/brn-form-field-control.mjs

@@ -0,0 +1,14 @@
+import { Directive, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BrnFormFieldControl {
+    /** Gets the AbstractControlDirective for this control. */
+    ngControl = null;
+    /** Whether the control is in an error state. */
+    errorState = signal(false);
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnFormFieldControl, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnFormFieldControl, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnFormFieldControl, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLWZvcm0tZmllbGQtY29udHJvbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYnJhaW4vZm9ybS1maWVsZC9zcmMvbGliL2Jybi1mb3JtLWZpZWxkLWNvbnRyb2wudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSS9ELE1BQU0sT0FBTyxtQkFBbUI7SUFDL0IsMERBQTBEO0lBQzFDLFNBQVMsR0FBZ0QsSUFBSSxDQUFDO0lBRTlFLGdEQUFnRDtJQUNoQyxVQUFVLEdBQW9CLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQzswSEFMaEQsbUJBQW1COzhHQUFuQixtQkFBbUI7OzJGQUFuQixtQkFBbUI7a0JBRC9CLFNBQVMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIHR5cGUgU2lnbmFsLCBzaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB0eXBlIHsgQWJzdHJhY3RDb250cm9sRGlyZWN0aXZlLCBOZ0NvbnRyb2wgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbkBEaXJlY3RpdmUoKVxuZXhwb3J0IGNsYXNzIEJybkZvcm1GaWVsZENvbnRyb2wge1xuXHQvKiogR2V0cyB0aGUgQWJzdHJhY3RDb250cm9sRGlyZWN0aXZlIGZvciB0aGlzIGNvbnRyb2wuICovXG5cdHB1YmxpYyByZWFkb25seSBuZ0NvbnRyb2w6IE5nQ29udHJvbCB8IEFic3RyYWN0Q29udHJvbERpcmVjdGl2ZSB8IG51bGwgPSBudWxsO1xuXG5cdC8qKiBXaGV0aGVyIHRoZSBjb250cm9sIGlzIGluIGFuIGVycm9yIHN0YXRlLiAqL1xuXHRwdWJsaWMgcmVhZG9ubHkgZXJyb3JTdGF0ZTogU2lnbmFsPGJvb2xlYW4+ID0gc2lnbmFsKGZhbHNlKTtcbn1cbiJdfQ==

package/esm2022/form-field/spartan-ng-brain-form-field.mjs

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

package/esm2022/forms/index.mjs

@@ -0,0 +1,4 @@
+export * from './lib/control-value-accessor';
+export * from './lib/error-options';
+export * from './lib/error-state-tracker';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL2Zvcm1zL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2NvbnRyb2wtdmFsdWUtYWNjZXNzb3InO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZXJyb3Itb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9lcnJvci1zdGF0ZS10cmFja2VyJztcbiJdfQ==

package/esm2022/forms/lib/control-value-accessor.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udHJvbC12YWx1ZS1hY2Nlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYnJhaW4vZm9ybXMvc3JjL2xpYi9jb250cm9sLXZhbHVlLWFjY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBDaGFuZ2VGbjxUPiA9ICh2YWx1ZTogVCkgPT4gdm9pZDtcbmV4cG9ydCB0eXBlIFRvdWNoRm4gPSAoKSA9PiB2b2lkO1xuIl19

package/esm2022/forms/lib/error-options.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Error state matcher that matches when a control is invalid and dirty. */
+export class ShowOnDirtyErrorStateMatcher {
+    isInvalid(control, form) {
+        return !!(control && control.invalid && (control.dirty || (form && form.submitted)));
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ShowOnDirtyErrorStateMatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ShowOnDirtyErrorStateMatcher });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ShowOnDirtyErrorStateMatcher, decorators: [{
+            type: Injectable
+        }] });
+/** Provider that defines how form controls behave with regards to displaying error messages. */
+export class ErrorStateMatcher {
+    isInvalid(control, form) {
+        return !!(control && control.invalid && (control.touched || (form && form.submitted)));
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ErrorStateMatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ErrorStateMatcher, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ErrorStateMatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/forms/lib/error-state-tracker.mjs

@@ -0,0 +1,29 @@
+import { signal } from '@angular/core';
+export class ErrorStateTracker {
+    _defaultMatcher;
+    ngControl;
+    _parentFormGroup;
+    _parentForm;
+    /** Whether the tracker is currently in an error state. */
+    errorState = signal(false);
+    /** User-defined matcher for the error state. */
+    matcher = null;
+    constructor(_defaultMatcher, ngControl, _parentFormGroup, _parentForm) {
+        this._defaultMatcher = _defaultMatcher;
+        this.ngControl = ngControl;
+        this._parentFormGroup = _parentFormGroup;
+        this._parentForm = _parentForm;
+    }
+    /** Updates the error state based on the provided error state matcher. */
+    updateErrorState() {
+        const oldState = this.errorState();
+        const parent = this._parentFormGroup || this._parentForm;
+        const matcher = this.matcher || this._defaultMatcher;
+        const control = this.ngControl ? this.ngControl.control : null;
+        const newState = matcher?.isInvalid(control, parent) ?? false;
+        if (newState !== oldState) {
+            this.errorState.set(newState);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/forms/spartan-ng-brain-forms.mjs

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

package/esm2022/hover-card/index.mjs

@@ -0,0 +1,29 @@
+import { NgModule } from '@angular/core';
+import { BrnHoverCardContentDirective, BrnHoverCardTriggerDirective } from './lib/brn-hover-card-content.service';
+import { BrnHoverCardComponent } from './lib/brn-hover-card.component';
+import * as i0 from "@angular/core";
+export * from './lib/brn-hover-card-content.service';
+export * from './lib/brn-hover-card.component';
+export * from './lib/createHoverObservable';
+export const BrnHoverCardImports = [
+    BrnHoverCardComponent,
+    BrnHoverCardContentDirective,
+    BrnHoverCardTriggerDirective,
+];
+export class BrnHoverCardModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnHoverCardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnHoverCardModule, imports: [BrnHoverCardComponent,
+            BrnHoverCardContentDirective,
+            BrnHoverCardTriggerDirective], exports: [BrnHoverCardComponent,
+            BrnHoverCardContentDirective,
+            BrnHoverCardTriggerDirective] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnHoverCardModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnHoverCardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...BrnHoverCardImports],
+                    exports: [...BrnHoverCardImports],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL2hvdmVyLWNhcmQvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLDRCQUE0QixFQUFFLDRCQUE0QixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDbEgsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7O0FBRXZFLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHO0lBQ2xDLHFCQUFxQjtJQUNyQiw0QkFBNEI7SUFDNUIsNEJBQTRCO0NBQ25CLENBQUM7QUFNWCxNQUFNLE9BQU8sa0JBQWtCOzBIQUFsQixrQkFBa0I7MkhBQWxCLGtCQUFrQixZQVQ5QixxQkFBcUI7WUFDckIsNEJBQTRCO1lBQzVCLDRCQUE0QixhQUY1QixxQkFBcUI7WUFDckIsNEJBQTRCO1lBQzVCLDRCQUE0QjsySEFPaEIsa0JBQWtCOzsyRkFBbEIsa0JBQWtCO2tCQUo5QixRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxDQUFDLEdBQUcsbUJBQW1CLENBQUM7b0JBQ2pDLE9BQU8sRUFBRSxDQUFDLEdBQUcsbUJBQW1CLENBQUM7aUJBQ2pDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEJybkhvdmVyQ2FyZENvbnRlbnREaXJlY3RpdmUsIEJybkhvdmVyQ2FyZFRyaWdnZXJEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9icm4taG92ZXItY2FyZC1jb250ZW50LnNlcnZpY2UnO1xuaW1wb3J0IHsgQnJuSG92ZXJDYXJkQ29tcG9uZW50IH0gZnJvbSAnLi9saWIvYnJuLWhvdmVyLWNhcmQuY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvYnJuLWhvdmVyLWNhcmQtY29udGVudC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jybi1ob3Zlci1jYXJkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jcmVhdGVIb3Zlck9ic2VydmFibGUnO1xuXG5leHBvcnQgY29uc3QgQnJuSG92ZXJDYXJkSW1wb3J0cyA9IFtcblx0QnJuSG92ZXJDYXJkQ29tcG9uZW50LFxuXHRCcm5Ib3ZlckNhcmRDb250ZW50RGlyZWN0aXZlLFxuXHRCcm5Ib3ZlckNhcmRUcmlnZ2VyRGlyZWN0aXZlLFxuXSBhcyBjb25zdDtcblxuQE5nTW9kdWxlKHtcblx0aW1wb3J0czogWy4uLkJybkhvdmVyQ2FyZEltcG9ydHNdLFxuXHRleHBvcnRzOiBbLi4uQnJuSG92ZXJDYXJkSW1wb3J0c10sXG59KVxuZXhwb3J0IGNsYXNzIEJybkhvdmVyQ2FyZE1vZHVsZSB7fVxuIl19