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

package/esm2022/select/lib/brn-select-content.component.mjs

@@ -0,0 +1,204 @@
+import { CdkListbox } from '@angular/cdk/listbox';
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, contentChild, contentChildren, effect, inject, signal, viewChild, } from '@angular/core';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { BrnSelectOptionDirective } from './brn-select-option.directive';
+import { BrnSelectService } from './brn-select.service';
+import { Directive } from '@angular/core';
+import { Subject, fromEvent, interval, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/listbox";
+const SCROLLBY_PIXELS = 100;
+export class BrnSelectScrollUpDirective {
+    _el = inject(ElementRef);
+    _selectContent = inject(BrnSelectContentComponent);
+    _endReached = new Subject();
+    _destroyRef = inject(DestroyRef);
+    startEmittingEvents() {
+        const mouseLeave$ = fromEvent(this._el.nativeElement, 'mouseleave');
+        interval(100)
+            .pipe(takeUntil(mouseLeave$), takeUntil(this._endReached), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => this._selectContent.moveFocusUp());
+    }
+    stopEmittingEvents() {
+        this._endReached.next(true);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectScrollUpDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnSelectScrollUpDirective, isStandalone: true, selector: "[brnSelectScrollUp], brn-select-scroll-up, hlm-select-scroll-up:not(noHlm)", host: { attributes: { "aria-hidden": "true" }, listeners: { "mouseenter": "startEmittingEvents()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectScrollUpDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnSelectScrollUp], brn-select-scroll-up, hlm-select-scroll-up:not(noHlm)',
+                    standalone: true,
+                    host: {
+                        'aria-hidden': 'true',
+                        '(mouseenter)': 'startEmittingEvents()',
+                    },
+                }]
+        }] });
+export class BrnSelectScrollDownDirective {
+    _el = inject(ElementRef);
+    _selectContent = inject(BrnSelectContentComponent);
+    _endReached = new Subject();
+    _destroyRef = inject(DestroyRef);
+    startEmittingEvents() {
+        const mouseLeave$ = fromEvent(this._el.nativeElement, 'mouseleave');
+        interval(100)
+            .pipe(takeUntil(mouseLeave$), takeUntil(this._endReached), takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => this._selectContent.moveFocusDown());
+    }
+    stopEmittingEvents() {
+        this._endReached.next(true);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectScrollDownDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnSelectScrollDownDirective, isStandalone: true, selector: "[brnSelectScrollDown], brn-select-scroll-down, hlm-select-scroll-down:not(noHlm)", host: { attributes: { "aria-hidden": "true" }, listeners: { "mouseenter": "startEmittingEvents()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectScrollDownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnSelectScrollDown], brn-select-scroll-down, hlm-select-scroll-down:not(noHlm)',
+                    standalone: true,
+                    host: {
+                        'aria-hidden': 'true',
+                        '(mouseenter)': 'startEmittingEvents()',
+                    },
+                }]
+        }] });
+export class BrnSelectContentComponent {
+    _el = inject(ElementRef);
+    _cdkListbox = inject(CdkListbox, { host: true });
+    _destroyRef = inject(DestroyRef);
+    _selectService = inject(BrnSelectService);
+    labelledBy = this._selectService.labelId;
+    id = this._selectService.id;
+    canScrollUp = signal(false);
+    canScrollDown = signal(false);
+    initialSelectedOptions$ = toObservable(this._selectService.selectedOptions);
+    viewport = viewChild.required('viewport');
+    scrollUpBtn = contentChild.required(BrnSelectScrollUpDirective);
+    scrollDownBtn = contentChild.required(BrnSelectScrollDownDirective);
+    _options = contentChildren(BrnSelectOptionDirective, { descendants: true });
+    constructor() {
+        this._cdkListbox.valueChange
+            .asObservable()
+            .pipe(takeUntilDestroyed())
+            .subscribe((val) => this._selectService.listBoxValueChangeEvent$.next(val));
+        effect(() => {
+            this._cdkListbox.multiple = this._selectService.multiple();
+            this._selectService.isExpanded() && setTimeout(() => this.updateArrowDisplay());
+        });
+    }
+    ngAfterViewInit() {
+        this.setInitiallySelectedOptions();
+    }
+    setInitiallySelectedOptions() {
+        this.initialSelectedOptions$.pipe(takeUntilDestroyed(this._destroyRef)).subscribe((selectedOptions) => {
+            // Reapplying cdkLibstbox multiple because seems this is running before effect that
+            // updates cdklistbox, reapplying multiple true so we can set the multiple initial options
+            if (this._selectService.multiple()) {
+                this._cdkListbox.multiple = true;
+            }
+            for (const cdkOption of this._selectService.possibleOptions()) {
+                if (selectedOptions.includes(cdkOption)) {
+                    cdkOption?.select();
+                }
+                else {
+                    cdkOption?.deselect();
+                }
+            }
+            for (const cdkOption of selectedOptions) {
+                cdkOption?.select();
+            }
+        });
+    }
+    updateArrowDisplay() {
+        const { scrollTop, scrollHeight, clientHeight } = this.viewport().nativeElement;
+        this.canScrollUp.set(scrollTop > 0);
+        const maxScroll = scrollHeight - clientHeight;
+        this.canScrollDown.set(Math.ceil(scrollTop) < maxScroll);
+    }
+    handleScroll() {
+        this.updateArrowDisplay();
+    }
+    focusList() {
+        this._cdkListbox.focus();
+    }
+    moveFocusUp() {
+        this.viewport().nativeElement.scrollBy({ top: -SCROLLBY_PIXELS, behavior: 'smooth' });
+        if (this.viewport().nativeElement.scrollTop === 0) {
+            this.scrollUpBtn().stopEmittingEvents();
+        }
+    }
+    moveFocusDown() {
+        this.viewport().nativeElement.scrollBy({ top: SCROLLBY_PIXELS, behavior: 'smooth' });
+        const viewportSize = this._el.nativeElement.scrollHeight;
+        const viewportScrollPosition = this.viewport().nativeElement.scrollTop;
+        if (viewportSize + viewportScrollPosition + SCROLLBY_PIXELS >
+            this.viewport().nativeElement.scrollHeight + SCROLLBY_PIXELS / 2) {
+            this.scrollDownBtn().stopEmittingEvents();
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.5", type: BrnSelectContentComponent, isStandalone: true, selector: "brn-select-content, hlm-select-content:not(noHlm)", host: { properties: { "attr.aria-labelledBy": "labelledBy()", "attr.aria-controlledBy": "id() +'--trigger'", "id": "id() + '--content'", "attr.dir": "_selectService.dir()" } }, queries: [{ propertyName: "scrollUpBtn", first: true, predicate: BrnSelectScrollUpDirective, descendants: true, isSignal: true }, { propertyName: "scrollDownBtn", first: true, predicate: BrnSelectScrollDownDirective, descendants: true, isSignal: true }, { propertyName: "_options", predicate: BrnSelectOptionDirective, descendants: true, isSignal: true }], viewQueries: [{ propertyName: "viewport", first: true, predicate: ["viewport"], descendants: true, isSignal: true }], hostDirectives: [{ directive: i1.CdkListbox }], ngImport: i0, template: `
+		<ng-template #scrollUp>
+			<ng-content select="hlm-select-scroll-up" />
+			<ng-content select="brnSelectScrollUp" />
+		</ng-template>
+		<ng-container *ngTemplateOutlet="canScrollUp() && scrollUpBtn() ? scrollUp : null" />
+		<div
+			data-brn-select-viewport
+			#viewport
+			(scroll)="handleScroll()"
+			style="flex: 1 1 0%;
+			position: relative;
+			width:100%;
+			overflow:auto;
+			min-height: 36px;
+      padding-bottom: 2px;
+      margin-bottom: -2px;"
+		>
+			<ng-content />
+		</div>
+		<ng-template #scrollDown>
+			<ng-content select="brnSelectScrollDown" />
+			<ng-content select="hlm-select-scroll-down" />
+		</ng-template>
+		<ng-container *ngTemplateOutlet="canScrollDown() && scrollDownBtn() ? scrollDown : null" />
+	`, isInline: true, styles: [":host{display:flex;box-sizing:border-box;flex-direction:column;outline:none;pointer-events:auto}[data-brn-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch}[data-brn-select-viewport]::-webkit-scrollbar{display:none}\n"], dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'brn-select-content, hlm-select-content:not(noHlm)', standalone: true, imports: [BrnSelectScrollUpDirective, BrnSelectScrollDownDirective, NgTemplateOutlet], hostDirectives: [CdkListbox], changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        '[attr.aria-labelledBy]': 'labelledBy()',
+                        '[attr.aria-controlledBy]': "id() +'--trigger'",
+                        '[id]': "id() + '--content'",
+                        '[attr.dir]': '_selectService.dir()',
+                    }, template: `
+		<ng-template #scrollUp>
+			<ng-content select="hlm-select-scroll-up" />
+			<ng-content select="brnSelectScrollUp" />
+		</ng-template>
+		<ng-container *ngTemplateOutlet="canScrollUp() && scrollUpBtn() ? scrollUp : null" />
+		<div
+			data-brn-select-viewport
+			#viewport
+			(scroll)="handleScroll()"
+			style="flex: 1 1 0%;
+			position: relative;
+			width:100%;
+			overflow:auto;
+			min-height: 36px;
+      padding-bottom: 2px;
+      margin-bottom: -2px;"
+		>
+			<ng-content />
+		</div>
+		<ng-template #scrollDown>
+			<ng-content select="brnSelectScrollDown" />
+			<ng-content select="hlm-select-scroll-down" />
+		</ng-template>
+		<ng-container *ngTemplateOutlet="canScrollDown() && scrollDownBtn() ? scrollDown : null" />
+	`, styles: [":host{display:flex;box-sizing:border-box;flex-direction:column;outline:none;pointer-events:auto}[data-brn-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch}[data-brn-select-viewport]::-webkit-scrollbar{display:none}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-select-content.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/select/src/lib/brn-select-content.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkListbox, type ListboxValueChangeEvent } from '@angular/cdk/listbox';\nimport { NgTemplateOutlet } from '@angular/common';\nimport {\n\ttype AfterViewInit,\n\tChangeDetectionStrategy,\n\tComponent,\n\tDestroyRef,\n\tElementRef,\n\tcontentChild,\n\tcontentChildren,\n\teffect,\n\tinject,\n\tsignal,\n\tviewChild,\n} from '@angular/core';\nimport { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';\nimport { BrnSelectOptionDirective } from './brn-select-option.directive';\nimport { BrnSelectService } from './brn-select.service';\n\nimport { Directive } from '@angular/core';\nimport { Subject, fromEvent, interval, takeUntil } from 'rxjs';\n\nconst SCROLLBY_PIXELS = 100;\n\n@Directive({\n\tselector: '[brnSelectScrollUp], brn-select-scroll-up, hlm-select-scroll-up:not(noHlm)',\n\tstandalone: true,\n\thost: {\n\t\t'aria-hidden': 'true',\n\t\t'(mouseenter)': 'startEmittingEvents()',\n\t},\n})\nexport class BrnSelectScrollUpDirective {\n\tprivate readonly _el = inject(ElementRef);\n\tprivate readonly _selectContent = inject(BrnSelectContentComponent);\n\n\tprivate readonly _endReached = new Subject<boolean>();\n\tprivate readonly _destroyRef = inject(DestroyRef);\n\n\tpublic startEmittingEvents(): void {\n\t\tconst mouseLeave$ = fromEvent(this._el.nativeElement, 'mouseleave');\n\n\t\tinterval(100)\n\t\t\t.pipe(takeUntil(mouseLeave$), takeUntil(this._endReached), takeUntilDestroyed(this._destroyRef))\n\t\t\t.subscribe(() => this._selectContent.moveFocusUp());\n\t}\n\n\tpublic stopEmittingEvents(): void {\n\t\tthis._endReached.next(true);\n\t}\n}\n\n@Directive({\n\tselector: '[brnSelectScrollDown], brn-select-scroll-down, hlm-select-scroll-down:not(noHlm)',\n\tstandalone: true,\n\thost: {\n\t\t'aria-hidden': 'true',\n\t\t'(mouseenter)': 'startEmittingEvents()',\n\t},\n})\nexport class BrnSelectScrollDownDirective {\n\tprivate readonly _el = inject(ElementRef);\n\tprivate readonly _selectContent = inject(BrnSelectContentComponent);\n\n\tprivate readonly _endReached = new Subject<boolean>();\n\tprivate readonly _destroyRef = inject(DestroyRef);\n\n\tpublic startEmittingEvents(): void {\n\t\tconst mouseLeave$ = fromEvent(this._el.nativeElement, 'mouseleave');\n\n\t\tinterval(100)\n\t\t\t.pipe(takeUntil(mouseLeave$), takeUntil(this._endReached), takeUntilDestroyed(this._destroyRef))\n\t\t\t.subscribe(() => this._selectContent.moveFocusDown());\n\t}\n\n\tpublic stopEmittingEvents(): void {\n\t\tthis._endReached.next(true);\n\t}\n}\n\n@Component({\n\tselector: 'brn-select-content, hlm-select-content:not(noHlm)',\n\tstandalone: true,\n\timports: [BrnSelectScrollUpDirective, BrnSelectScrollDownDirective, NgTemplateOutlet],\n\thostDirectives: [CdkListbox],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\thost: {\n\t\t'[attr.aria-labelledBy]': 'labelledBy()',\n\t\t'[attr.aria-controlledBy]': \"id() +'--trigger'\",\n\t\t'[id]': \"id() + '--content'\",\n\t\t'[attr.dir]': '_selectService.dir()',\n\t},\n\tstyles: [\n\t\t`\n\t\t\t:host {\n\t\t\t\tdisplay: flex;\n\t\t\t\tbox-sizing: border-box;\n\t\t\t\tflex-direction: column;\n\t\t\t\toutline: none;\n\t\t\t\tpointer-events: auto;\n\t\t\t}\n\n\t\t\t[data-brn-select-viewport] {\n\t\t\t\tscrollbar-width: none;\n\t\t\t\t-ms-overflow-style: none;\n\t\t\t\t-webkit-overflow-scrolling: touch;\n\t\t\t}\n\n\t\t\t[data-brn-select-viewport]::-webkit-scrollbar {\n\t\t\t\tdisplay: none;\n\t\t\t}\n\t\t`,\n\t],\n\ttemplate: `\n\t\t<ng-template #scrollUp>\n\t\t\t<ng-content select=\"hlm-select-scroll-up\" />\n\t\t\t<ng-content select=\"brnSelectScrollUp\" />\n\t\t</ng-template>\n\t\t<ng-container *ngTemplateOutlet=\"canScrollUp() && scrollUpBtn() ? scrollUp : null\" />\n\t\t<div\n\t\t\tdata-brn-select-viewport\n\t\t\t#viewport\n\t\t\t(scroll)=\"handleScroll()\"\n\t\t\tstyle=\"flex: 1 1 0%;\n\t\t\tposition: relative;\n\t\t\twidth:100%;\n\t\t\toverflow:auto;\n\t\t\tmin-height: 36px;\n      padding-bottom: 2px;\n      margin-bottom: -2px;\"\n\t\t>\n\t\t\t<ng-content />\n\t\t</div>\n\t\t<ng-template #scrollDown>\n\t\t\t<ng-content select=\"brnSelectScrollDown\" />\n\t\t\t<ng-content select=\"hlm-select-scroll-down\" />\n\t\t</ng-template>\n\t\t<ng-container *ngTemplateOutlet=\"canScrollDown() && scrollDownBtn() ? scrollDown : null\" />\n\t`,\n})\nexport class BrnSelectContentComponent implements AfterViewInit {\n\tprivate readonly _el: ElementRef<HTMLElement> = inject(ElementRef);\n\tprivate readonly _cdkListbox = inject(CdkListbox, { host: true });\n\tprivate readonly _destroyRef = inject(DestroyRef);\n\tprotected readonly _selectService = inject(BrnSelectService);\n\n\tprotected readonly labelledBy = this._selectService.labelId;\n\tprotected readonly id = this._selectService.id;\n\tprotected readonly canScrollUp = signal(false);\n\tprotected readonly canScrollDown = signal(false);\n\n\tprotected initialSelectedOptions$ = toObservable(this._selectService.selectedOptions);\n\n\tprotected viewport = viewChild.required<ElementRef<HTMLElement>>('viewport');\n\n\tprotected scrollUpBtn = contentChild.required(BrnSelectScrollUpDirective);\n\n\tprotected scrollDownBtn = contentChild.required(BrnSelectScrollDownDirective);\n\n\tprotected _options = contentChildren(BrnSelectOptionDirective, { descendants: true });\n\n\tconstructor() {\n\t\tthis._cdkListbox.valueChange\n\t\t\t.asObservable()\n\t\t\t.pipe(takeUntilDestroyed())\n\t\t\t.subscribe((val: ListboxValueChangeEvent<unknown>) => this._selectService.listBoxValueChangeEvent$.next(val));\n\n\t\teffect(() => {\n\t\t\tthis._cdkListbox.multiple = this._selectService.multiple();\n\t\t\tthis._selectService.isExpanded() && setTimeout(() => this.updateArrowDisplay());\n\t\t});\n\t}\n\n\tngAfterViewInit(): void {\n\t\tthis.setInitiallySelectedOptions();\n\t}\n\n\tprivate setInitiallySelectedOptions() {\n\t\tthis.initialSelectedOptions$.pipe(takeUntilDestroyed(this._destroyRef)).subscribe((selectedOptions) => {\n\t\t\t// Reapplying cdkLibstbox multiple because seems this is running before effect that\n\t\t\t// updates cdklistbox, reapplying multiple true so we can set the multiple initial options\n\t\t\tif (this._selectService.multiple()) {\n\t\t\t\tthis._cdkListbox.multiple = true;\n\t\t\t}\n\n\t\t\tfor (const cdkOption of this._selectService.possibleOptions()) {\n\t\t\t\tif (selectedOptions.includes(cdkOption)) {\n\t\t\t\t\tcdkOption?.select();\n\t\t\t\t} else {\n\t\t\t\t\tcdkOption?.deselect();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor (const cdkOption of selectedOptions) {\n\t\t\t\tcdkOption?.select();\n\t\t\t}\n\t\t});\n\t}\n\n\tpublic updateArrowDisplay(): void {\n\t\tconst { scrollTop, scrollHeight, clientHeight } = this.viewport().nativeElement;\n\t\tthis.canScrollUp.set(scrollTop > 0);\n\t\tconst maxScroll = scrollHeight - clientHeight;\n\t\tthis.canScrollDown.set(Math.ceil(scrollTop) < maxScroll);\n\t}\n\n\tpublic handleScroll() {\n\t\tthis.updateArrowDisplay();\n\t}\n\n\tpublic focusList(): void {\n\t\tthis._cdkListbox.focus();\n\t}\n\n\tpublic moveFocusUp() {\n\t\tthis.viewport().nativeElement.scrollBy({ top: -SCROLLBY_PIXELS, behavior: 'smooth' });\n\t\tif (this.viewport().nativeElement.scrollTop === 0) {\n\t\t\tthis.scrollUpBtn().stopEmittingEvents();\n\t\t}\n\t}\n\n\tpublic moveFocusDown() {\n\t\tthis.viewport().nativeElement.scrollBy({ top: SCROLLBY_PIXELS, behavior: 'smooth' });\n\t\tconst viewportSize = this._el.nativeElement.scrollHeight;\n\t\tconst viewportScrollPosition = this.viewport().nativeElement.scrollTop;\n\t\tif (\n\t\t\tviewportSize + viewportScrollPosition + SCROLLBY_PIXELS >\n\t\t\tthis.viewport().nativeElement.scrollHeight + SCROLLBY_PIXELS / 2\n\t\t) {\n\t\t\tthis.scrollDownBtn().stopEmittingEvents();\n\t\t}\n\t}\n}\n"]}

package/esm2022/select/lib/brn-select-group.directive.mjs

@@ -0,0 +1,19 @@
+import { Directive, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BrnSelectGroupDirective {
+    labelledBy = signal('');
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectGroupDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnSelectGroupDirective, isStandalone: true, selector: "[brnSelectGroup]", host: { attributes: { "role": "group" }, properties: { "attr.aria-labelledby": "labelledBy()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnSelectGroup]',
+                    standalone: true,
+                    host: {
+                        role: 'group',
+                        '[attr.aria-labelledby]': 'labelledBy()',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLXNlbGVjdC1ncm91cC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3NlbGVjdC9zcmMvbGliL2Jybi1zZWxlY3QtZ3JvdXAuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVVsRCxNQUFNLE9BQU8sdUJBQXVCO0lBQ25CLFVBQVUsR0FBRyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7MEhBRDVCLHVCQUF1Qjs4R0FBdkIsdUJBQXVCOzsyRkFBdkIsdUJBQXVCO2tCQVJuQyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixJQUFJLEVBQUU7d0JBQ0wsSUFBSSxFQUFFLE9BQU87d0JBQ2Isd0JBQXdCLEVBQUUsY0FBYztxQkFDeEM7aUJBQ0QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIHNpZ25hbCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcblx0c2VsZWN0b3I6ICdbYnJuU2VsZWN0R3JvdXBdJyxcblx0c3RhbmRhbG9uZTogdHJ1ZSxcblx0aG9zdDoge1xuXHRcdHJvbGU6ICdncm91cCcsXG5cdFx0J1thdHRyLmFyaWEtbGFiZWxsZWRieV0nOiAnbGFiZWxsZWRCeSgpJyxcblx0fSxcbn0pXG5leHBvcnQgY2xhc3MgQnJuU2VsZWN0R3JvdXBEaXJlY3RpdmUge1xuXHRwdWJsaWMgcmVhZG9ubHkgbGFiZWxsZWRCeSA9IHNpZ25hbCgnJyk7XG59XG4iXX0=

package/esm2022/select/lib/brn-select-label.directive.mjs

@@ -0,0 +1,23 @@
+import { Directive, inject } from '@angular/core';
+import { BrnLabelDirective } from '@spartan-ng/brain/label';
+import { BrnSelectGroupDirective } from './brn-select-group.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@spartan-ng/brain/label";
+export class BrnSelectLabelDirective {
+    _group = inject(BrnSelectGroupDirective, { optional: true });
+    _label = inject(BrnLabelDirective, { host: true });
+    constructor() {
+        this._group?.labelledBy.set(this._label.id());
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectLabelDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: BrnSelectLabelDirective, isStandalone: true, selector: "[brnSelectLabel]", hostDirectives: [{ directive: i1.BrnLabelDirective }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectLabelDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnSelectLabel]',
+                    hostDirectives: [BrnLabelDirective],
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJuLXNlbGVjdC1sYWJlbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3NlbGVjdC9zcmMvbGliL2Jybi1zZWxlY3QtbGFiZWwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2xELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzVELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDOzs7QUFPdkUsTUFBTSxPQUFPLHVCQUF1QjtJQUNsQixNQUFNLEdBQUcsTUFBTSxDQUFDLHVCQUF1QixFQUFFLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDN0QsTUFBTSxHQUFHLE1BQU0sQ0FBQyxpQkFBaUIsRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBRXBFO1FBQ0MsSUFBSSxDQUFDLE1BQU0sRUFBRSxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUMvQyxDQUFDOzBIQU5XLHVCQUF1Qjs4R0FBdkIsdUJBQXVCOzsyRkFBdkIsdUJBQXVCO2tCQUxuQyxTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxrQkFBa0I7b0JBQzVCLGNBQWMsRUFBRSxDQUFDLGlCQUFpQixDQUFDO29CQUNuQyxVQUFVLEVBQUUsSUFBSTtpQkFDaEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQnJuTGFiZWxEaXJlY3RpdmUgfSBmcm9tICdAc3BhcnRhbi1uZy9icmFpbi9sYWJlbCc7XG5pbXBvcnQgeyBCcm5TZWxlY3RHcm91cERpcmVjdGl2ZSB9IGZyb20gJy4vYnJuLXNlbGVjdC1ncm91cC5kaXJlY3RpdmUnO1xuXG5ARGlyZWN0aXZlKHtcblx0c2VsZWN0b3I6ICdbYnJuU2VsZWN0TGFiZWxdJyxcblx0aG9zdERpcmVjdGl2ZXM6IFtCcm5MYWJlbERpcmVjdGl2ZV0sXG5cdHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIEJyblNlbGVjdExhYmVsRGlyZWN0aXZlIHtcblx0cHJpdmF0ZSByZWFkb25seSBfZ3JvdXAgPSBpbmplY3QoQnJuU2VsZWN0R3JvdXBEaXJlY3RpdmUsIHsgb3B0aW9uYWw6IHRydWUgfSk7XG5cdHByaXZhdGUgcmVhZG9ubHkgX2xhYmVsID0gaW5qZWN0KEJybkxhYmVsRGlyZWN0aXZlLCB7IGhvc3Q6IHRydWUgfSk7XG5cblx0Y29uc3RydWN0b3IoKSB7XG5cdFx0dGhpcy5fZ3JvdXA/LmxhYmVsbGVkQnkuc2V0KHRoaXMuX2xhYmVsLmlkKCkpO1xuXHR9XG59XG4iXX0=

package/esm2022/select/lib/brn-select-option.directive.mjs

@@ -0,0 +1,65 @@
+import { CdkOption } from '@angular/cdk/listbox';
+import { Directive, ElementRef, booleanAttribute, computed, effect, inject, input, signal, } from '@angular/core';
+import { BrnSelectService } from './brn-select.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/listbox";
+export class BrnSelectOptionDirective {
+    _cdkSelectOption = inject(CdkOption, { host: true });
+    _selectService = inject(BrnSelectService);
+    _focused = signal(false);
+    elementRef = inject(ElementRef);
+    selected = computed(() => {
+        if (Array.isArray(this._selectService.value())) {
+            const itemFound = this._selectService.value().find((val) => val === this._cdkSelectOption.value);
+            return !!itemFound;
+        }
+        return this._cdkSelectOption.value === this._selectService.value();
+    });
+    focused = computed(() => this._focused());
+    checkedState = computed(() => (this.selected() ? 'checked' : 'unchecked'));
+    dir = computed(() => this._selectService.dir());
+    constructor() {
+        effect(() => {
+            this._cdkSelectOption.value = this.value();
+        });
+        effect(() => {
+            this._cdkSelectOption.disabled = this.disabledSignal();
+        });
+    }
+    ngAfterContentChecked() {
+        this._cdkSelectOption.value = this.value();
+    }
+    value = input(null);
+    // we use "disabledSignal" here because disabled is already defined in the FocusableOption interface
+    disabledSignal = input(false, {
+        alias: 'disabled',
+        transform: booleanAttribute,
+    });
+    hover() {
+        this.focus();
+    }
+    focus() {
+        this._cdkSelectOption.focus();
+        this._focused.set(true);
+    }
+    blur() {
+        this._focused.set(false);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectOptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: BrnSelectOptionDirective, isStandalone: true, selector: "[brnOption]", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, disabledSignal: { classPropertyName: "disabledSignal", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseenter": "hover()", "blur": "blur()" }, properties: { "attr.dir": "_selectService.dir()", "attr.data-disabled": "disabledSignal() ? '' : undefined" } }, hostDirectives: [{ directive: i1.CdkOption }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectOptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnOption]',
+                    standalone: true,
+                    hostDirectives: [CdkOption],
+                    host: {
+                        '(mouseenter)': 'hover()',
+                        '(blur)': 'blur()',
+                        '[attr.dir]': '_selectService.dir()',
+                        '[attr.data-disabled]': "disabledSignal() ? '' : undefined",
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/select/lib/brn-select-value.component.mjs

@@ -0,0 +1,46 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, computed, inject, input } from '@angular/core';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { BrnSelectService } from './brn-select.service';
+import * as i0 from "@angular/core";
+export class BrnSelectValueComponent {
+    _selectService = inject(BrnSelectService);
+    id = computed(() => `${this._selectService.id()}--value`);
+    placeholder = computed(() => this._selectService.placeholder());
+    value = null;
+    transformFn = input((values) => (values ?? []).join(', '));
+    constructor() {
+        const cdr = inject(ChangeDetectorRef);
+        // In certain cases (when using a computed signal for value) where the value of the select and the options are
+        // changed dynamically, the template does not update until the next frame. To work around this we can use a simple
+        // string variable in the template and manually trigger change detection when we update it.
+        toObservable(this._selectService.selectedOptions)
+            .pipe(takeUntilDestroyed())
+            .subscribe((value) => {
+            if (value.length === 0) {
+                this.value = null;
+                cdr.detectChanges();
+                return;
+            }
+            const selectedLabels = value.map((selectedOption) => selectedOption?.getLabel());
+            if (this._selectService.dir() === 'rtl') {
+                selectedLabels.reverse();
+            }
+            const result = this.transformFn()(selectedLabels);
+            this.value = result;
+            cdr.detectChanges();
+        });
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectValueComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.5", type: BrnSelectValueComponent, isStandalone: true, selector: "brn-select-value, hlm-select-value", inputs: { transformFn: { classPropertyName: "transformFn", publicName: "transformFn", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "id": "id()" } }, ngImport: i0, template: `
+		{{ value || placeholder() }}
+	`, isInline: true, styles: [":host{display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:1;white-space:nowrap;pointer-events:none}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectValueComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'brn-select-value, hlm-select-value', template: `
+		{{ value || placeholder() }}
+	`, host: {
+                        '[id]': 'id()',
+                    }, standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:1;white-space:nowrap;pointer-events:none}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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