@danske/sapphire-angular 1.12.4

package/esm2020/lib/select/src/common/hidden-select.component.mjs

@@ -0,0 +1,33 @@
+import { Component } from '@angular/core';
+import { isMobile } from '../../../common/platform';
+import * as i0 from "@angular/core";
+import * as i1 from "./select-component-base";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../../common/visually-hidden.directive";
+import * as i5 from "../../../common/sapphire-view-encapsulation";
+/**
+ * Hidden native select to be rendered in sapphire select components. It does two things:
+ * - Takes care of form accessibility and autofilling by rendering native select/input
+ * - Opens the native select dropdown instead of the custom dropdown, when possible.
+ *
+ * The latter proved to be a questionable, and we may rethink it at some point.
+ *
+ * @internal
+ */
+export class HiddenSelectComponent {
+    constructor(_select) {
+        this._select = _select;
+        this._isMobile = isMobile();
+    }
+    _onNativeSelectChange(e) {
+        this._select.listboxValue = [e.target.value];
+    }
+}
+HiddenSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: HiddenSelectComponent, deps: [{ token: i1.SelectComponentBase }], target: i0.ɵɵFactoryTarget.Component });
+HiddenSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.0", type: HiddenSelectComponent, selector: "sp-hidden-select", ngImport: i0, template: "<ng-container *ngIf=\"_select._initialized\">\n  <select\n    *ngIf=\"_isMobile && !_select.multiple\"\n    class=\"sapphire-select__native-select\"\n    _spUseComponentStyles\n    [disabled]=\"_select.disabled\"\n    [attr.name]=\"_select.name\"\n    (change)=\"_onNativeSelectChange($event)\"\n  >\n    <option\n      *ngFor=\"let option of _select.options\"\n      [value]=\"option.value\"\n      [disabled]=\"option.disabled\"\n    >\n      {{ option.label }}\n    </option>\n  </select>\n  <div\n    *ngIf=\"!_isMobile || _select.multiple\"\n    aria-hidden=\"true\"\n    spVisuallyHidden\n  >\n    <input\n      type=\"text\"\n      style=\"font-size: 16px\"\n      [disabled]=\"_select.disabled\"\n      [tabIndex]=\"_select.isFocused() || _select.isOpen() ? -1 : 0\"\n      (focus)=\"_select.focus('keyboard')\"\n    />\n    <label>\n      {{ _select.getLabelText() }}\n      <select\n        [attr.size]=\"_select.multiple ? _select.options.length : null\"\n        [disabled]=\"_select.disabled\"\n        tabindex=\"-1\"\n        [multiple]=\"_select.multiple\"\n        (change)=\"_onNativeSelectChange($event)\"\n        [attr.name]=\"_select.name\"\n      >\n        <option\n          *ngFor=\"let option of _select.options\"\n          [value]=\"option.value\"\n          [selected]=\"_select.listboxValue.includes(option.value)\"\n          [disabled]=\"option.disabled\"\n        >\n          {{ option.label }}\n        </option>\n      </select>\n    </label>\n  </div>\n</ng-container>\n", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i3.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i4.VisuallyHiddenDirective, selector: "[spVisuallyHidden]", inputs: ["spVisuallyHidden"] }, { kind: "directive", type: i5.UseComponentStyles, selector: "[_spUseComponentStyles]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: HiddenSelectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sp-hidden-select', template: "<ng-container *ngIf=\"_select._initialized\">\n  <select\n    *ngIf=\"_isMobile && !_select.multiple\"\n    class=\"sapphire-select__native-select\"\n    _spUseComponentStyles\n    [disabled]=\"_select.disabled\"\n    [attr.name]=\"_select.name\"\n    (change)=\"_onNativeSelectChange($event)\"\n  >\n    <option\n      *ngFor=\"let option of _select.options\"\n      [value]=\"option.value\"\n      [disabled]=\"option.disabled\"\n    >\n      {{ option.label }}\n    </option>\n  </select>\n  <div\n    *ngIf=\"!_isMobile || _select.multiple\"\n    aria-hidden=\"true\"\n    spVisuallyHidden\n  >\n    <input\n      type=\"text\"\n      style=\"font-size: 16px\"\n      [disabled]=\"_select.disabled\"\n      [tabIndex]=\"_select.isFocused() || _select.isOpen() ? -1 : 0\"\n      (focus)=\"_select.focus('keyboard')\"\n    />\n    <label>\n      {{ _select.getLabelText() }}\n      <select\n        [attr.size]=\"_select.multiple ? _select.options.length : null\"\n        [disabled]=\"_select.disabled\"\n        tabindex=\"-1\"\n        [multiple]=\"_select.multiple\"\n        (change)=\"_onNativeSelectChange($event)\"\n        [attr.name]=\"_select.name\"\n      >\n        <option\n          *ngFor=\"let option of _select.options\"\n          [value]=\"option.value\"\n          [selected]=\"_select.listboxValue.includes(option.value)\"\n          [disabled]=\"option.disabled\"\n        >\n          {{ option.label }}\n        </option>\n      </select>\n    </label>\n  </div>\n</ng-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.SelectComponentBase }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/select/src/common/select-component-base.mjs

@@ -0,0 +1,267 @@
+import { __decorate } from "tslib";
+import { CoerceBoolean } from '../../../common/coerce-boolean.decorator';
+import { ListboxChild, OptionComponent, } from '../../../listbox/public_api';
+import { ChangeDetectorRef, ContentChild, ContentChildren, Directive, EventEmitter, inject, Input, Output, QueryList, } from '@angular/core';
+import { AutoId } from '../../../common/auto-id.decorator';
+import { ListKeyManager, } from '@angular/cdk/a11y';
+import { MultiSelectDirectiveBase, } from './select-value-holder';
+import { SelectionTextDirective } from '../select/selection-text.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./select-value-holder";
+export class SelectComponentBase {
+    set listboxValue(value) {
+        this.valueHolder.setFromListboxValue(value);
+        this.controlValueAccessorChangeFn(this.valueHolder.value);
+    }
+    get listboxValue() {
+        return this.valueHolder.getListboxValue();
+    }
+    get selectedOptions() {
+        return this.options?.filter((option) => this.listboxValue.includes(option.value));
+    }
+    constructor(valueHolder) {
+        this.valueHolder = valueHolder;
+        /** A unique id for the select. If none is supplied, it will be auto-generated. */
+        this.id = '';
+        /**
+         * Emitted when the popover is opened
+         */
+        this.opened = new EventEmitter();
+        /**
+         * Emitted when the popover is closed
+         */
+        this.closed = new EventEmitter();
+        this.options = new QueryList();
+        this.listboxChildren = new QueryList();
+        /**
+         * Emits whenever the dropdown is closed as a result of an option (already
+         * selected or not) being selected.
+         */
+        this.selected = new EventEmitter();
+        this.ariaLabel = null;
+        this.ariaLabelledby = null;
+        /**
+         * Used to work around ExpressionChangedAfterItHasBeenCheckedError error thrown from HiddenSelect,
+         * when the select component is rendered from a template (e.g. with *ngIf). It's set to true
+         * asynchronously after content is initialized, to delay rendering of things that depend on
+         * options. It's not clear why the issue happens, and it only happens when select is used with
+         * *ngIf, or generally in a template.
+         */
+        this._initialized = false;
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        this.controlValueAccessorChangeFn = () => { };
+        this.onTouched = () => { };
+    }
+    handleKeyDown($event) {
+        if ($event.target !== this.triggerElementRef?.nativeElement) {
+            return;
+        }
+        switch ($event.key) {
+            case 'ArrowDown':
+                this.triggerRef?.open();
+                break;
+            case 'ArrowUp':
+                this.triggerRef?.open();
+                // we need to delay it a little, since the listbox will autofocus
+                // the first item.
+                setTimeout(() => {
+                    if (this.options?.last && this.listboxValue.length === 0) {
+                        this.listbox?.setActiveOption(this.options?.last.value);
+                    }
+                });
+                break;
+            case 'ArrowRight':
+            case 'ArrowLeft':
+                if (this.multiple) {
+                    this.triggerRef?.open();
+                }
+                else {
+                    const option = this.getNextEnabledOptionValue($event.key === 'ArrowLeft' ? 'left' : 'right');
+                    if (option) {
+                        this.listboxValue = [option];
+                    }
+                }
+                break;
+            default:
+                this.keyManager?.onKeydown($event);
+        }
+    }
+    getSelectionText() {
+        const selectedOptions = this.selectedOptions;
+        if (selectedOptions.length === 0) {
+            return '';
+        }
+        if (selectedOptions.length === 1) {
+            return selectedOptions[0]?.label;
+        }
+        return `${selectedOptions.length === this.options.length
+            ? 'All'
+            : selectedOptions.length} selected`;
+    }
+    /**
+     * Whether multiple selection is allowed.
+     */
+    get multiple() {
+        return this.valueHolder instanceof MultiSelectDirectiveBase;
+    }
+    ngAfterContentInit() {
+        this.initKeyManager();
+        this.options.changes.subscribe(() => {
+            this.initKeyManager();
+        });
+        Promise.resolve().then(() => {
+            this._initialized = true;
+        });
+    }
+    ngAfterViewInit() {
+        /**
+         * This is to avoid an NG0100 ExpressionChangedAfter... error when there is an initial value
+         * The issue is probably due to the fact that options are defined withing the **content**
+         * (sp-option elements), so the listbox value can change after the view of select is checked,
+         * if there is a default value. And that leads to the error, since we have bindings in the
+         * template, such as `getSelectionText()`, that depend on the listbox value.
+         */
+        if (this.listboxValue.length > 0) {
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    ngOnDestroy() {
+        this.keyManager?.destroy();
+    }
+    /**
+     * Called when an item in the listbox is selected.
+     */
+    _handleSelected() {
+        if (!this.multiple) {
+            this.triggerRef?.close();
+        }
+        this.selected.emit();
+    }
+    isOpen() {
+        return this.triggerRef?.isOpen() ?? false;
+    }
+    open() {
+        this.triggerRef?.open();
+    }
+    close() {
+        this.triggerRef?.close();
+    }
+    toggle() {
+        this.triggerRef?.open();
+    }
+    getLabelText() {
+        return (this.getFieldLabel?.() ?? this.ariaLabel)?.trim();
+    }
+    _onOpen() {
+        this.opened.emit();
+    }
+    _onClose() {
+        this.closed.emit();
+        this.onTouched();
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnChange(fn) {
+        this.controlValueAccessorChangeFn = fn;
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value) {
+        this.valueHolder.value = value;
+    }
+    getNextEnabledOptionValue(direction = 'right') {
+        const optionsArray = this.options?.toArray() || [];
+        let nextNonDisabledOption;
+        const selectedOption = this.selectedOptions[0];
+        const currentOptionIndex = (selectedOption && optionsArray.indexOf(selectedOption)) ?? -1;
+        const notDisabled = (o) => !o.disabled;
+        if (currentOptionIndex === -1) {
+            nextNonDisabledOption = optionsArray.find(notDisabled);
+        }
+        else if (direction === 'left') {
+            nextNonDisabledOption = optionsArray
+                .slice(0, currentOptionIndex)
+                .reverse()
+                .find(notDisabled);
+        }
+        else {
+            nextNonDisabledOption = optionsArray
+                .slice(currentOptionIndex + 1, optionsArray.length)
+                .find(notDisabled);
+        }
+        const nextNonDisabledOptionIndex = nextNonDisabledOption
+            ? optionsArray.indexOf(nextNonDisabledOption)
+            : currentOptionIndex;
+        return this.options?.get(nextNonDisabledOptionIndex)?.value;
+    }
+    initKeyManager() {
+        // destroy any existing key manager
+        this.keyManager?.destroy();
+        this.keyManager = new ListKeyManager(this.options.map((option) => ({
+            value: option.value,
+            getLabel: () => option.label,
+            disabled: !!option.disabled,
+        }))).withTypeAhead();
+        this.keyManager.change.subscribe(() => {
+            const selectedOption = this.options?.find((option) => this.keyManager?.activeItem?.value === option.value);
+            if (selectedOption) {
+                this.listboxValue = [selectedOption.value];
+            }
+        });
+    }
+}
+SelectComponentBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SelectComponentBase, deps: [{ token: i1.SelectValueHolder }], target: i0.ɵɵFactoryTarget.Directive });
+SelectComponentBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: SelectComponentBase, inputs: { disabled: "disabled", id: "id", name: "name", placeholder: "placeholder", ariaLabel: ["aria-label", "ariaLabel"], ariaLabelledby: ["aria-labelledby", "ariaLabelledby"] }, outputs: { opened: "opened", closed: "closed", selected: "selected" }, queries: [{ propertyName: "selectionText", first: true, predicate: SelectionTextDirective, descendants: true }, { propertyName: "options", predicate: OptionComponent, descendants: true }, { propertyName: "listboxChildren", predicate: ListboxChild }], ngImport: i0 });
+__decorate([
+    CoerceBoolean
+], SelectComponentBase.prototype, "disabled", void 0);
+__decorate([
+    AutoId()
+], SelectComponentBase.prototype, "id", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SelectComponentBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.SelectValueHolder }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], options: [{
+                type: ContentChildren,
+                args: [OptionComponent, { descendants: true }]
+            }], listboxChildren: [{
+                type: ContentChildren,
+                args: [ListboxChild]
+            }], selected: [{
+                type: Output
+            }], ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], ariaLabelledby: [{
+                type: Input,
+                args: ['aria-labelledby']
+            }], selectionText: [{
+                type: ContentChild,
+                args: [SelectionTextDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select-component-base.js","sourceRoot":"","sources":["../../../../../../src/lib/select/src/common/select-component-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { CoerceBoolean } from '../../../common/coerce-boolean.decorator';\nimport { BooleanInput } from '@angular/cdk/coercion';\nimport {\n  ListboxChild,\n  ListboxComponent,\n  OptionComponent,\n} from '../../../listbox/public_api';\nimport { ControlValueAccessor } from '@angular/forms';\nimport {\n  AfterContentInit,\n  ChangeDetectorRef,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  inject,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n} from '@angular/core';\nimport { AutoId } from '../../../common/auto-id.decorator';\nimport {\n  FocusOrigin,\n  ListKeyManager,\n  ListKeyManagerOption,\n} from '@angular/cdk/a11y';\nimport { PopoverTriggerDirective } from '../../../popover/src/popover-trigger.directive';\nimport {\n  MultiSelectDirectiveBase,\n  SelectValueHolder,\n} from './select-value-holder';\nimport { SelectionTextDirective } from '../select/selection-text.directive';\n\n@Directive() // This is needed for decorators like Input to work\nexport abstract class SelectComponentBase\n  implements ControlValueAccessor, AfterContentInit, OnDestroy\n{\n  /**\n   * Whether the component is disabled.\n   */\n  @Input()\n  @CoerceBoolean\n  disabled: BooleanInput;\n\n  /** A unique id for the select. If none is supplied, it will be auto-generated. */\n  @Input()\n  @AutoId()\n  id = '';\n\n  /** The name of the input, used when submitting an HTML form. */\n  @Input()\n  name?: string;\n\n  /**\n   * Placeholder to be shown if no value has been selected.\n   */\n  @Input() placeholder?: string;\n\n  /**\n   * Emitted when the popover is opened\n   */\n  @Output()\n  readonly opened: EventEmitter<void> = new EventEmitter();\n\n  /**\n   * Emitted when the popover is closed\n   */\n  @Output()\n  readonly closed: EventEmitter<void> = new EventEmitter();\n\n  @ContentChildren(OptionComponent, { descendants: true })\n  public options: QueryList<OptionComponent> = new QueryList<OptionComponent>();\n\n  @ContentChildren(ListboxChild)\n  public listboxChildren: QueryList<ListboxChild> = new QueryList<ListboxChild>();\n\n  /**\n   * Manages keyboard events for options in the panel.\n   */\n  protected keyManager:\n    | ListKeyManager<{ value: string } & ListKeyManagerOption>\n    | undefined;\n\n  /**\n   * Emits whenever the dropdown is closed as a result of an option (already\n   * selected or not) being selected.\n   */\n  @Output()\n  selected = new EventEmitter();\n\n  @Input('aria-label')\n  ariaLabel: string | null = null;\n  @Input('aria-labelledby')\n  ariaLabelledby?: string | null = null;\n\n  @ContentChild(SelectionTextDirective)\n  selectionText?: SelectionTextDirective;\n\n  /**\n   * Used to work around ExpressionChangedAfterItHasBeenCheckedError error thrown from HiddenSelect,\n   * when the select component is rendered from a template (e.g. with *ngIf). It's set to true\n   * asynchronously after content is initialized, to delay rendering of things that depend on\n   * options. It's not clear why the issue happens, and it only happens when select is used with\n   * *ngIf, or generally in a template.\n   */\n  _initialized = false;\n\n  set listboxValue(value: readonly string[]) {\n    this.valueHolder.setFromListboxValue(value);\n    this.controlValueAccessorChangeFn(this.valueHolder.value);\n  }\n  get listboxValue() {\n    return this.valueHolder.getListboxValue();\n  }\n  get selectedOptions() {\n    return this.options?.filter((option) =>\n      this.listboxValue.includes(option.value)\n    );\n  }\n\n  private changeDetectorRef = inject(ChangeDetectorRef);\n\n  constructor(protected valueHolder: SelectValueHolder) {}\n\n  protected abstract triggerRef: PopoverTriggerDirective | undefined;\n  protected abstract triggerElementRef: ElementRef<HTMLElement> | undefined;\n  protected abstract listbox: ListboxComponent | undefined;\n  public abstract focus(focusOrigin: FocusOrigin): void;\n  public abstract isFocused(): boolean;\n\n  handleKeyDown($event: KeyboardEvent) {\n    if ($event.target !== this.triggerElementRef?.nativeElement) {\n      return;\n    }\n    switch ($event.key) {\n      case 'ArrowDown':\n        this.triggerRef?.open();\n        break;\n      case 'ArrowUp':\n        this.triggerRef?.open();\n        // we need to delay it a little, since the listbox will autofocus\n        // the first item.\n        setTimeout(() => {\n          if (this.options?.last && this.listboxValue.length === 0) {\n            this.listbox?.setActiveOption(this.options?.last.value);\n          }\n        });\n        break;\n      case 'ArrowRight':\n      case 'ArrowLeft':\n        if (this.multiple) {\n          this.triggerRef?.open();\n        } else {\n          const option = this.getNextEnabledOptionValue(\n            $event.key === 'ArrowLeft' ? 'left' : 'right'\n          );\n          if (option) {\n            this.listboxValue = [option];\n          }\n        }\n        break;\n      default:\n        this.keyManager?.onKeydown($event);\n    }\n  }\n\n  getSelectionText(): string {\n    const selectedOptions = this.selectedOptions;\n    if (selectedOptions.length === 0) {\n      return '';\n    }\n    if (selectedOptions.length === 1) {\n      return selectedOptions[0]?.label;\n    }\n    return `${\n      selectedOptions.length === this.options.length\n        ? 'All'\n        : selectedOptions.length\n    } selected`;\n  }\n\n  /**\n   * Whether multiple selection is allowed.\n   */\n  get multiple() {\n    return this.valueHolder instanceof MultiSelectDirectiveBase;\n  }\n\n  ngAfterContentInit(): void {\n    this.initKeyManager();\n\n    this.options.changes.subscribe(() => {\n      this.initKeyManager();\n    });\n    Promise.resolve().then(() => {\n      this._initialized = true;\n    });\n  }\n\n  ngAfterViewInit() {\n    /**\n     * This is to avoid an NG0100 ExpressionChangedAfter... error when there is an initial value\n     * The issue is probably due to the fact that options are defined withing the **content**\n     * (sp-option elements), so the listbox value can change after the view of select is checked,\n     * if there is a default value. And that leads to the error, since we have bindings in the\n     * template, such as `getSelectionText()`, that depend on the listbox value.\n     */\n    if (this.listboxValue.length > 0) {\n      this.changeDetectorRef.detectChanges();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.keyManager?.destroy();\n  }\n\n  /**\n   * Called when an item in the listbox is selected.\n   */\n  _handleSelected() {\n    if (!this.multiple) {\n      this.triggerRef?.close();\n    }\n    this.selected.emit();\n  }\n\n  isOpen(): boolean {\n    return this.triggerRef?.isOpen() ?? false;\n  }\n\n  open() {\n    this.triggerRef?.open();\n  }\n\n  close() {\n    this.triggerRef?.close();\n  }\n\n  toggle() {\n    this.triggerRef?.open();\n  }\n\n  protected getFieldLabel?(): string;\n\n  getLabelText(): string | undefined {\n    return (this.getFieldLabel?.() ?? this.ariaLabel)?.trim();\n  }\n\n  protected controlValueAccessorChangeFn: (value: any) => void = () => {};\n  public onTouched: () => any = () => {};\n\n  public _onOpen(): void {\n    this.opened.emit();\n  }\n\n  public _onClose(): void {\n    this.closed.emit();\n    this.onTouched();\n  }\n\n  /**\n   * Implemented as part of ControlValueAccessor.\n   */\n  registerOnChange(fn: any): void {\n    this.controlValueAccessorChangeFn = fn;\n  }\n\n  /**\n   * Implemented as part of ControlValueAccessor.\n   */\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  /**\n   * Implemented as part of ControlValueAccessor.\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /**\n   * Implemented as part of ControlValueAccessor.\n   */\n  writeValue(value: unknown): void {\n    this.valueHolder.value = value;\n  }\n\n  protected getNextEnabledOptionValue(direction: 'left' | 'right' = 'right') {\n    const optionsArray = this.options?.toArray() || [];\n    let nextNonDisabledOption;\n    const selectedOption = this.selectedOptions[0];\n\n    const currentOptionIndex =\n      (selectedOption && optionsArray.indexOf(selectedOption)) ?? -1;\n    const notDisabled = (o: OptionComponent) => !o.disabled;\n\n    if (currentOptionIndex === -1) {\n      nextNonDisabledOption = optionsArray.find(notDisabled);\n    } else if (direction === 'left') {\n      nextNonDisabledOption = optionsArray\n        .slice(0, currentOptionIndex)\n        .reverse()\n        .find(notDisabled);\n    } else {\n      nextNonDisabledOption = optionsArray\n        .slice(currentOptionIndex + 1, optionsArray.length)\n        .find(notDisabled);\n    }\n\n    const nextNonDisabledOptionIndex = nextNonDisabledOption\n      ? optionsArray.indexOf(nextNonDisabledOption)\n      : currentOptionIndex;\n    return this.options?.get(nextNonDisabledOptionIndex)?.value;\n  }\n\n  protected initKeyManager(): void {\n    // destroy any existing key manager\n    this.keyManager?.destroy();\n\n    this.keyManager = new ListKeyManager<\n      { value: string } & ListKeyManagerOption\n    >(\n      this.options.map((option) => ({\n        value: option.value,\n        getLabel: () => option.label,\n        disabled: !!option.disabled,\n      }))\n    ).withTypeAhead();\n\n    this.keyManager.change.subscribe(() => {\n      const selectedOption = this.options?.find(\n        (option) => this.keyManager?.activeItem?.value === option.value\n      );\n\n      if (selectedOption) {\n        this.listboxValue = [selectedOption.value];\n      }\n    });\n  }\n}\n"]}

package/esm2020/lib/select/src/common/select-value-holder.mjs

@@ -0,0 +1,86 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A common base class to handle value for single and multiple selection.
+ * {@link MultiSelectDirectiveBase} and {@link SingleSelectDirectiveBase} implement and
+ * provide this interface. Note that the main purpose for such design is **not**
+ * to abstract out selection behavior. But to have accurate `value` and `valueChange`
+ * type for single and multiple selection mode. It would be possible to fully abstract out
+ * the selection behavior, and have Select component not know anything about selection being
+ * multiple or not, but it doesn't seem such a clear abstraction, and also not worth the additional
+ * complexity.
+ *
+ * At least one directive has to be defined for each select component to provide SelectValueHolder,
+ * extending either {@link MultiSelectDirectiveBase} or {@link SingleSelectDirectiveBase}
+ */
+export class SelectValueHolder {
+}
+/**
+ * Enables multiple selection. When present, `value` will be of type `string[]`, and `valueChange`
+ * will emit `string[]`.
+ *
+ * Each select component can define a directive with the right selector (usually based on
+ * the presence of `multiple` attribute) to enable multiple selection.
+ */
+export class MultiSelectDirectiveBase extends SelectValueHolder {
+    constructor() {
+        super(...arguments);
+        this.value = [];
+        this.valueChange = new EventEmitter();
+    }
+    setFromListboxValue(value) {
+        this.value = value;
+        this.valueChange.emit(this.value);
+    }
+    getListboxValue() {
+        return this.value || [];
+    }
+}
+MultiSelectDirectiveBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MultiSelectDirectiveBase, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+MultiSelectDirectiveBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: MultiSelectDirectiveBase, inputs: { value: "value" }, outputs: { valueChange: "valueChange" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: MultiSelectDirectiveBase, decorators: [{
+            type: Directive
+        }], propDecorators: { value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+/**
+ * Enables single selection, the default behavior of select.
+ * When present, `value` will be of type `string`, and `valueChange` will emit `string`.
+ *
+ * Each select component has to define a directive with the right selector (usually based on
+ * the absence of `multiple` attribute) to enable single selection.
+ */
+export class SingleSelectDirectiveBase extends SelectValueHolder {
+    constructor() {
+        super(...arguments);
+        this._value = '';
+        this.values = [];
+        this.valueChange = new EventEmitter();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this.values = value ? [value] : [];
+    }
+    setFromListboxValue(value) {
+        this.value = value[0];
+        this.valueChange.emit(this._value);
+    }
+    getListboxValue() {
+        return this.values;
+    }
+}
+SingleSelectDirectiveBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SingleSelectDirectiveBase, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+SingleSelectDirectiveBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: SingleSelectDirectiveBase, inputs: { value: "value" }, outputs: { valueChange: "valueChange" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SingleSelectDirectiveBase, decorators: [{
+            type: Directive
+        }], propDecorators: { value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/select/src/select/searchable-select.directive.mjs

@@ -0,0 +1,90 @@
+import { __decorate } from "tslib";
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { CoerceBoolean } from '../../../common/coerce-boolean.decorator';
+import { OptionComponent } from '../../../listbox/src/option.component';
+import { section, SectionDirective, } from '../../../listbox/src/section.directive';
+import * as i0 from "@angular/core";
+/**
+ * Marks sp-select as searchable. When used, a search input is rendered inside select trigger
+ * which allows filtering options, in a more convenient way than the default typeahead search.
+ * By default, rendered `sp-option`s are filtered based on the search value, but `searchValue`
+ * and `searchValueChange` can be used to control the search value and filter the `sp-options`
+ * upfront.
+ */
+export class SearchableSelectDirective {
+    constructor() {
+        /**
+         * Filtering function to be applied on each item. The default filter function
+         * does a case-insensitive search on optionComponent.label.
+         * The built-in filtering can be disabled by passing `null`. That's useful
+         * when filtering is fully controlled by filtering input sp-options based on
+         * {@property searchValue}.
+         */
+        this.filter = (optionComponent, searchQuery) => optionComponent.label.toLowerCase().includes(searchQuery?.toLowerCase());
+        this.searchValueChange = new EventEmitter();
+    }
+    get searchValue() {
+        return this._searchValue ?? '';
+    }
+    set searchValue(value) {
+        this._searchValue = value;
+    }
+    filterListboxItems(items, filter) {
+        const filteredOutOptions = [];
+        const filteredChildren = Array.from(items)
+            ?.map((item) => {
+            if (item instanceof OptionComponent) {
+                const isMatch = filter(item);
+                if (!isMatch) {
+                    filteredOutOptions.push(item);
+                }
+                return isMatch ? item : null;
+            }
+            if (item instanceof SectionDirective) {
+                const { filteredChildren: sectionFilteredChildren, filteredOutOptions: sectionFilteredOutOptions, } = this.filterListboxItems(item.children, filter);
+                filteredOutOptions.push(...sectionFilteredOutOptions);
+                if (sectionFilteredChildren.length > 0) {
+                    return section(sectionFilteredChildren.filter((item) => item instanceof OptionComponent), item.ariaLabel);
+                }
+                return null;
+            }
+            return null;
+        })
+            .filter(notNull);
+        return { filteredChildren, filteredOutOptions };
+    }
+    /**
+     * Used when search value is updated via UI, and searchValueChange output should be emitted.
+     * @internal
+     */
+    setSearchValue(searchValue) {
+        this._searchValue = searchValue;
+        this.searchValueChange.emit(searchValue);
+    }
+    defaultFilter(optionComponent, searchQuery) {
+        return optionComponent.label
+            .toLowerCase()
+            .includes(searchQuery?.toLowerCase());
+    }
+}
+SearchableSelectDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SearchableSelectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+SearchableSelectDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.0", type: SearchableSelectDirective, selector: "sp-select[searchable]", inputs: { searchValue: "searchValue", filter: "filter", selectTextOnOpen: "selectTextOnOpen" }, outputs: { searchValueChange: "searchValueChange" }, ngImport: i0 });
+__decorate([
+    CoerceBoolean
+], SearchableSelectDirective.prototype, "selectTextOnOpen", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: SearchableSelectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'sp-select[searchable]',
+                }]
+        }], propDecorators: { searchValue: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], selectTextOnOpen: [{
+                type: Input
+            }], searchValueChange: [{
+                type: Output
+            }] } });
+export const notNull = (item) => item != null;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"searchable-select.directive.js","sourceRoot":"","sources":["../../../../../../src/lib/select/src/select/searchable-select.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EventEmitter, Input, Output } from '@angular/core';\nimport { CoerceBoolean } from '../../../common/coerce-boolean.decorator';\nimport { BooleanInput } from '@angular/cdk/coercion';\nimport { ListboxChild } from '../../../listbox/src/listbox-child';\nimport { OptionComponent } from '../../../listbox/src/option.component';\nimport {\n  section,\n  SectionDirective,\n} from '../../../listbox/src/section.directive';\n\n/**\n * Marks sp-select as searchable. When used, a search input is rendered inside select trigger\n * which allows filtering options, in a more convenient way than the default typeahead search.\n * By default, rendered `sp-option`s are filtered based on the search value, but `searchValue`\n * and `searchValueChange` can be used to control the search value and filter the `sp-options`\n * upfront.\n */\n@Directive({\n  selector: 'sp-select[searchable]',\n})\nexport class SearchableSelectDirective {\n  @Input()\n  get searchValue() {\n    return this._searchValue ?? '';\n  }\n  set searchValue(value: string | undefined) {\n    this._searchValue = value;\n  }\n  private _searchValue: string | undefined;\n\n  /**\n   * Filtering function to be applied on each item. The default filter function\n   * does a case-insensitive search on optionComponent.label.\n   * The built-in filtering can be disabled by passing `null`. That's useful\n   * when filtering is fully controlled by filtering input sp-options based on\n   * {@property searchValue}.\n   */\n  @Input()\n  filter?:\n    | null\n    | ((optionComponent: OptionComponent, searchQuery: string) => boolean) = (\n    optionComponent: OptionComponent,\n    searchQuery: string\n  ) => optionComponent.label.toLowerCase().includes(searchQuery?.toLowerCase());\n\n  @Input()\n  @CoerceBoolean\n  selectTextOnOpen?: BooleanInput;\n\n  @Output()\n  searchValueChange = new EventEmitter<string>();\n\n  filterListboxItems(\n    items: Iterable<ListboxChild>,\n    filter: (option: OptionComponent) => boolean\n  ): {\n    filteredChildren: ListboxChild[];\n    filteredOutOptions: OptionComponent[];\n  } {\n    const filteredOutOptions: OptionComponent[] = [];\n    const filteredChildren = Array.from(items)\n      ?.map((item): ListboxChild | null => {\n        if (item instanceof OptionComponent) {\n          const isMatch = filter(item);\n          if (!isMatch) {\n            filteredOutOptions.push(item);\n          }\n          return isMatch ? item : null;\n        }\n        if (item instanceof SectionDirective) {\n          const {\n            filteredChildren: sectionFilteredChildren,\n            filteredOutOptions: sectionFilteredOutOptions,\n          } = this.filterListboxItems(item.children, filter);\n          filteredOutOptions.push(...sectionFilteredOutOptions);\n          if (sectionFilteredChildren.length > 0) {\n            return section(\n              sectionFilteredChildren.filter(\n                (item): item is OptionComponent =>\n                  item instanceof OptionComponent\n              ),\n              item.ariaLabel\n            );\n          }\n          return null;\n        }\n        return null;\n      })\n      .filter(notNull);\n    return { filteredChildren, filteredOutOptions };\n  }\n\n  /**\n   * Used when search value is updated via UI, and searchValueChange output should be emitted.\n   * @internal\n   */\n  setSearchValue(searchValue: string) {\n    this._searchValue = searchValue;\n    this.searchValueChange.emit(searchValue);\n  }\n\n  defaultFilter(optionComponent: OptionComponent, searchQuery: string) {\n    return optionComponent.label\n      .toLowerCase()\n      .includes(searchQuery?.toLowerCase());\n  }\n}\n\nexport const notNull = <T>(\n  item: T | undefined | null\n): item is NonNullable<T> => item != null;\n"]}