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

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

@@ -0,0 +1,358 @@
+import { CdkListbox, CdkListboxModule, CdkOption } from '@angular/cdk/listbox';
+import { CdkConnectedOverlay, OverlayModule, } from '@angular/cdk/overlay';
+import { ChangeDetectionStrategy, Component, computed, contentChild, contentChildren, inject, input, output, signal, viewChild, } from '@angular/core';
+import { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { BrnFormFieldControl } from '@spartan-ng/brain/form-field';
+import { ErrorStateMatcher, ErrorStateTracker } from '@spartan-ng/brain/forms';
+import { BrnLabelDirective } from '@spartan-ng/brain/label';
+import { provideExposedSideProviderExisting, provideExposesStateProviderExisting, } from '@spartan-ng/ui-core';
+import { Subject, combineLatest, delay, map, of, switchMap } from 'rxjs';
+import { BrnSelectContentComponent } from './brn-select-content.component';
+import { BrnSelectService } from './brn-select.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+let nextId = 0;
+export class BrnSelectComponent {
+    _selectService = inject(BrnSelectService);
+    triggerWidth = this._selectService.triggerWidth;
+    multiple = input(false);
+    placeholder = input('');
+    disabled = input(false);
+    dir = input('ltr');
+    _disabledFromSetDisabledState = signal(false);
+    selectLabel = contentChild(BrnLabelDirective, { descendants: false });
+    /** Overlay pane containing the options. */
+    selectContent = contentChild.required(BrnSelectContentComponent);
+    options = contentChildren(CdkOption, { descendants: true });
+    options$ = toObservable(this.options);
+    optionsAndIndex$ = this.options$.pipe(map((options, index) => [options, index]));
+    /** Overlay pane containing the options. */
+    _overlayDir = viewChild(CdkConnectedOverlay);
+    openedChange = output();
+    closeDelay = input(100);
+    isExpanded = this._selectService.isExpanded;
+    _delayedExpanded = toSignal(toObservable(this.isExpanded).pipe(switchMap((expanded) => (!expanded ? of(expanded).pipe(delay(this.closeDelay())) : of(expanded))), takeUntilDestroyed()), { initialValue: false });
+    state = computed(() => (this.isExpanded() ? 'open' : 'closed'));
+    _positionChanges$ = new Subject();
+    side = toSignal(this._positionChanges$.pipe(map((change) => 
+    // todo: better translation or adjusting hlm to take that into account
+    change.connectionPair.originY === 'center'
+        ? change.connectionPair.originX === 'start'
+            ? 'left'
+            : 'right'
+        : change.connectionPair.originY)), { initialValue: 'bottom' });
+    backupLabelId = computed(() => this._selectService.labelId());
+    labelProvided = signal(false);
+    ngControl = inject(NgControl, { optional: true, self: true });
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _onChange = () => { };
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _onTouched = () => { };
+    _shouldEmitValueChange = signal(false);
+    /*
+     * This position config ensures that the top "start" corner of the overlay
+     * is aligned with with the top "start" of the origin by default (overlapping
+     * the trigger completely). If the panel cannot fit below the trigger, it
+     * will fall back to a position above the trigger.
+     */
+    _positions = [
+        {
+            originX: 'start',
+            originY: 'bottom',
+            overlayX: 'start',
+            overlayY: 'top',
+        },
+        {
+            originX: 'end',
+            originY: 'bottom',
+            overlayX: 'end',
+            overlayY: 'top',
+        },
+        {
+            originX: 'start',
+            originY: 'top',
+            overlayX: 'start',
+            overlayY: 'bottom',
+        },
+        {
+            originX: 'end',
+            originY: 'top',
+            overlayX: 'end',
+            overlayY: 'bottom',
+        },
+    ];
+    errorStateTracker;
+    _defaultErrorStateMatcher = inject(ErrorStateMatcher);
+    _parentForm = inject(NgForm, { optional: true });
+    _parentFormGroup = inject(FormGroupDirective, { optional: true });
+    errorState = computed(() => this.errorStateTracker.errorState());
+    writeValue$ = new Subject();
+    constructor() {
+        this._selectService.state.update((state) => ({
+            ...state,
+            multiple: this.multiple,
+            placeholder: this.placeholder,
+            disabled: this.disabled,
+            disabledBySetDisabled: this._disabledFromSetDisabledState,
+            dir: this.dir,
+        }));
+        this.handleOptionChanges();
+        this.handleInitialOptionSelect();
+        this._selectService.state.update((state) => ({
+            ...state,
+            id: `brn-select-${nextId++}`,
+        }));
+        if (this.ngControl !== null) {
+            this.ngControl.valueAccessor = this;
+        }
+        // Watch for Listbox Selection Changes to trigger Collapse and Value Change
+        this._selectService.listBoxValueChangeEvent$.pipe(takeUntilDestroyed()).subscribe(() => {
+            if (!this.multiple()) {
+                this.close();
+            }
+            // we set shouldEmitValueChange to true because we want to propagate the value change
+            // as a result of user interaction
+            this._shouldEmitValueChange.set(true);
+        });
+        /**
+         * Listening to value changes in order to trigger forms api on change
+         * ShouldEmitValueChange simply ensures we only propagate value change when a user makes a selection
+         * we don't propagate changes made from outside the component (ex. patch value or initial value from form control)
+         */
+        toObservable(this._selectService.value).subscribe((value) => {
+            if (this._shouldEmitValueChange()) {
+                this._onChange((value ?? null));
+            }
+            this._shouldEmitValueChange.set(true);
+        });
+        this.errorStateTracker = new ErrorStateTracker(this._defaultErrorStateMatcher, this.ngControl, this._parentFormGroup, this._parentForm);
+    }
+    ngAfterContentInit() {
+        // Check if Label Directive Provided and pass to service
+        const label = this.selectLabel();
+        if (label) {
+            this.labelProvided.set(true);
+            this._selectService.state.update((state) => ({
+                ...state,
+                labelId: label.id(),
+            }));
+        }
+        else if (this.placeholder()) {
+            this._selectService.state.update((state) => ({
+                ...state,
+                labelId: `${state.id}--label`,
+            }));
+        }
+    }
+    ngDoCheck() {
+        this.errorStateTracker.updateErrorState();
+    }
+    toggle() {
+        if (this.isExpanded()) {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    open() {
+        if (!this._canOpen())
+            return;
+        this._selectService.state.update((state) => ({
+            ...state,
+            isExpanded: true,
+        }));
+        this.openedChange.emit(true);
+        this._moveFocusToCDKList();
+    }
+    close() {
+        if (!this.isExpanded())
+            return;
+        if (this._selectService.selectTrigger) {
+            this._selectService.selectTrigger.focus();
+        }
+        this.openedChange.emit(false);
+        this._selectService.state.update((state) => ({
+            ...state,
+            isExpanded: false,
+        }));
+        this._onTouched();
+    }
+    _canOpen() {
+        return !this.isExpanded() && !this.disabled() && this.options()?.length > 0;
+    }
+    _moveFocusToCDKList() {
+        setTimeout(() => {
+            this.selectContent()?.focusList();
+        });
+    }
+    writeValue(value) {
+        this.writeValue$.next(value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this._disabledFromSetDisabledState.set(isDisabled);
+    }
+    /**
+     * Once writeValue is called and options are available we can handle setting the initial options
+     * @private
+     */
+    handleInitialOptionSelect() {
+        // Write value cannot be handled until options are available, so we wait until both are available with a combineLatest
+        combineLatest([this.writeValue$, this.options$])
+            .pipe(map((values, index) => [...values, index]), takeUntilDestroyed())
+            .subscribe(([value, _, index]) => {
+            this._shouldEmitValueChange.set(false);
+            this._selectService.setInitialSelectedOptions(value);
+            // the first time this observable emits a value we are simply setting the initial state
+            // this change should not count as changing the state of the select, so we need to mark as pristine
+            if (index === 0) {
+                this.ngControl?.control?.markAsPristine();
+            }
+        });
+    }
+    /**
+     * When options change, our current selected options may become invalid
+     * Here we will automatically update our current selected options so that they are always inline with the possibleOptions
+     * @private
+     */
+    handleOptionChanges() {
+        this.optionsAndIndex$.pipe(takeUntilDestroyed()).subscribe(([options, index]) => {
+            if (index > 0) {
+                this.handleInvalidOptions(options);
+            }
+            this.updatePossibleOptions(options);
+        });
+    }
+    /**
+     * Check that our "selectedOptions" are still valid when "possibleOptions" is about to be updated
+     */
+    handleInvalidOptions(options) {
+        const selectedOptions = this._selectService.selectedOptions();
+        const availableOptionSet = new Set(options);
+        if (this._selectService.multiple()) {
+            const filteredOptions = selectedOptions.filter((o) => availableOptionSet.has(o));
+            // only update if there was an actual change
+            if (selectedOptions.length !== filteredOptions.length) {
+                // update should result in a value change since we are deselecting a value
+                this._shouldEmitValueChange.set(true);
+                const value = filteredOptions.map((o) => o?.value ?? '');
+                this._selectService.state.update((state) => ({
+                    ...state,
+                    selectedOptions: filteredOptions,
+                    value: value,
+                }));
+                this._onChange((value ?? null));
+            }
+        }
+        else {
+            const selectedOption = selectedOptions[0] ?? null;
+            if (selectedOption !== null && !availableOptionSet.has(selectedOption)) {
+                this._shouldEmitValueChange.set(true);
+                this._selectService.state.update((state) => ({
+                    ...state,
+                    selectedOptions: [],
+                    value: '',
+                }));
+                this._onChange('');
+            }
+        }
+    }
+    /**
+     * Sync the updated options with "possibleOptions" in the select service
+     */
+    updatePossibleOptions(options) {
+        this._selectService.state.update((state) => ({
+            ...state,
+            possibleOptions: options,
+        }));
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: BrnSelectComponent, isStandalone: true, selector: "brn-select, hlm-select", inputs: { multiple: { classPropertyName: "multiple", publicName: "multiple", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, dir: { classPropertyName: "dir", publicName: "dir", isSignal: true, isRequired: false, transformFunction: null }, closeDelay: { classPropertyName: "closeDelay", publicName: "closeDelay", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { openedChange: "openedChange" }, providers: [
+            BrnSelectService,
+            CdkListbox,
+            provideExposedSideProviderExisting((() => BrnSelectComponent)),
+            provideExposesStateProviderExisting((() => BrnSelectComponent)),
+            {
+                provide: BrnFormFieldControl,
+                useExisting: BrnSelectComponent,
+            },
+        ], queries: [{ propertyName: "selectLabel", first: true, predicate: BrnLabelDirective, isSignal: true }, { propertyName: "selectContent", first: true, predicate: BrnSelectContentComponent, descendants: true, isSignal: true }, { propertyName: "options", predicate: CdkOption, descendants: true, isSignal: true }], viewQueries: [{ propertyName: "_overlayDir", first: true, predicate: CdkConnectedOverlay, descendants: true, isSignal: true }], ngImport: i0, template: `
+		@if (!labelProvided() && placeholder()) {
+			<label class="hidden" [attr.id]="backupLabelId()">{{ placeholder() }}</label>
+		} @else {
+			<ng-content select="label[hlmLabel],label[brnLabel]" />
+		}
+
+		<div cdk-overlay-origin (click)="toggle()" #trigger="cdkOverlayOrigin">
+			<ng-content select="hlm-select-trigger,[brnSelectTrigger]" />
+		</div>
+		<ng-template
+			cdk-connected-overlay
+			cdkConnectedOverlayLockPosition
+			cdkConnectedOverlayHasBackdrop
+			cdkConnectedOverlayBackdropClass="cdk-overlay-transparent-backdrop"
+			[cdkConnectedOverlayOrigin]="trigger"
+			[cdkConnectedOverlayOpen]="_delayedExpanded()"
+			[cdkConnectedOverlayPositions]="_positions"
+			[cdkConnectedOverlayWidth]="triggerWidth() > 0 ? triggerWidth() : 'auto'"
+			(backdropClick)="close()"
+			(detach)="close()"
+			(positionChange)="_positionChanges$.next($event)"
+		>
+			<ng-content />
+		</ng-template>
+	`, isInline: true, dependencies: [{ kind: "ngmodule", type: OverlayModule }, { kind: "directive", type: i1.CdkConnectedOverlay, selector: "[cdk-connected-overlay], [connected-overlay], [cdkConnectedOverlay]", inputs: ["cdkConnectedOverlayOrigin", "cdkConnectedOverlayPositions", "cdkConnectedOverlayPositionStrategy", "cdkConnectedOverlayOffsetX", "cdkConnectedOverlayOffsetY", "cdkConnectedOverlayWidth", "cdkConnectedOverlayHeight", "cdkConnectedOverlayMinWidth", "cdkConnectedOverlayMinHeight", "cdkConnectedOverlayBackdropClass", "cdkConnectedOverlayPanelClass", "cdkConnectedOverlayViewportMargin", "cdkConnectedOverlayScrollStrategy", "cdkConnectedOverlayOpen", "cdkConnectedOverlayDisableClose", "cdkConnectedOverlayTransformOriginOn", "cdkConnectedOverlayHasBackdrop", "cdkConnectedOverlayLockPosition", "cdkConnectedOverlayFlexibleDimensions", "cdkConnectedOverlayGrowAfterOpen", "cdkConnectedOverlayPush", "cdkConnectedOverlayDisposeOnNavigation"], outputs: ["backdropClick", "positionChange", "attach", "detach", "overlayKeydown", "overlayOutsideClick"], exportAs: ["cdkConnectedOverlay"] }, { kind: "directive", type: i1.CdkOverlayOrigin, selector: "[cdk-overlay-origin], [overlay-origin], [cdkOverlayOrigin]", exportAs: ["cdkOverlayOrigin"] }, { kind: "ngmodule", type: CdkListboxModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnSelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-select, hlm-select',
+                    standalone: true,
+                    imports: [OverlayModule, CdkListboxModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        BrnSelectService,
+                        CdkListbox,
+                        provideExposedSideProviderExisting((() => BrnSelectComponent)),
+                        provideExposesStateProviderExisting((() => BrnSelectComponent)),
+                        {
+                            provide: BrnFormFieldControl,
+                            useExisting: BrnSelectComponent,
+                        },
+                    ],
+                    template: `
+		@if (!labelProvided() && placeholder()) {
+			<label class="hidden" [attr.id]="backupLabelId()">{{ placeholder() }}</label>
+		} @else {
+			<ng-content select="label[hlmLabel],label[brnLabel]" />
+		}
+
+		<div cdk-overlay-origin (click)="toggle()" #trigger="cdkOverlayOrigin">
+			<ng-content select="hlm-select-trigger,[brnSelectTrigger]" />
+		</div>
+		<ng-template
+			cdk-connected-overlay
+			cdkConnectedOverlayLockPosition
+			cdkConnectedOverlayHasBackdrop
+			cdkConnectedOverlayBackdropClass="cdk-overlay-transparent-backdrop"
+			[cdkConnectedOverlayOrigin]="trigger"
+			[cdkConnectedOverlayOpen]="_delayedExpanded()"
+			[cdkConnectedOverlayPositions]="_positions"
+			[cdkConnectedOverlayWidth]="triggerWidth() > 0 ? triggerWidth() : 'auto'"
+			(backdropClick)="close()"
+			(detach)="close()"
+			(positionChange)="_positionChanges$.next($event)"
+		>
+			<ng-content />
+		</ng-template>
+	`,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-select.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/select/src/lib/brn-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkListbox, CdkListboxModule, CdkOption } from '@angular/cdk/listbox';\nimport {\n\tCdkConnectedOverlay,\n\ttype ConnectedOverlayPositionChange,\n\ttype ConnectedPosition,\n\tOverlayModule,\n} from '@angular/cdk/overlay';\nimport {\n\tAfterContentInit,\n\tChangeDetectionStrategy,\n\tComponent,\n\ttype DoCheck,\n\ttype Signal,\n\tcomputed,\n\tcontentChild,\n\tcontentChildren,\n\tinject,\n\tinput,\n\toutput,\n\tsignal,\n\tviewChild,\n} from '@angular/core';\nimport { takeUntilDestroyed, toObservable, toSignal } from '@angular/core/rxjs-interop';\nimport { type ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';\nimport { BrnFormFieldControl } from '@spartan-ng/brain/form-field';\nimport { ChangeFn, ErrorStateMatcher, ErrorStateTracker, TouchFn } from '@spartan-ng/brain/forms';\nimport { BrnLabelDirective } from '@spartan-ng/brain/label';\nimport {\n\ttype ExposesSide,\n\ttype ExposesState,\n\tprovideExposedSideProviderExisting,\n\tprovideExposesStateProviderExisting,\n} from '@spartan-ng/ui-core';\nimport { Subject, combineLatest, delay, map, of, switchMap } from 'rxjs';\nimport { BrnSelectContentComponent } from './brn-select-content.component';\nimport { BrnSelectService } from './brn-select.service';\n\nexport type BrnReadDirection = 'ltr' | 'rtl';\n\nlet nextId = 0;\n\n@Component({\n\tselector: 'brn-select, hlm-select',\n\tstandalone: true,\n\timports: [OverlayModule, CdkListboxModule],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tproviders: [\n\t\tBrnSelectService,\n\t\tCdkListbox,\n\t\tprovideExposedSideProviderExisting(() => BrnSelectComponent),\n\t\tprovideExposesStateProviderExisting(() => BrnSelectComponent),\n\t\t{\n\t\t\tprovide: BrnFormFieldControl,\n\t\t\tuseExisting: BrnSelectComponent,\n\t\t},\n\t],\n\ttemplate: `\n\t\t@if (!labelProvided() && placeholder()) {\n\t\t\t<label class=\"hidden\" [attr.id]=\"backupLabelId()\">{{ placeholder() }}</label>\n\t\t} @else {\n\t\t\t<ng-content select=\"label[hlmLabel],label[brnLabel]\" />\n\t\t}\n\n\t\t<div cdk-overlay-origin (click)=\"toggle()\" #trigger=\"cdkOverlayOrigin\">\n\t\t\t<ng-content select=\"hlm-select-trigger,[brnSelectTrigger]\" />\n\t\t</div>\n\t\t<ng-template\n\t\t\tcdk-connected-overlay\n\t\t\tcdkConnectedOverlayLockPosition\n\t\t\tcdkConnectedOverlayHasBackdrop\n\t\t\tcdkConnectedOverlayBackdropClass=\"cdk-overlay-transparent-backdrop\"\n\t\t\t[cdkConnectedOverlayOrigin]=\"trigger\"\n\t\t\t[cdkConnectedOverlayOpen]=\"_delayedExpanded()\"\n\t\t\t[cdkConnectedOverlayPositions]=\"_positions\"\n\t\t\t[cdkConnectedOverlayWidth]=\"triggerWidth() > 0 ? triggerWidth() : 'auto'\"\n\t\t\t(backdropClick)=\"close()\"\n\t\t\t(detach)=\"close()\"\n\t\t\t(positionChange)=\"_positionChanges$.next($event)\"\n\t\t>\n\t\t\t<ng-content />\n\t\t</ng-template>\n\t`,\n})\nexport class BrnSelectComponent<T = unknown>\n\timplements ControlValueAccessor, AfterContentInit, DoCheck, ExposesSide, ExposesState, BrnFormFieldControl\n{\n\tprivate readonly _selectService = inject(BrnSelectService);\n\n\tpublic readonly triggerWidth = this._selectService.triggerWidth;\n\n\tpublic readonly multiple = input<boolean>(false);\n\tpublic readonly placeholder = input<string>('');\n\tpublic readonly disabled = input<boolean>(false);\n\tpublic readonly dir = input<BrnReadDirection>('ltr');\n\tprivate readonly _disabledFromSetDisabledState = signal(false);\n\n\tprotected selectLabel = contentChild(BrnLabelDirective, { descendants: false });\n\t/** Overlay pane containing the options. */\n\tprotected selectContent = contentChild.required(BrnSelectContentComponent);\n\n\tprotected options = contentChildren(CdkOption, { descendants: true });\n\tprotected options$ = toObservable(this.options);\n\tprotected optionsAndIndex$ = this.options$.pipe(map((options, index) => [options, index] as const));\n\n\t/** Overlay pane containing the options. */\n\tprotected _overlayDir = viewChild(CdkConnectedOverlay);\n\n\tpublic readonly openedChange = output<boolean>();\n\n\tpublic readonly closeDelay = input<number>(100);\n\tpublic readonly isExpanded = this._selectService.isExpanded;\n\tprotected readonly _delayedExpanded = toSignal(\n\t\ttoObservable(this.isExpanded).pipe(\n\t\t\tswitchMap((expanded) => (!expanded ? of(expanded).pipe(delay(this.closeDelay())) : of(expanded))),\n\t\t\ttakeUntilDestroyed(),\n\t\t),\n\t\t{ initialValue: false },\n\t);\n\tpublic readonly state = computed(() => (this.isExpanded() ? 'open' : 'closed'));\n\n\tprotected readonly _positionChanges$ = new Subject<ConnectedOverlayPositionChange>();\n\tpublic readonly side: Signal<'top' | 'bottom' | 'left' | 'right'> = toSignal(\n\t\tthis._positionChanges$.pipe(\n\t\t\tmap<ConnectedOverlayPositionChange, 'top' | 'bottom' | 'left' | 'right'>((change) =>\n\t\t\t\t// todo: better translation or adjusting hlm to take that into account\n\t\t\t\tchange.connectionPair.originY === 'center'\n\t\t\t\t\t? change.connectionPair.originX === 'start'\n\t\t\t\t\t\t? 'left'\n\t\t\t\t\t\t: 'right'\n\t\t\t\t\t: change.connectionPair.originY,\n\t\t\t),\n\t\t),\n\t\t{ initialValue: 'bottom' },\n\t);\n\n\tpublic readonly backupLabelId = computed(() => this._selectService.labelId());\n\tpublic readonly labelProvided = signal(false);\n\n\tpublic readonly ngControl = inject(NgControl, { optional: true, self: true });\n\n\t// eslint-disable-next-line @typescript-eslint/no-empty-function\n\tprivate _onChange: ChangeFn<T> = () => {};\n\t// eslint-disable-next-line @typescript-eslint/no-empty-function\n\tprivate _onTouched: TouchFn = () => {};\n\n\tprivate readonly _shouldEmitValueChange = signal(false);\n\n\t/*\n\t * This position config ensures that the top \"start\" corner of the overlay\n\t * is aligned with with the top \"start\" of the origin by default (overlapping\n\t * the trigger completely). If the panel cannot fit below the trigger, it\n\t * will fall back to a position above the trigger.\n\t */\n\tprotected _positions: ConnectedPosition[] = [\n\t\t{\n\t\t\toriginX: 'start',\n\t\t\toriginY: 'bottom',\n\t\t\toverlayX: 'start',\n\t\t\toverlayY: 'top',\n\t\t},\n\t\t{\n\t\t\toriginX: 'end',\n\t\t\toriginY: 'bottom',\n\t\t\toverlayX: 'end',\n\t\t\toverlayY: 'top',\n\t\t},\n\t\t{\n\t\t\toriginX: 'start',\n\t\t\toriginY: 'top',\n\t\t\toverlayX: 'start',\n\t\t\toverlayY: 'bottom',\n\t\t},\n\t\t{\n\t\t\toriginX: 'end',\n\t\t\toriginY: 'top',\n\t\t\toverlayX: 'end',\n\t\t\toverlayY: 'bottom',\n\t\t},\n\t];\n\n\tpublic errorStateTracker: ErrorStateTracker;\n\n\tprivate readonly _defaultErrorStateMatcher = inject(ErrorStateMatcher);\n\tprivate readonly _parentForm = inject(NgForm, { optional: true });\n\tprivate readonly _parentFormGroup = inject(FormGroupDirective, { optional: true });\n\n\tpublic errorState = computed(() => this.errorStateTracker.errorState());\n\n\tpublic writeValue$ = new Subject<T>();\n\n\tconstructor() {\n\t\tthis._selectService.state.update((state) => ({\n\t\t\t...state,\n\t\t\tmultiple: this.multiple,\n\t\t\tplaceholder: this.placeholder,\n\t\t\tdisabled: this.disabled,\n\t\t\tdisabledBySetDisabled: this._disabledFromSetDisabledState,\n\t\t\tdir: this.dir,\n\t\t}));\n\t\tthis.handleOptionChanges();\n\t\tthis.handleInitialOptionSelect();\n\n\t\tthis._selectService.state.update((state) => ({\n\t\t\t...state,\n\t\t\tid: `brn-select-${nextId++}`,\n\t\t}));\n\t\tif (this.ngControl !== null) {\n\t\t\tthis.ngControl.valueAccessor = this;\n\t\t}\n\n\t\t// Watch for Listbox Selection Changes to trigger Collapse and Value Change\n\t\tthis._selectService.listBoxValueChangeEvent$.pipe(takeUntilDestroyed()).subscribe(() => {\n\t\t\tif (!this.multiple()) {\n\t\t\t\tthis.close();\n\t\t\t}\n\n\t\t\t// we set shouldEmitValueChange to true because we want to propagate the value change\n\t\t\t// as a result of user interaction\n\t\t\tthis._shouldEmitValueChange.set(true);\n\t\t});\n\n\t\t/**\n\t\t * Listening to value changes in order to trigger forms api on change\n\t\t * ShouldEmitValueChange simply ensures we only propagate value change when a user makes a selection\n\t\t * we don't propagate changes made from outside the component (ex. patch value or initial value from form control)\n\t\t */\n\t\ttoObservable(this._selectService.value).subscribe((value) => {\n\t\t\tif (this._shouldEmitValueChange()) {\n\t\t\t\tthis._onChange((value ?? null) as T);\n\t\t\t}\n\t\t\tthis._shouldEmitValueChange.set(true);\n\t\t});\n\n\t\tthis.errorStateTracker = new ErrorStateTracker(\n\t\t\tthis._defaultErrorStateMatcher,\n\t\t\tthis.ngControl,\n\t\t\tthis._parentFormGroup,\n\t\t\tthis._parentForm,\n\t\t);\n\t}\n\n\tpublic ngAfterContentInit(): void {\n\t\t// Check if Label Directive Provided and pass to service\n\t\tconst label = this.selectLabel();\n\t\tif (label) {\n\t\t\tthis.labelProvided.set(true);\n\t\t\tthis._selectService.state.update((state) => ({\n\t\t\t\t...state,\n\t\t\t\tlabelId: label.id(),\n\t\t\t}));\n\t\t} else if (this.placeholder()) {\n\t\t\tthis._selectService.state.update((state) => ({\n\t\t\t\t...state,\n\t\t\t\tlabelId: `${state.id}--label`,\n\t\t\t}));\n\t\t}\n\t}\n\n\tngDoCheck() {\n\t\tthis.errorStateTracker.updateErrorState();\n\t}\n\n\tpublic toggle(): void {\n\t\tif (this.isExpanded()) {\n\t\t\tthis.close();\n\t\t} else {\n\t\t\tthis.open();\n\t\t}\n\t}\n\n\tpublic open(): void {\n\t\tif (!this._canOpen()) return;\n\t\tthis._selectService.state.update((state) => ({\n\t\t\t...state,\n\t\t\tisExpanded: true,\n\t\t}));\n\t\tthis.openedChange.emit(true);\n\t\tthis._moveFocusToCDKList();\n\t}\n\n\tpublic close(): void {\n\t\tif (!this.isExpanded()) return;\n\n\t\tif (this._selectService.selectTrigger) {\n\t\t\tthis._selectService.selectTrigger.focus();\n\t\t}\n\n\t\tthis.openedChange.emit(false);\n\t\tthis._selectService.state.update((state) => ({\n\t\t\t...state,\n\t\t\tisExpanded: false,\n\t\t}));\n\t\tthis._onTouched();\n\t}\n\n\tprotected _canOpen(): boolean {\n\t\treturn !this.isExpanded() && !this.disabled() && this.options()?.length > 0;\n\t}\n\n\tprivate _moveFocusToCDKList(): void {\n\t\tsetTimeout(() => {\n\t\t\tthis.selectContent()?.focusList();\n\t\t});\n\t}\n\n\tpublic writeValue(value: T): void {\n\t\tthis.writeValue$.next(value);\n\t}\n\n\tpublic registerOnChange(fn: ChangeFn<T>): void {\n\t\tthis._onChange = fn;\n\t}\n\n\tpublic registerOnTouched(fn: TouchFn): void {\n\t\tthis._onTouched = fn;\n\t}\n\n\tpublic setDisabledState(isDisabled: boolean) {\n\t\tthis._disabledFromSetDisabledState.set(isDisabled);\n\t}\n\n\t/**\n\t * Once writeValue is called and options are available we can handle setting the initial options\n\t * @private\n\t */\n\tprivate handleInitialOptionSelect() {\n\t\t// Write value cannot be handled until options are available, so we wait until both are available with a combineLatest\n\t\tcombineLatest([this.writeValue$, this.options$])\n\t\t\t.pipe(\n\t\t\t\tmap((values, index) => [...values, index]),\n\t\t\t\ttakeUntilDestroyed(),\n\t\t\t)\n\t\t\t.subscribe(([value, _, index]) => {\n\t\t\t\tthis._shouldEmitValueChange.set(false);\n\t\t\t\tthis._selectService.setInitialSelectedOptions(value);\n\t\t\t\t// the first time this observable emits a value we are simply setting the initial state\n\t\t\t\t// this change should not count as changing the state of the select, so we need to mark as pristine\n\t\t\t\tif (index === 0) {\n\t\t\t\t\tthis.ngControl?.control?.markAsPristine();\n\t\t\t\t}\n\t\t\t});\n\t}\n\n\t/**\n\t * When options change, our current selected options may become invalid\n\t * Here we will automatically update our current selected options so that they are always inline with the possibleOptions\n\t * @private\n\t */\n\tprivate handleOptionChanges() {\n\t\tthis.optionsAndIndex$.pipe(takeUntilDestroyed()).subscribe(([options, index]) => {\n\t\t\tif (index > 0) {\n\t\t\t\tthis.handleInvalidOptions(options);\n\t\t\t}\n\t\t\tthis.updatePossibleOptions(options);\n\t\t});\n\t}\n\n\t/**\n\t * Check that our \"selectedOptions\" are still valid when \"possibleOptions\" is about to be updated\n\t */\n\tprivate handleInvalidOptions(options: readonly CdkOption[]) {\n\t\tconst selectedOptions = this._selectService.selectedOptions();\n\t\tconst availableOptionSet = new Set<CdkOption | null>(options);\n\t\tif (this._selectService.multiple()) {\n\t\t\tconst filteredOptions = selectedOptions.filter((o) => availableOptionSet.has(o));\n\t\t\t// only update if there was an actual change\n\t\t\tif (selectedOptions.length !== filteredOptions.length) {\n\t\t\t\t// update should result in a value change since we are deselecting a value\n\t\t\t\tthis._shouldEmitValueChange.set(true);\n\t\t\t\tconst value = filteredOptions.map((o) => (o?.value as string) ?? '');\n\t\t\t\tthis._selectService.state.update((state) => ({\n\t\t\t\t\t...state,\n\t\t\t\t\tselectedOptions: filteredOptions,\n\t\t\t\t\tvalue: value,\n\t\t\t\t}));\n\t\t\t\tthis._onChange((value ?? null) as T);\n\t\t\t}\n\t\t} else {\n\t\t\tconst selectedOption = selectedOptions[0] ?? null;\n\t\t\tif (selectedOption !== null && !availableOptionSet.has(selectedOption)) {\n\t\t\t\tthis._shouldEmitValueChange.set(true);\n\t\t\t\tthis._selectService.state.update((state) => ({\n\t\t\t\t\t...state,\n\t\t\t\t\tselectedOptions: [],\n\t\t\t\t\tvalue: '',\n\t\t\t\t}));\n\t\t\t\tthis._onChange('' as T);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Sync the updated options with \"possibleOptions\" in the select service\n\t */\n\tprivate updatePossibleOptions(options: readonly CdkOption[]) {\n\t\tthis._selectService.state.update((state) => ({\n\t\t\t...state,\n\t\t\tpossibleOptions: options as CdkOption[],\n\t\t}));\n\t}\n}\n"]}