@recursyve/ngx-material-components 18.0.0-beta.0

package/esm2022/typeahead/typeahead-base.mjs

@@ -0,0 +1,456 @@
+import { ActiveDescendantKeyManager } from "@angular/cdk/a11y";
+import { SelectionModel } from "@angular/cdk/collections";
+import { DOWN_ARROW, ENTER, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW } from "@angular/cdk/keycodes";
+import { CdkConnectedOverlay, CdkOverlayOrigin } from "@angular/cdk/overlay";
+import { ChangeDetectorRef, computed, DestroyRef, Directive, effect, ElementRef, inject, input, signal, viewChild, ViewChildren } from "@angular/core";
+import { takeUntilDestroyed } from "@angular/core/rxjs-interop";
+import { FormBuilder, NgControl } from "@angular/forms";
+import { _getOptionScrollPosition, MatOption } from "@angular/material/core";
+import { MAT_FORM_FIELD } from "@angular/material/form-field";
+import { debounceTime, defer, distinctUntilChanged, merge, startWith, Subject, switchMap, take, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+/**
+ * Implementation of the same panel and overlay logic as the official Angular MatSelect.
+ * This used some of the logic from MatSelect to make this component look and feel like a MatSelect.
+ */
+export class NiceTypeaheadBase {
+    options;
+    labelProperty = input();
+    formatLabelFn = input();
+    static nextId = 0;
+    _input = viewChild("input");
+    _panel = viewChild("panel");
+    _overlayDir = viewChild(CdkConnectedOverlay);
+    _focused = false;
+    _required = false;
+    _disabled = false;
+    _panelOpen = false;
+    _compareWith = (o1, o2) => o1 === o2;
+    _value = signal(null);
+    _empty = computed(() => !this._value());
+    _placeholder = signal("");
+    _searchValue = signal("");
+    _elementRef = inject(ElementRef);
+    _destroyRef = inject(DestroyRef);
+    _changeDetectorRef = inject(ChangeDetectorRef);
+    _fb = inject(FormBuilder);
+    _searchControl = this._fb.nonNullable.control("");
+    _initialized = new Subject();
+    _parentFormField = inject(MAT_FORM_FIELD, { optional: true });
+    id = `nice-typeahead-${NiceTypeaheadBase.nextId++}`;
+    controlType = "nice-typeahead";
+    stateChanges = new Subject();
+    optionSelectionChanges = defer(() => {
+        const options = this.options;
+        if (options) {
+            return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.onSelectionChange))));
+        }
+        return this._initialized.pipe(switchMap(() => this.optionSelectionChanges));
+    });
+    ngControl = inject(NgControl, { optional: true, self: true });
+    _panelDoneAnimatingStream = new Subject();
+    _keyManager;
+    _preferredOverlayOrigin;
+    _overlayWidth;
+    _selectionModel;
+    _onChange;
+    _onTouch;
+    get placeholder() {
+        return this._placeholder();
+    }
+    set placeholder(placeholder) {
+        this._placeholder.set(placeholder);
+        this.stateChanges.next();
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(isFocused) {
+        this._focused = isFocused;
+        this.stateChanges.next();
+    }
+    get required() {
+        return this._required;
+    }
+    set required(isRequired) {
+        this._required = isRequired;
+        this.stateChanges.next();
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = value;
+        this.stateChanges.next();
+    }
+    get value() {
+        return this._value();
+    }
+    set value(value) {
+        const hasAssigned = this._assignValue(value);
+        if (hasAssigned) {
+            this._onChange?.(value);
+        }
+    }
+    get empty() {
+        return !this._value();
+    }
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    get errorState() {
+        return false; // Implement error state logic as needed
+    }
+    get panelOpen() {
+        return this._panelOpen;
+    }
+    constructor() {
+        effect(() => {
+            this._input()?.nativeElement.focus();
+        });
+        if (this.ngControl) {
+            // Note: we provide the value accessor through here, instead of
+            // the `providers` to avoid running into a circular import.
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    ngOnInit() {
+        this._selectionModel = new SelectionModel();
+        this._searchControl.valueChanges.pipe(takeUntilDestroyed(this._destroyRef), debounceTime(250), distinctUntilChanged()).subscribe((value) => this._searchValue.set(value));
+    }
+    ngAfterViewInit() {
+        this._initialized.next();
+        this._initialized.complete();
+        this._initKeyManager();
+        this.options.changes.pipe(startWith(null), takeUntilDestroyed(this._destroyRef)).subscribe(() => {
+            this._resetOptions();
+            this._initializeSelection();
+        });
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    onContainerClick(event) {
+        if (this.disabled) {
+            return;
+        }
+        this.stateChanges.next();
+        if (event.target.tagName.toLowerCase() !== "input") {
+            this.onFocusChanged(true);
+        }
+    }
+    setDescribedByIds(ids) {
+        const controlElement = this._elementRef.nativeElement.querySelector(".nice-typeahead");
+        if (!controlElement) {
+            return;
+        }
+        controlElement.setAttribute("aria-describedby", ids.join(" "));
+    }
+    onFocusChanged(isFocused) {
+        this.focused = isFocused;
+        this.stateChanges.next();
+        if (isFocused) {
+            this.open();
+        }
+    }
+    writeValue(value) {
+        this._assignValue(value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouch = fn;
+    }
+    formatLabel(item) {
+        if (typeof item === "string") {
+            return item;
+        }
+        const fn = this.formatLabelFn();
+        if (fn) {
+            return fn(item);
+        }
+        const property = this.labelProperty();
+        if (!property) {
+            return item?.toString() ?? "";
+        }
+        if (!(typeof item === "object") || item === null) {
+            return item?.toString() ?? "";
+        }
+        if (property in item) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return item[property];
+        }
+        return item.toString();
+    }
+    removeActiveValue() {
+        this.value = null;
+        this._selectionModel.clear();
+        this._keyManager.setActiveItem(-1);
+        this._changeDetectorRef.markForCheck();
+    }
+    open() {
+        if (!this._canOpen()) {
+            return;
+        }
+        // It's important that we read this as late as possible, because doing so earlier will
+        // return a different element since it's based on queries in the form field which may
+        // not have run yet. Also this needs to be assigned before we measure the overlay width.
+        if (this._parentFormField) {
+            this._preferredOverlayOrigin = this._parentFormField.getConnectedOverlayOrigin();
+        }
+        this._overlayWidth = this._getOverlayWidth(this._preferredOverlayOrigin);
+        this._panelOpen = true;
+        this._keyManager.withHorizontalOrientation(null);
+        this._changeDetectorRef.markForCheck();
+        // Required for the MDC form field to pick up when the overlay has been opened.
+        this.stateChanges.next();
+    }
+    close() {
+        if (!this._panelOpen) {
+            return;
+        }
+        this._focused = false;
+        this._panelOpen = false;
+        this._changeDetectorRef.markForCheck();
+        this._searchValue.set("");
+        // Required for the MDC form field to pick up when the overlay has been closed.
+        this.stateChanges.next();
+    }
+    focus(options) {
+        this._elementRef.nativeElement.focus(options);
+    }
+    _handleKeydown(event) {
+        if (this.disabled) {
+            return;
+        }
+        if (this.panelOpen) {
+            this._handleOpenKeydown(event);
+        }
+        else {
+            this._handleClosedKeydown(event);
+        }
+    }
+    _handleScrollEnd() {
+        console.log("scroll end");
+    }
+    _canOpen() {
+        return !this._panelOpen && !this.disabled;
+    }
+    _onAttached() {
+        this._overlayDir()?.positionChange.pipe(take(1)).subscribe(() => {
+            this._changeDetectorRef.detectChanges();
+            this._positioningSettled();
+        });
+    }
+    _initKeyManager() {
+        this._keyManager = new ActiveDescendantKeyManager(this.options)
+            .withVerticalOrientation()
+            .withHomeAndEnd()
+            .withPageUpDown()
+            .withAllowedModifierKeys(["shiftKey"])
+            .skipPredicate(this._skipPredicate);
+        this._keyManager.tabOut.subscribe(() => {
+            if (this.panelOpen) {
+                if (this._keyManager.activeItem) {
+                    this._keyManager.activeItem._selectViaInteraction();
+                }
+                this.focus();
+                this.close();
+            }
+        });
+        this._keyManager.change.subscribe(() => {
+            if (this._panelOpen && this._panel()) {
+                this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);
+            }
+            else if (!this._panelOpen && this._keyManager.activeItem) {
+                this._keyManager.activeItem._selectViaInteraction();
+            }
+        });
+    }
+    _getOverlayWidth(preferredOrigin) {
+        const refToMeasure = preferredOrigin instanceof CdkOverlayOrigin
+            ? preferredOrigin.elementRef
+            : preferredOrigin || this._elementRef;
+        return refToMeasure.nativeElement.getBoundingClientRect().width;
+    }
+    _skipPredicate = (option) => {
+        if (this.panelOpen) {
+            return false;
+        }
+        return option.disabled;
+    };
+    _positioningSettled() {
+        this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);
+    }
+    _scrollOptionIntoView(index) {
+        const option = this.options.toArray()[index];
+        if (!option) {
+            return;
+        }
+        const panel = this._panel()?.nativeElement;
+        if (!panel) {
+            return;
+        }
+        const element = option._getHostElement();
+        if (index === 0) {
+            // If we've got one group label before the option and we're at the top option,
+            // scroll the list to the top. This is better UX than scrolling the list to the
+            // top of the option, because it allows the user to read the top group's label.
+            panel.scrollTop = 0;
+        }
+        else {
+            panel.scrollTop = _getOptionScrollPosition(element.offsetTop, element.offsetHeight, panel.scrollTop, panel.offsetHeight);
+        }
+    }
+    _resetOptions() {
+        this.optionSelectionChanges.pipe(takeUntil(this.options.changes), takeUntilDestroyed(this._destroyRef)).subscribe((event) => {
+            this._onSelect(event.source);
+            if (event.isUserInput && this._panelOpen) {
+                this.close();
+                this.focus();
+            }
+        });
+    }
+    _onSelect(option) {
+        this.value = option.value;
+        this._setSelectionByValue(option.value);
+        this._selectOptionByValue(option.value);
+        this.stateChanges.next();
+    }
+    _initializeSelection() {
+        // Defer setting the value in order to avoid the "Expression
+        // has changed after it was checked" errors from Angular.
+        Promise.resolve().then(() => {
+            if (this.ngControl) {
+                this._value.set(this.ngControl.value);
+            }
+            const _value = this.value;
+            if (_value) {
+                this._selectOptionByValue(_value);
+            }
+            this._setSelectionByValue(_value);
+            this._highlightCorrectOption();
+            this.stateChanges.next();
+        });
+    }
+    _setSelectionByValue(value) {
+        this.options.forEach(option => option.setInactiveStyles());
+        this._selectionModel.clear();
+        const correspondingOption = value ? this._selectOptionByValue(value) : null;
+        // Shift focus to the active item. Note that we shouldn't do this in multiple
+        // mode, because we don't know what option the user interacted with last.
+        if (correspondingOption) {
+            correspondingOption.select(false);
+            this._keyManager.updateActiveItem(correspondingOption);
+        }
+        else if (!this.panelOpen) {
+            // Otherwise reset the highlighted option. Note that we only want to do this while
+            // closed, because doing it while open can shift the user's focus unnecessarily.
+            this._keyManager.updateActiveItem(-1);
+        }
+        this._changeDetectorRef.markForCheck();
+    }
+    _selectOptionByValue(value) {
+        const correspondingOption = this.options.find((option) => {
+            // Skip options that are already in the model. This allows us to handle cases
+            // where the same primitive value is selected multiple times.
+            if (this._selectionModel.isSelected(option)) {
+                return false;
+            }
+            try {
+                // Treat null as a special reset value.
+                return option.value != null && this._compareWith(option.value, value);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                return false;
+            }
+        });
+        if (correspondingOption) {
+            this._selectionModel.select(correspondingOption);
+        }
+        return correspondingOption;
+    }
+    _highlightCorrectOption() {
+        if (!this._keyManager) {
+            return;
+        }
+        if (this.empty) {
+            // Find the index of the first *enabled* option. Avoid calling `_keyManager.setActiveItem`
+            // because it activates the first option that passes the skip predicate, rather than the
+            // first *enabled* option.
+            let firstEnabledOptionIndex = -1;
+            for (let index = 0; index < this.options.length; index++) {
+                const option = this.options.get(index);
+                if (!option.disabled) {
+                    firstEnabledOptionIndex = index;
+                    break;
+                }
+            }
+            this._keyManager.setActiveItem(firstEnabledOptionIndex);
+        }
+        else {
+            this._keyManager.setActiveItem(this._selectionModel.selected[0]);
+        }
+    }
+    _handleClosedKeydown(event) {
+        const keyCode = event.keyCode;
+        const isArrowKey = keyCode === DOWN_ARROW ||
+            keyCode === UP_ARROW ||
+            keyCode === LEFT_ARROW ||
+            keyCode === RIGHT_ARROW;
+        const isOpenKey = keyCode === ENTER || keyCode === SPACE;
+        const manager = this._keyManager;
+        // Open the select on ALT + arrow key to match the native <select>
+        if ((!manager.isTyping() && isOpenKey && !hasModifierKey(event)) ||
+            (event.altKey && isArrowKey)) {
+            event.preventDefault(); // prevents the page from scrolling down when pressing space
+            this.open();
+        }
+    }
+    _handleOpenKeydown(event) {
+        const manager = this._keyManager;
+        const keyCode = event.keyCode;
+        const isArrowKey = keyCode === DOWN_ARROW || keyCode === UP_ARROW;
+        const isTyping = manager.isTyping();
+        if (isArrowKey && event.altKey) {
+            // Close the select on ALT + arrow key to match the native <select>
+            event.preventDefault();
+            this.close();
+            // Don't do anything in this case if the user is typing,
+            // because the typing sequence can include the space key.
+        }
+        else if (!isTyping &&
+            (keyCode === ENTER || keyCode === SPACE) &&
+            manager.activeItem &&
+            !hasModifierKey(event)) {
+            event.preventDefault();
+            manager.activeItem._selectViaInteraction();
+        }
+        else {
+            manager.onKeydown(event);
+        }
+    }
+    _assignValue(newValue) {
+        // Always re-assign an array, because it might have been mutated.
+        if (newValue !== this.value) {
+            if (this.options) {
+                this._setSelectionByValue(newValue);
+            }
+            this._value.set(newValue);
+            return true;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NiceTypeaheadBase, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.13", type: NiceTypeaheadBase, inputs: { labelProperty: { classPropertyName: "labelProperty", publicName: "labelProperty", isSignal: true, isRequired: false, transformFunction: null }, formatLabelFn: { classPropertyName: "formatLabelFn", publicName: "formatLabelFn", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "_input", first: true, predicate: ["input"], descendants: true, isSignal: true }, { propertyName: "_panel", first: true, predicate: ["panel"], descendants: true, isSignal: true }, { propertyName: "_overlayDir", first: true, predicate: CdkConnectedOverlay, descendants: true, isSignal: true }, { propertyName: "options", predicate: MatOption, descendants: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NiceTypeaheadBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { options: [{
+                type: ViewChildren,
+                args: [MatOption]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead-base.js","sourceRoot":"","sources":["../../../../src/material-components/typeahead/typeahead-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActiveDescendantKeyManager } from \"@angular/cdk/a11y\";\nimport { SelectionModel } from \"@angular/cdk/collections\";\nimport { DOWN_ARROW, ENTER, hasModifierKey, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW } from \"@angular/cdk/keycodes\";\nimport { CdkConnectedOverlay, CdkOverlayOrigin } from \"@angular/cdk/overlay\";\nimport {\n    AfterViewInit,\n    ChangeDetectorRef,\n    computed,\n    DestroyRef,\n    Directive,\n    effect,\n    ElementRef,\n    inject,\n    input,\n    OnDestroy,\n    OnInit,\n    QueryList,\n    signal,\n    viewChild,\n    ViewChildren\n} from \"@angular/core\";\nimport { takeUntilDestroyed } from \"@angular/core/rxjs-interop\";\nimport { ControlValueAccessor, FormBuilder, NgControl } from \"@angular/forms\";\nimport { _getOptionScrollPosition, MatOption, MatOptionSelectionChange } from \"@angular/material/core\";\nimport { MAT_FORM_FIELD, MatFormField, MatFormFieldControl } from \"@angular/material/form-field\";\nimport {\n    debounceTime,\n    defer,\n    distinctUntilChanged,\n    merge,\n    Observable,\n    startWith,\n    Subject,\n    switchMap,\n    take,\n    takeUntil\n} from \"rxjs\";\n\n/**\n * Implementation of the same panel and overlay logic as the official Angular MatSelect.\n * This used some of the logic from MatSelect to make this component look and feel like a MatSelect.\n */\n@Directive()\nexport class NiceTypeaheadBase<T>\n    implements\n        MatFormFieldControl<T>,\n        ControlValueAccessor,\n        OnInit,\n        AfterViewInit,\n        OnDestroy\n{\n    @ViewChildren(MatOption)\n    private readonly options!: QueryList<MatOption>;\n\n    public readonly labelProperty = input<string>();\n    public readonly formatLabelFn = input<((value: T) => string)>();\n\n    private static nextId = 0;\n\n    protected readonly _input = viewChild<ElementRef<HTMLInputElement>>(\"input\");\n    protected readonly _panel = viewChild<ElementRef<HTMLElement>>(\"panel\");\n    protected readonly _overlayDir = viewChild(CdkConnectedOverlay);\n\n    protected _focused = false;\n    protected _required = false;\n    protected _disabled = false;\n    protected _panelOpen = false;\n    protected _compareWith = (o1: T, o2: T) => o1 === o2;\n\n    protected readonly _value = signal<T | null>(null);\n    protected readonly _empty = computed(() => !this._value());\n    protected readonly _placeholder = signal(\"\");\n    protected readonly _searchValue = signal(\"\");\n\n    protected readonly _elementRef = inject(ElementRef);\n    protected readonly _destroyRef = inject(DestroyRef);\n    protected readonly _changeDetectorRef = inject(ChangeDetectorRef);\n    protected readonly _fb = inject(FormBuilder);\n\n    protected readonly _searchControl = this._fb.nonNullable.control(\"\");\n    protected readonly _initialized = new Subject<void>();\n\n    protected readonly _parentFormField = inject<MatFormField>(MAT_FORM_FIELD, { optional: true });\n\n    public readonly id: string = `nice-typeahead-${NiceTypeaheadBase.nextId++}`;\n    public readonly controlType: string = \"nice-typeahead\";\n    public readonly stateChanges = new Subject<void>();\n    public readonly optionSelectionChanges: Observable<MatOptionSelectionChange> = defer(() => {\n        const options = this.options;\n\n        if (options) {\n            return options.changes.pipe(\n                startWith(options),\n                switchMap(() => merge(...options.map(option => option.onSelectionChange))),\n            );\n        }\n\n        return this._initialized.pipe(switchMap(() => this.optionSelectionChanges));\n    });\n\n    public readonly ngControl = inject(NgControl, { optional: true, self: true });\n\n    public readonly _panelDoneAnimatingStream = new Subject<string>();\n\n    public _keyManager!: ActiveDescendantKeyManager<MatOption>;\n    public _preferredOverlayOrigin?: CdkOverlayOrigin | ElementRef;\n    public _overlayWidth!: string | number;\n    public _selectionModel!: SelectionModel<MatOption>;\n    public _onChange?: (value: T | null) => void;\n    public _onTouch?: () => void;\n\n    public get placeholder(): string {\n        return this._placeholder();\n    }\n\n    public set placeholder(placeholder) {\n        this._placeholder.set(placeholder);\n        this.stateChanges.next();\n    }\n\n    public get focused(): boolean {\n        return this._focused;\n    }\n\n    public set focused(isFocused: boolean) {\n        this._focused = isFocused;\n        this.stateChanges.next();\n    }\n\n    public get required(): boolean {\n        return this._required;\n    }\n\n    public set required(isRequired: boolean) {\n        this._required = isRequired;\n        this.stateChanges.next();\n    }\n\n    public get disabled(): boolean {\n        return this._disabled;\n    }\n\n    public set disabled(value: boolean) {\n        this._disabled = value;\n        this.stateChanges.next();\n    }\n\n    public get value(): T | null {\n        return this._value();\n    }\n\n    public set value(value: T | null) {\n        const hasAssigned = this._assignValue(value);\n\n        if (hasAssigned) {\n            this._onChange?.(value);\n        }\n    }\n\n    public get empty(): boolean {\n        return !this._value();\n    }\n\n    public get shouldLabelFloat(): boolean {\n        return this.focused || !this.empty;\n    }\n\n    public get errorState(): boolean {\n        return false; // Implement error state logic as needed\n    }\n\n    public get panelOpen(): boolean {\n        return this._panelOpen;\n    }\n\n    constructor() {\n        effect(() => {\n            this._input()?.nativeElement.focus();\n        });\n\n        if (this.ngControl) {\n            // Note: we provide the value accessor through here, instead of\n            // the `providers` to avoid running into a circular import.\n            this.ngControl.valueAccessor = this;\n        }\n    }\n\n    public ngOnInit(): void {\n        this._selectionModel = new SelectionModel<MatOption>();\n\n        this._searchControl.valueChanges.pipe(\n            takeUntilDestroyed(this._destroyRef),\n            debounceTime(250),\n            distinctUntilChanged()\n        ).subscribe((value) => this._searchValue.set(value));\n    }\n\n    public ngAfterViewInit(): void {\n        this._initialized.next();\n        this._initialized.complete();\n\n        this._initKeyManager();\n\n        this.options.changes.pipe(startWith(null), takeUntilDestroyed(this._destroyRef)).subscribe(() => {\n            this._resetOptions();\n            this._initializeSelection();\n        });\n    }\n\n    public ngOnDestroy(): void {\n        this.stateChanges.complete();\n    }\n\n    public onContainerClick(event: MouseEvent): void {\n        if (this.disabled) {\n            return;\n        }\n\n        this.stateChanges.next();\n        if ((event.target as Element).tagName.toLowerCase() !== \"input\") {\n            this.onFocusChanged(true);\n        }\n    }\n\n    public setDescribedByIds(ids: string[]): void {\n        const controlElement = this._elementRef.nativeElement.querySelector(\".nice-typeahead\");\n        if (!controlElement) {\n            return;\n        }\n\n        controlElement.setAttribute(\"aria-describedby\", ids.join(\" \"));\n    }\n\n    public onFocusChanged(isFocused: boolean): void {\n        this.focused = isFocused;\n        this.stateChanges.next();\n\n        if (isFocused) {\n            this.open();\n        }\n    }\n\n    public writeValue(value: T): void {\n        this._assignValue(value);\n    }\n\n    public registerOnChange(fn: (value: T | null) => void) {\n        this._onChange = fn;\n    }\n\n    public registerOnTouched(fn: () => void): void {\n        this._onTouch = fn;\n    }\n\n    public formatLabel(item: T): string {\n        if (typeof item === \"string\") {\n            return item;\n        }\n\n        const fn = this.formatLabelFn();\n        if (fn) {\n            return fn(item);\n        }\n\n        const property = this.labelProperty();\n        if (!property) {\n            return item?.toString() ?? \"\";\n        }\n\n        if (!(typeof item === \"object\") || item === null) {\n            return item?.toString() ?? \"\";\n        }\n\n        if (property in item) {\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore\n            return item[property];\n        }\n\n        return item.toString();\n    }\n\n    public removeActiveValue(): void {\n        this.value = null;\n        this._selectionModel.clear();\n        this._keyManager.setActiveItem(-1);\n        this._changeDetectorRef.markForCheck();\n    }\n\n    public open(): void {\n        if (!this._canOpen()) {\n            return;\n        }\n\n        // It's important that we read this as late as possible, because doing so earlier will\n        // return a different element since it's based on queries in the form field which may\n        // not have run yet. Also this needs to be assigned before we measure the overlay width.\n        if (this._parentFormField) {\n            this._preferredOverlayOrigin = this._parentFormField.getConnectedOverlayOrigin();\n        }\n\n        this._overlayWidth = this._getOverlayWidth(this._preferredOverlayOrigin);\n        this._panelOpen = true;\n        this._keyManager.withHorizontalOrientation(null);\n        this._changeDetectorRef.markForCheck();\n\n        // Required for the MDC form field to pick up when the overlay has been opened.\n        this.stateChanges.next();\n    }\n\n    public close(): void {\n        if (!this._panelOpen) {\n            return;\n        }\n\n        this._focused = false;\n        this._panelOpen = false;\n        this._changeDetectorRef.markForCheck();\n\n        this._searchValue.set(\"\");\n\n        // Required for the MDC form field to pick up when the overlay has been closed.\n        this.stateChanges.next();\n    }\n\n    public focus(options?: FocusOptions): void {\n        this._elementRef.nativeElement.focus(options);\n    }\n\n    public _handleKeydown(event: KeyboardEvent): void {\n        if (this.disabled) {\n            return;\n        }\n\n        if (this.panelOpen) {\n            this._handleOpenKeydown(event);\n        } else {\n            this._handleClosedKeydown(event);\n        }\n    }\n\n    public _handleScrollEnd(): void {\n        console.log(\"scroll end\")\n    }\n\n    protected _canOpen(): boolean {\n        return !this._panelOpen && !this.disabled;\n    }\n\n    protected _onAttached(): void {\n        this._overlayDir()?.positionChange.pipe(take(1)).subscribe(() => {\n            this._changeDetectorRef.detectChanges();\n            this._positioningSettled();\n        });\n    }\n\n    protected _initKeyManager() {\n        this._keyManager = new ActiveDescendantKeyManager<MatOption>(this.options)\n            .withVerticalOrientation()\n            .withHomeAndEnd()\n            .withPageUpDown()\n            .withAllowedModifierKeys([\"shiftKey\"])\n            .skipPredicate(this._skipPredicate);\n\n        this._keyManager.tabOut.subscribe(() => {\n            if (this.panelOpen) {\n                if (this._keyManager.activeItem) {\n                    this._keyManager.activeItem._selectViaInteraction();\n                }\n\n                this.focus();\n                this.close();\n            }\n        });\n\n        this._keyManager.change.subscribe(() => {\n            if (this._panelOpen && this._panel()) {\n                this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);\n            } else if (!this._panelOpen && this._keyManager.activeItem) {\n                this._keyManager.activeItem._selectViaInteraction();\n            }\n        });\n    }\n\n    protected _getOverlayWidth(preferredOrigin?: ElementRef<ElementRef> | CdkOverlayOrigin): string | number {\n        const refToMeasure =\n            preferredOrigin instanceof CdkOverlayOrigin\n                ? preferredOrigin.elementRef\n                : preferredOrigin || this._elementRef;\n        return refToMeasure.nativeElement.getBoundingClientRect().width;\n    }\n\n    protected _skipPredicate = (option: MatOption) => {\n        if (this.panelOpen) {\n            return false;\n        }\n\n        return option.disabled;\n    };\n\n    protected _positioningSettled() {\n        this._scrollOptionIntoView(this._keyManager.activeItemIndex || 0);\n    }\n\n    protected _scrollOptionIntoView(index: number): void {\n        const option = this.options.toArray()[index];\n        if (!option) {\n            return;\n        }\n\n        const panel = this._panel()?.nativeElement;\n        if (!panel) {\n            return;\n        }\n\n        const element = option._getHostElement();\n        if (index === 0) {\n            // If we've got one group label before the option and we're at the top option,\n            // scroll the list to the top. This is better UX than scrolling the list to the\n            // top of the option, because it allows the user to read the top group's label.\n            panel.scrollTop = 0;\n        } else {\n            panel.scrollTop = _getOptionScrollPosition(\n                element.offsetTop,\n                element.offsetHeight,\n                panel.scrollTop,\n                panel.offsetHeight,\n            );\n        }\n    }\n\n    protected _resetOptions(): void {\n        this.optionSelectionChanges.pipe(\n            takeUntil(this.options.changes),\n            takeUntilDestroyed(this._destroyRef)\n        ).subscribe((event) => {\n            this._onSelect(event.source);\n\n            if (event.isUserInput && this._panelOpen) {\n                this.close();\n                this.focus();\n            }\n        });\n    }\n\n    protected _onSelect(option: MatOption): void {\n        this.value = option.value;\n        this._setSelectionByValue(option.value);\n        this._selectOptionByValue(option.value);\n\n        this.stateChanges.next();\n    }\n\n    protected _initializeSelection(): void {\n        // Defer setting the value in order to avoid the \"Expression\n        // has changed after it was checked\" errors from Angular.\n        Promise.resolve().then(() => {\n            if (this.ngControl) {\n                this._value.set(this.ngControl.value);\n            }\n\n            const _value = this.value;\n            if (_value) {\n                this._selectOptionByValue(_value);\n            }\n            this._setSelectionByValue(_value);\n\n            this._highlightCorrectOption();\n            this.stateChanges.next();\n        });\n    }\n\n    protected _setSelectionByValue(value: T | null): void {\n        this.options.forEach(option => option.setInactiveStyles());\n        this._selectionModel.clear();\n\n        const correspondingOption = value ? this._selectOptionByValue(value) : null;\n\n        // Shift focus to the active item. Note that we shouldn't do this in multiple\n        // mode, because we don't know what option the user interacted with last.\n        if (correspondingOption) {\n            correspondingOption.select(false);\n            this._keyManager.updateActiveItem(correspondingOption);\n        } else if (!this.panelOpen) {\n            // Otherwise reset the highlighted option. Note that we only want to do this while\n            // closed, because doing it while open can shift the user's focus unnecessarily.\n            this._keyManager.updateActiveItem(-1);\n        }\n\n        this._changeDetectorRef.markForCheck();\n    }\n\n\n    protected _selectOptionByValue(value: T): MatOption | undefined {\n        const correspondingOption = this.options.find((option: MatOption) => {\n            // Skip options that are already in the model. This allows us to handle cases\n            // where the same primitive value is selected multiple times.\n            if (this._selectionModel.isSelected(option)) {\n                return false;\n            }\n\n            try {\n                // Treat null as a special reset value.\n                return option.value != null && this._compareWith(option.value, value);\n                // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            } catch (error) {\n                return false;\n            }\n        });\n\n        if (correspondingOption) {\n            this._selectionModel.select(correspondingOption);\n        }\n\n        return correspondingOption;\n    }\n\n    protected _highlightCorrectOption(): void {\n        if (!this._keyManager) {\n            return;\n        }\n\n        if (this.empty) {\n            // Find the index of the first *enabled* option. Avoid calling `_keyManager.setActiveItem`\n            // because it activates the first option that passes the skip predicate, rather than the\n            // first *enabled* option.\n            let firstEnabledOptionIndex = -1;\n            for (let index = 0; index < this.options.length; index++) {\n                const option = this.options.get(index)!;\n                if (!option.disabled) {\n                    firstEnabledOptionIndex = index;\n                    break;\n                }\n            }\n\n            this._keyManager.setActiveItem(firstEnabledOptionIndex);\n        } else {\n            this._keyManager.setActiveItem(this._selectionModel.selected[0]);\n        }\n    }\n\n\n    protected _handleClosedKeydown(event: KeyboardEvent): void {\n        const keyCode = event.keyCode;\n        const isArrowKey =\n            keyCode === DOWN_ARROW ||\n            keyCode === UP_ARROW ||\n            keyCode === LEFT_ARROW ||\n            keyCode === RIGHT_ARROW;\n        const isOpenKey = keyCode === ENTER || keyCode === SPACE;\n        const manager = this._keyManager;\n\n        // Open the select on ALT + arrow key to match the native <select>\n        if (\n            (!manager.isTyping() && isOpenKey && !hasModifierKey(event)) ||\n            (event.altKey && isArrowKey)\n        ) {\n            event.preventDefault(); // prevents the page from scrolling down when pressing space\n            this.open();\n        }\n    }\n\n    protected _handleOpenKeydown(event: KeyboardEvent): void {\n        const manager = this._keyManager;\n        const keyCode = event.keyCode;\n        const isArrowKey = keyCode === DOWN_ARROW || keyCode === UP_ARROW;\n        const isTyping = manager.isTyping();\n\n        if (isArrowKey && event.altKey) {\n            // Close the select on ALT + arrow key to match the native <select>\n            event.preventDefault();\n            this.close();\n            // Don't do anything in this case if the user is typing,\n            // because the typing sequence can include the space key.\n        } else if (\n            !isTyping &&\n            (keyCode === ENTER || keyCode === SPACE) &&\n            manager.activeItem &&\n            !hasModifierKey(event)\n        ) {\n            event.preventDefault();\n            manager.activeItem._selectViaInteraction();\n        } else {\n            manager.onKeydown(event);\n        }\n    }\n\n    protected _assignValue(newValue: T | null): boolean {\n        // Always re-assign an array, because it might have been mutated.\n        if (newValue !== this.value) {\n            if (this.options) {\n                this._setSelectionByValue(newValue);\n            }\n\n            this._value.set(newValue);\n            return true;\n        }\n        return false;\n    }\n}\n"]}