@angular/cdk-experimental 14.0.0-rc.2 → 14.1.0-next.0

package/esm2020/listbox/listbox.mjs

@@ -5,128 +5,127 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { ContentChildren, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, Optional, Output, QueryList, } from '@angular/core';
+import { ChangeDetectorRef, ContentChildren, Directive, ElementRef, forwardRef, inject, InjectFlags, Input, Output, QueryList, } from '@angular/core';
 import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
 import { DOWN_ARROW, ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW } from '@angular/cdk/keycodes';
 import { coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';
 import { SelectionModel } from '@angular/cdk/collections';
-import { defer, merge, Subject } from 'rxjs';
-import { startWith, switchMap, takeUntil } from 'rxjs/operators';
-import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { BehaviorSubject, combineLatest, defer, merge, Subject } from 'rxjs';
+import { filter, mapTo, startWith, switchMap, take, takeUntil } from 'rxjs/operators';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
 import { Directionality } from '@angular/cdk/bidi';
-import { CDK_COMBOBOX, CdkCombobox } from '@angular/cdk-experimental/combobox';
+import { CdkCombobox } from '@angular/cdk-experimental/combobox';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/cdk/bidi";
-import * as i2 from "@angular/cdk-experimental/combobox";
+/** The next id to use for creating unique DOM IDs. */
 let nextId = 0;
-let listboxId = 0;
-export const CDK_LISTBOX_VALUE_ACCESSOR = {
-    provide: NG_VALUE_ACCESSOR,
-    useExisting: forwardRef(() => CdkListbox),
-    multi: true,
-};
+// TODO(mmalerba):
+//   - should listbox wrap be configurable?
+//   - should skipping disabled options be configurable?
+/** A selectable option in a listbox. */
 export class CdkOption {
-    constructor(_elementRef, listbox) {
-        this._elementRef = _elementRef;
-        this.listbox = listbox;
-        this._selected = false;
+    constructor() {
+        this._generatedId = `cdk-option-${nextId++}`;
         this._disabled = false;
+        /** The option's host element */
+        this.element = inject(ElementRef).nativeElement;
+        /** The parent listbox this option belongs to. */
+        this.listbox = inject(CdkListbox);
+        /** Emits when the option is destroyed. */
+        this.destroyed = new Subject();
+        /** Emits when the option is clicked. */
+        this._clicked = new Subject();
+        /** Whether the option is currently active. */
         this._active = false;
-        /** The id of the option, set to a uniqueid if the user does not provide one. */
-        this.id = `cdk-option-${nextId++}`;
-        this.selectionChange = new EventEmitter();
     }
-    get selected() {
-        return this._selected;
+    /** The id of the option's host element. */
+    get id() {
+        return this._id || this._generatedId;
     }
-    set selected(value) {
-        if (!this._disabled) {
-            this._selected = coerceBooleanProperty(value);
-        }
+    set id(value) {
+        this._id = value;
     }
+    /** Whether this option is disabled. */
     get disabled() {
-        return this._disabled;
+        return this.listbox.disabled || this._disabled;
     }
     set disabled(value) {
         this._disabled = coerceBooleanProperty(value);
     }
-    /** The form value of the option. */
-    get value() {
-        return this._value;
+    /** The tabindex of the option when it is enabled. */
+    get enabledTabIndex() {
+        return this._enabledTabIndex === undefined
+            ? this.listbox.enabledTabIndex
+            : this._enabledTabIndex;
     }
-    set value(value) {
-        if (this.selected && value !== this._value) {
-            this.deselect();
-        }
-        this._value = value;
+    set enabledTabIndex(value) {
+        this._enabledTabIndex = value;
     }
-    /** Toggles the selected state, emits a change event through the injected listbox. */
-    toggle() {
-        if (!this._isInteractionDisabled()) {
-            this.selected = !this.selected;
-            this._emitSelectionChange(true);
-        }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
     }
-    /** Sets the active property true if the option and listbox aren't disabled. */
-    activate() {
-        if (!this._isInteractionDisabled()) {
-            this._active = true;
-        }
+    /** Whether this option is selected. */
+    isSelected() {
+        return this.listbox.isSelected(this.value);
     }
-    /** Sets the active property false. */
-    deactivate() {
-        if (!this._isInteractionDisabled()) {
-            this._active = false;
-        }
+    /** Whether this option is active. */
+    isActive() {
+        return this._active;
     }
-    /** Sets the selected property true if it was false. */
+    /** Toggle the selected state of this option. */
+    toggle() {
+        this.listbox.toggle(this);
+    }
+    /** Select this option if it is not selected. */
     select() {
-        if (!this.selected) {
-            this.selected = true;
-            this._emitSelectionChange();
-        }
+        this.listbox.select(this);
     }
-    /** Sets the selected property false if it was true. */
+    /** Deselect this option if it is selected. */
     deselect() {
-        if (this.selected) {
-            this.selected = false;
-            this._emitSelectionChange();
-        }
+        this.listbox.deselect(this);
     }
-    /** Applies focus to the option. */
+    /** Focus this option. */
     focus() {
-        this._elementRef.nativeElement.focus();
-    }
-    /** Returns true if the option or listbox are disabled, and false otherwise. */
-    _isInteractionDisabled() {
-        return this.listbox.disabled || this._disabled;
-    }
-    /** Emits a change event extending the Option Selection Change Event interface. */
-    _emitSelectionChange(isUserInput = false) {
-        this.selectionChange.emit({
-            source: this,
-            isUserInput: isUserInput,
-        });
-    }
-    /** Returns the tab index which depends on the disabled property. */
-    _getTabIndex() {
-        return this._isInteractionDisabled() ? null : '-1';
+        this.element.focus();
     }
     /** Get the label for this element which is required by the FocusableOption interface. */
     getLabel() {
-        return (this.typeahead ?? this._elementRef.nativeElement.textContent?.trim()) || '';
+        return (this.typeaheadLabel ?? this.element.textContent?.trim()) || '';
     }
-    /** Sets the active property to true to enable the active css class. */
+    /**
+     * Set the option as active.
+     * @docs-private
+     */
     setActiveStyles() {
         this._active = true;
     }
-    /** Sets the active property to false to disable the active css class. */
+    /**
+     * Set the option as inactive.
+     * @docs-private
+     */
     setInactiveStyles() {
         this._active = false;
     }
+    /** Handle focus events on the option. */
+    _handleFocus() {
+        // Options can wind up getting focused in active descendant mode if the user clicks on them.
+        // In this case, we push focus back to the parent listbox to prevent an extra tab stop when
+        // the user performs a shift+tab.
+        if (this.listbox.useActiveDescendant) {
+            this.listbox._setActiveOption(this);
+            this.listbox.focus();
+        }
+    }
+    /** Get the tabindex for this option. */
+    _getTabIndex() {
+        if (this.listbox.useActiveDescendant || this.disabled) {
+            return -1;
+        }
+        return this.isActive() ? this.enabledTabIndex : -1;
+    }
 }
-CdkOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkOption, deps: [{ token: i0.ElementRef }, { token: forwardRef(() => CdkListbox) }], target: i0.ɵɵFactoryTarget.Directive });
-CdkOption.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-rc.1", type: CdkOption, selector: "[cdkOption]", inputs: { id: "id", selected: "selected", disabled: "disabled", value: "value", typeahead: "typeahead" }, outputs: { selectionChange: "selectionChange" }, host: { attributes: { "role": "option" }, listeners: { "click": "toggle()", "focus": "activate()", "blur": "deactivate()" }, properties: { "id": "id", "attr.aria-selected": "selected || null", "attr.tabindex": "_getTabIndex()", "attr.aria-disabled": "_isInteractionDisabled()", "class.cdk-option-disabled": "_isInteractionDisabled()", "class.cdk-option-active": "_active", "class.cdk-option-selected": "selected" }, classAttribute: "cdk-option" }, exportAs: ["cdkOption"], ngImport: i0 });
+CdkOption.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkOption, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkOption.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-rc.1", type: CdkOption, selector: "[cdkOption]", inputs: { id: "id", value: ["cdkOption", "value"], typeaheadLabel: ["cdkOptionTypeaheadLabel", "typeaheadLabel"], disabled: ["cdkOptionDisabled", "disabled"], enabledTabIndex: ["tabindex", "enabledTabIndex"] }, host: { attributes: { "role": "option" }, listeners: { "click": "_clicked.next()", "focus": "_handleFocus()" }, properties: { "id": "id", "attr.aria-selected": "isSelected() || null", "attr.tabindex": "_getTabIndex()", "attr.aria-disabled": "disabled", "class.cdk-option-disabled": "disabled", "class.cdk-option-active": "isActive()", "class.cdk-option-selected": "isSelected()" }, classAttribute: "cdk-option" }, exportAs: ["cdkOption"], ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkOption, decorators: [{
             type: Directive,
             args: [{
@@ -135,70 +134,134 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-rc.1", ng
                     host: {
                         'role': 'option',
                         'class': 'cdk-option',
-                        '(click)': 'toggle()',
-                        '(focus)': 'activate()',
-                        '(blur)': 'deactivate()',
                         '[id]': 'id',
-                        '[attr.aria-selected]': 'selected || null',
+                        '[attr.aria-selected]': 'isSelected() || null',
                         '[attr.tabindex]': '_getTabIndex()',
-                        '[attr.aria-disabled]': '_isInteractionDisabled()',
-                        '[class.cdk-option-disabled]': '_isInteractionDisabled()',
-                        '[class.cdk-option-active]': '_active',
-                        '[class.cdk-option-selected]': 'selected',
+                        '[attr.aria-disabled]': 'disabled',
+                        '[class.cdk-option-disabled]': 'disabled',
+                        '[class.cdk-option-active]': 'isActive()',
+                        '[class.cdk-option-selected]': 'isSelected()',
+                        '(click)': '_clicked.next()',
+                        '(focus)': '_handleFocus()',
                     },
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: CdkListbox, decorators: [{
-                    type: Inject,
-                    args: [forwardRef(() => CdkListbox)]
-                }] }]; }, propDecorators: { id: [{
-                type: Input
-            }], selected: [{
-                type: Input
-            }], disabled: [{
+        }], propDecorators: { id: [{
                 type: Input
             }], value: [{
-                type: Input
-            }], typeahead: [{
-                type: Input
-            }], selectionChange: [{
-                type: Output
+                type: Input,
+                args: ['cdkOption']
+            }], typeaheadLabel: [{
+                type: Input,
+                args: ['cdkOptionTypeaheadLabel']
+            }], disabled: [{
+                type: Input,
+                args: ['cdkOptionDisabled']
+            }], enabledTabIndex: [{
+                type: Input,
+                args: ['tabindex']
             }] } });
 export class CdkListbox {
-    constructor(_combobox, _dir) {
-        this._combobox = _combobox;
-        this._dir = _dir;
-        this._tabIndex = 0;
-        /** `View -> model callback called when select has been touched` */
-        this._onTouched = () => { };
-        /** `View -> model callback called when value changes` */
-        this._onChange = () => { };
-        this.optionSelectionChanges = defer(() => {
-            const options = this._options;
-            return options.changes.pipe(startWith(options), switchMap(() => merge(...options.map(option => option.selectionChange))));
-        });
-        this._disabled = false;
+    constructor() {
+        this._generatedId = `cdk-listbox-${nextId++}`;
         this._multiple = false;
+        this._disabled = false;
         this._useActiveDescendant = false;
-        this._autoFocus = true;
-        this._destroyed = new Subject();
-        this.selectionChange = new EventEmitter();
-        this.id = `cdk-listbox-${listboxId++}`;
-        /** Determines the orientation for the list key manager. Affects keyboard interaction. */
+        /** The orientation of the listbox. Only affects keyboard interaction, not visual layout. */
         this.orientation = 'vertical';
-        this.compareWith = (a1, a2) => a1 === a2;
+        /** Emits when the selected value(s) in the listbox change. */
+        this.valueChange = new Subject();
+        // TODO(mmalerba): Refactor SelectionModel so that its not necessary to create new instances
+        /** The selection model used by the listbox. */
+        this.selectionModelSubject = new BehaviorSubject(new SelectionModel(this.multiple, [], true, this._compareWith));
+        /** Emits when the listbox is destroyed. */
+        this.destroyed = new Subject();
+        /** The host element of the listbox. */
+        this.element = inject(ElementRef).nativeElement;
+        /** The change detector for this listbox. */
+        this.changeDetectorRef = inject(ChangeDetectorRef);
+        /** Callback called when the listbox has been touched */
+        this._onTouched = () => { };
+        /** Callback called when the listbox value changes */
+        this._onChange = () => { };
+        /** Callback called when the form validator changes. */
+        this._onValidatorChange = () => { };
+        /** Emits when an option has been clicked. */
+        this._optionClicked = defer(() => this.options.changes.pipe(startWith(this.options), switchMap(options => merge(...options.map(option => option._clicked.pipe(mapTo(option)))))));
+        /** The directionality of the page. */
+        this._dir = inject(Directionality, InjectFlags.Optional);
+        // TODO(mmalerba): Should not depend on combobox
+        this._combobox = inject(CdkCombobox, InjectFlags.Optional);
+        /**
+         * Validator that produces an error if multiple values are selected in a single selection
+         * listbox.
+         * @param control The control to validate
+         * @return A validation error or null
+         */
+        this._validateMultipleValues = (control) => {
+            const controlValue = this._coerceValue(control.value);
+            if (!this.multiple && controlValue.length > 1) {
+                return { 'cdkListboxMultipleValues': true };
+            }
+            return null;
+        };
+        /**
+         * Validator that produces an error if any selected values are not valid options for this listbox.
+         * @param control The control to validate
+         * @return A validation error or null
+         */
+        this._validateInvalidValues = (control) => {
+            const controlValue = this._coerceValue(control.value);
+            const invalidValues = this._getValuesWithValidity(controlValue, false);
+            if (invalidValues.length) {
+                return { 'cdkListboxInvalidValues': { 'values': invalidValues } };
+            }
+            return null;
+        };
+        /** The combined set of validators for this listbox. */
+        this._validators = Validators.compose([
+            this._validateMultipleValues,
+            this._validateInvalidValues,
+        ]);
+        this.selectionModelSubject
+            .pipe(switchMap(selectionModel => selectionModel.changed), takeUntil(this.destroyed))
+            .subscribe(() => {
+            this._updateInternalValue();
+        });
+    }
+    /** The id of the option's host element. */
+    get id() {
+        return this._id || this._generatedId;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    /** The tabindex to use when the listbox is enabled. */
+    get enabledTabIndex() {
+        return this._enabledTabIndex === undefined ? 0 : this._enabledTabIndex;
+    }
+    set enabledTabIndex(value) {
+        this._enabledTabIndex = value;
+    }
+    /** The value selected in the listbox, represented as an array of option values. */
+    get value() {
+        return this.selectionModel().selected;
+    }
+    set value(value) {
+        this._setSelection(value);
     }
     /**
-     * Whether the listbox allows multiple options to be selected.
-     * If `multiple` switches from `true` to `false`, all options are deselected.
+     * Whether the listbox allows multiple options to be selected. If the value switches from `true`
+     * to `false`, and more than one option is selected, all options are deselected.
      */
     get multiple() {
         return this._multiple;
     }
     set multiple(value) {
-        const coercedValue = coerceBooleanProperty(value);
-        this._updateSelectionOnMultiSelectionChange(coercedValue);
-        this._multiple = coercedValue;
+        this._multiple = coerceBooleanProperty(value);
+        this._updateSelectionModel();
+        this._onValidatorChange();
     }
+    /** Whether the listbox is disabled. */
     get disabled() {
         return this._disabled;
     }
@@ -212,226 +275,400 @@ export class CdkListbox {
     set useActiveDescendant(shouldUseActiveDescendant) {
         this._useActiveDescendant = coerceBooleanProperty(shouldUseActiveDescendant);
     }
-    /** Whether on focus the listbox will focus its active option, default to true. */
-    get autoFocus() {
-        return this._autoFocus;
+    /** The function used to compare option values. */
+    get compareWith() {
+        return this._compareWith;
     }
-    set autoFocus(shouldAutoFocus) {
-        this._autoFocus = coerceBooleanProperty(shouldAutoFocus);
-    }
-    ngOnInit() {
-        this._selectionModel = new SelectionModel(this.multiple);
+    set compareWith(fn) {
+        this._compareWith = fn;
+        this._updateSelectionModel();
     }
     ngAfterContentInit() {
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            this._verifyNoOptionValueCollisions();
+        }
         this._initKeyManager();
-        this._initSelectionModel();
         this._combobox?._registerContent(this.id, 'listbox');
-        this.optionSelectionChanges.subscribe(event => {
-            this._emitChangeEvent(event.source);
-            this._updateSelectionModel(event.source);
-            this.setActiveOption(event.source);
-            this._updatePanelForSelection(event.source);
+        this.options.changes.pipe(takeUntil(this.destroyed)).subscribe(() => {
+            this._updateInternalValue();
+            this._onValidatorChange();
         });
+        this._optionClicked
+            .pipe(filter(option => !option.disabled), takeUntil(this.destroyed))
+            .subscribe(option => this._handleOptionClicked(option));
     }
     ngOnDestroy() {
-        this._listKeyManager.change.complete();
-        this._destroyed.next();
-        this._destroyed.complete();
+        this.listKeyManager.change.complete();
+        this.destroyed.next();
+        this.destroyed.complete();
     }
-    _initKeyManager() {
-        this._listKeyManager = new ActiveDescendantKeyManager(this._options)
-            .withWrap()
-            .withTypeAhead()
-            .withHomeAndEnd()
-            .withAllowedModifierKeys(['shiftKey']);
-        if (this.orientation === 'vertical') {
-            this._listKeyManager.withVerticalOrientation();
+    /**
+     * Toggle the selected state of the given option.
+     * @param option The option to toggle
+     */
+    toggle(option) {
+        this.toggleValue(option.value);
+    }
+    /**
+     * Toggle the selected state of the given value.
+     * @param value The value to toggle
+     */
+    toggleValue(value) {
+        this.selectionModel().toggle(value);
+    }
+    /**
+     * Select the given option.
+     * @param option The option to select
+     */
+    select(option) {
+        this.selectValue(option.value);
+    }
+    /**
+     * Select the given value.
+     * @param value The value to select
+     */
+    selectValue(value) {
+        this.selectionModel().select(value);
+    }
+    /**
+     * Deselect the given option.
+     * @param option The option to deselect
+     */
+    deselect(option) {
+        this.deselectValue(option.value);
+    }
+    /**
+     * Deselect the given value.
+     * @param value The value to deselect
+     */
+    deselectValue(value) {
+        this.selectionModel().deselect(value);
+    }
+    /**
+     * Set the selected state of all options.
+     * @param isSelected The new selected state to set
+     */
+    setAllSelected(isSelected) {
+        if (!isSelected) {
+            this.selectionModel().clear();
         }
         else {
-            this._listKeyManager.withHorizontalOrientation(this._dir?.value || 'ltr');
+            this.selectionModel().select(...this.options.toArray().map(option => option.value));
         }
-        this._listKeyManager.change.pipe(takeUntil(this._destroyed)).subscribe(() => {
-            this._updateActiveOption();
-        });
     }
-    _initSelectionModel() {
-        this._selectionModel.changed
-            .pipe(takeUntil(this._destroyed))
-            .subscribe((event) => {
-            for (const option of event.added) {
-                option.selected = true;
+    /**
+     * Get whether the given option is selected.
+     * @param option The option to get the selected state of
+     */
+    isSelected(option) {
+        return this.selectionModel().isSelected(option instanceof CdkOption ? option.value : option);
+    }
+    /**
+     * Registers a callback to be invoked when the listbox's value changes from user input.
+     * @param fn The callback to register
+     * @docs-private
+     */
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    /**
+     * Registers a callback to be invoked when the listbox is blurred by the user.
+     * @param fn The callback to register
+     * @docs-private
+     */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /**
+     * Sets the listbox's value.
+     * @param value The new value of the listbox
+     * @docs-private
+     */
+    writeValue(value) {
+        this._setSelection(value);
+    }
+    /**
+     * Sets the disabled state of the listbox.
+     * @param isDisabled The new disabled state
+     * @docs-private
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * Validate the given control
+     * @docs-private
+     */
+    validate(control) {
+        return this._validators(control);
+    }
+    /**
+     * Registers a callback to be called when the form validator changes.
+     * @param fn The callback to call
+     * @docs-private
+     */
+    registerOnValidatorChange(fn) {
+        this._onValidatorChange = fn;
+    }
+    /** Focus the listbox's host element. */
+    focus() {
+        this.element.focus();
+    }
+    /** The selection model used to track the listbox's value. */
+    selectionModel() {
+        return this.selectionModelSubject.value;
+    }
+    /**
+     * Triggers the given option in response to user interaction.
+     * - In single selection mode: selects the option and deselects any other selected option.
+     * - In multi selection mode: toggles the selected state of the option.
+     * @param option The option to trigger
+     */
+    triggerOption(option) {
+        if (option && !option.disabled) {
+            let changed = false;
+            this.selectionModel()
+                .changed.pipe(take(1), takeUntil(this.destroyed))
+                .subscribe(() => (changed = true));
+            if (this.multiple) {
+                this.toggle(option);
             }
-            for (const option of event.removed) {
-                option.selected = false;
+            else {
+                this.select(option);
             }
-        });
+            if (changed) {
+                this._onChange(this.value);
+                this.valueChange.next({
+                    value: this.value,
+                    listbox: this,
+                    option: option,
+                });
+            }
+        }
+    }
+    /**
+     * Sets the given option as active.
+     * @param option The option to make active
+     */
+    _setActiveOption(option) {
+        this.listKeyManager.setActiveItem(option);
     }
-    _keydown(event) {
+    /** Called when the listbox receives focus. */
+    _handleFocus() {
+        if (!this.useActiveDescendant) {
+            this.listKeyManager.setNextItemActive();
+            this._focusActiveOption();
+        }
+    }
+    /** Called when the user presses keydown on the listbox. */
+    _handleKeydown(event) {
         if (this._disabled) {
             return;
         }
-        const manager = this._listKeyManager;
         const { keyCode } = event;
-        const previousActiveIndex = manager.activeItemIndex;
+        const previousActiveIndex = this.listKeyManager.activeItemIndex;
         if (keyCode === SPACE || keyCode === ENTER) {
-            if (manager.activeItem && !manager.isTyping()) {
-                this._toggleActiveOption();
-            }
+            this.triggerOption(this.listKeyManager.activeItem);
             event.preventDefault();
         }
         else {
-            manager.onKeydown(event);
+            this.listKeyManager.onKeydown(event);
         }
         /** Will select an option if shift was pressed while navigating to the option */
         const isArrow = keyCode === UP_ARROW ||
             keyCode === DOWN_ARROW ||
             keyCode === LEFT_ARROW ||
             keyCode === RIGHT_ARROW;
-        if (isArrow && event.shiftKey && previousActiveIndex !== this._listKeyManager.activeItemIndex) {
-            this._toggleActiveOption();
+        if (isArrow && event.shiftKey && previousActiveIndex !== this.listKeyManager.activeItemIndex) {
+            this.triggerOption(this.listKeyManager.activeItem);
         }
     }
-    /** Emits a selection change event, called when an option has its selected state changed. */
-    _emitChangeEvent(option) {
-        this.selectionChange.emit({
-            source: this,
-            option: option,
-        });
+    /**
+     * Called when the focus leaves an element in the listbox.
+     * @param event The focusout event
+     */
+    _handleFocusOut(event) {
+        const otherElement = event.relatedTarget;
+        if (this.element !== otherElement && !this.element.contains(otherElement)) {
+            this._onTouched();
+        }
+    }
+    /** Get the id of the active option if active descendant is being used. */
+    _getAriaActiveDescendant() {
+        return this._useActiveDescendant ? this.listKeyManager?.activeItem?.id : null;
     }
-    /** Updates the selection model after a toggle. */
-    _updateSelectionModel(option) {
-        if (!this.multiple && this._selectionModel.selected.length !== 0) {
-            const previouslySelected = this._selectionModel.selected[0];
-            this.deselect(previouslySelected);
+    /** Get the tabindex for the listbox. */
+    _getTabIndex() {
+        if (this.disabled) {
+            return -1;
+        }
+        return this.useActiveDescendant || !this.listKeyManager.activeItem ? this.enabledTabIndex : -1;
+    }
+    /** Initialize the key manager. */
+    _initKeyManager() {
+        this.listKeyManager = new ActiveDescendantKeyManager(this.options)
+            .withWrap()
+            .withTypeAhead()
+            .withHomeAndEnd()
+            .withAllowedModifierKeys(['shiftKey']);
+        if (this.orientation === 'vertical') {
+            this.listKeyManager.withVerticalOrientation();
+        }
+        else {
+            this.listKeyManager.withHorizontalOrientation(this._dir?.value || 'ltr');
         }
-        option.selected ? this._selectionModel.select(option) : this._selectionModel.deselect(option);
+        this.listKeyManager.change
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(() => this._focusActiveOption());
     }
+    // TODO(mmalerba): Should not depend on combobox.
     _updatePanelForSelection(option) {
         if (this._combobox) {
             if (!this.multiple) {
-                this._combobox.updateAndClose(option.selected ? option.value : []);
+                this._combobox.updateAndClose(option.isSelected() ? option.value : []);
             }
             else {
-                this._combobox.updateAndClose(this.getSelectedValues());
+                this._combobox.updateAndClose(this.value);
             }
         }
     }
-    /** Toggles the selected state of the active option if not disabled. */
-    _toggleActiveOption() {
-        const activeOption = this._listKeyManager.activeItem;
-        if (activeOption && !activeOption.disabled) {
-            activeOption.toggle();
-        }
-    }
-    /** Returns the id of the active option if active descendant is being used. */
-    _getAriaActiveDescendant() {
-        return this._useActiveDescendant ? this._listKeyManager?.activeItem?.id : null;
-    }
-    /** Updates the activeOption and the active and focus properties of the option. */
-    _updateActiveOption() {
-        if (!this._listKeyManager.activeItem) {
-            return;
-        }
-        this._activeOption?.deactivate();
-        this._activeOption = this._listKeyManager.activeItem;
-        this._activeOption.activate();
-        if (!this.useActiveDescendant) {
-            this._activeOption.focus();
-        }
-    }
-    /** Updates selection states of options when the 'multiple' property changes. */
-    _updateSelectionOnMultiSelectionChange(value) {
-        if (this.multiple && !value) {
-            // Deselect all options instead of arbitrarily keeping one of the selected options.
-            this.setAllSelected(false);
-        }
-        else if (!this.multiple && value) {
-            this._selectionModel = new SelectionModel(value, this._selectionModel?.selected);
-        }
+    /** Update the selection mode when the 'multiple' property changes. */
+    _updateSelectionModel() {
+        this.selectionModelSubject.next(new SelectionModel(this.multiple, !this.multiple && this.value.length > 1 ? [] : this.value.slice(), true, this._compareWith));
     }
+    /** Focus the active option. */
     _focusActiveOption() {
-        if (!this.autoFocus) {
-            return;
-        }
-        if (this._listKeyManager.activeItem) {
-            this.setActiveOption(this._listKeyManager.activeItem);
-        }
-        else if (this._options.first) {
-            this.setActiveOption(this._options.first);
-        }
-    }
-    /** Selects the given option if the option and listbox aren't disabled. */
-    select(option) {
-        if (!this.disabled && !option.disabled) {
-            option.select();
-        }
-    }
-    /** Deselects the given option if the option and listbox aren't disabled. */
-    deselect(option) {
-        if (!this.disabled && !option.disabled) {
-            option.deselect();
-        }
-    }
-    /** Sets the selected state of all options to be the given value. */
-    setAllSelected(isSelected) {
-        for (const option of this._options.toArray()) {
-            isSelected ? this.select(option) : this.deselect(option);
+        if (!this.useActiveDescendant) {
+            this.listKeyManager.activeItem?.focus();
         }
-    }
-    /** Updates the key manager's active item to the given option. */
-    setActiveOption(option) {
-        this._listKeyManager.updateActiveItem(option);
-        this._updateActiveOption();
+        this.changeDetectorRef.markForCheck();
     }
     /**
-     * Saves a callback function to be invoked when the select's value
-     * changes from user input. Required to implement ControlValueAccessor.
+     * Set the selected values.
+     * @param value The list of new selected values.
      */
-    registerOnChange(fn) {
-        this._onChange = fn;
+    _setSelection(value) {
+        const coercedValue = this._coerceValue(value);
+        this.selectionModel().setSelection(...(!this.multiple && coercedValue.length > 1
+            ? []
+            : this._getValuesWithValidity(coercedValue, true)));
+    }
+    /** Update the internal value of the listbox based on the selection model. */
+    _updateInternalValue() {
+        const indexCache = new Map();
+        // Check if we need to remove any values due to them becoming invalid
+        // (e.g. if the option was removed from the DOM.)
+        const selected = this.selectionModel().selected;
+        const validSelected = this._getValuesWithValidity(selected, true);
+        if (validSelected.length != selected.length) {
+            this.selectionModel().setSelection(...validSelected);
+        }
+        this.selectionModel().sort((a, b) => {
+            const aIndex = this._getIndexForValue(indexCache, a);
+            const bIndex = this._getIndexForValue(indexCache, b);
+            return aIndex - bIndex;
+        });
+        this.changeDetectorRef.markForCheck();
     }
     /**
-     * Saves a callback function to be invoked when the select is blurred
-     * by the user. Required to implement ControlValueAccessor.
+     * Gets the index of the given value in the given list of options.
+     * @param cache The cache of indices found so far
+     * @param value The value to find
+     * @return The index of the value in the options list
      */
-    registerOnTouched(fn) {
-        this._onTouched = fn;
-    }
-    /** Sets the select's value. Required to implement ControlValueAccessor. */
-    writeValue(values) {
-        if (this._options) {
-            this._setSelectionByValue(values);
+    _getIndexForValue(cache, value) {
+        const isEqual = this.compareWith || Object.is;
+        if (!cache.has(value)) {
+            let index = -1;
+            for (let i = 0; i < this.options.length; i++) {
+                if (isEqual(value, this.options.get(i).value)) {
+                    index = i;
+                    break;
+                }
+            }
+            cache.set(value, index);
         }
+        return cache.get(value);
     }
-    /** Disables the select. Required to implement ControlValueAccessor. */
-    setDisabledState(isDisabled) {
-        this.disabled = isDisabled;
-    }
-    /** Returns the values of the currently selected options. */
-    getSelectedValues() {
-        return this._options.filter(option => option.selected).map(option => option.value);
-    }
-    /** Selects an option that has the corresponding given value. */
-    _setSelectionByValue(values) {
-        for (const option of this._options.toArray()) {
-            this.deselect(option);
-        }
-        const valuesArray = coerceArray(values);
-        for (const value of valuesArray) {
-            const correspondingOption = this._options.find((option) => {
-                return option.value != null && this.compareWith(option.value, value);
-            });
-            if (correspondingOption) {
-                this.select(correspondingOption);
-                if (!this.multiple) {
+    /**
+     * Handle the user clicking an option.
+     * @param option The option that was clicked.
+     */
+    _handleOptionClicked(option) {
+        this.listKeyManager.setActiveItem(option);
+        this.triggerOption(option);
+        this._updatePanelForSelection(option);
+    }
+    /** Verifies that no two options represent the same value under the compareWith function. */
+    _verifyNoOptionValueCollisions() {
+        combineLatest([
+            this.selectionModelSubject,
+            this.options.changes.pipe(startWith(this.options)),
+        ]).subscribe(() => {
+            const isEqual = this.compareWith ?? Object.is;
+            for (let i = 0; i < this.options.length; i++) {
+                const option = this.options.get(i);
+                let duplicate = null;
+                for (let j = i + 1; j < this.options.length; j++) {
+                    const other = this.options.get(j);
+                    if (isEqual(option.value, other.value)) {
+                        duplicate = other;
+                        break;
+                    }
+                }
+                if (duplicate) {
+                    // TODO(mmalerba): Link to docs about this.
+                    if (this.compareWith) {
+                        console.warn(`Found multiple CdkOption representing the same value under the given compareWith function`, {
+                            option1: option.element,
+                            option2: duplicate.element,
+                            compareWith: this.compareWith,
+                        });
+                    }
+                    else {
+                        console.warn(`Found multiple CdkOption with the same value`, {
+                            option1: option.element,
+                            option2: duplicate.element,
+                        });
+                    }
                     return;
                 }
             }
-        }
+        });
+    }
+    /**
+     * Coerces a value into an array representing a listbox selection.
+     * @param value The value to coerce
+     * @return An array
+     */
+    _coerceValue(value) {
+        return value == null ? [] : coerceArray(value);
+    }
+    /**
+     * Get the sublist of values with the given validity.
+     * @param values The list of values
+     * @param valid Whether to get valid values
+     * @return The sublist of values with the requested validity
+     */
+    _getValuesWithValidity(values, valid) {
+        const isEqual = this.compareWith || Object.is;
+        const validValues = (this.options || []).map(option => option.value);
+        return values.filter(value => valid === validValues.some(validValue => isEqual(value, validValue)));
     }
 }
-CdkListbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkListbox, deps: [{ token: CDK_COMBOBOX, optional: true }, { token: i1.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-CdkListbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-rc.1", type: CdkListbox, selector: "[cdkListbox]", inputs: { id: "id", multiple: "multiple", disabled: "disabled", useActiveDescendant: "useActiveDescendant", autoFocus: "autoFocus", orientation: ["listboxOrientation", "orientation"], compareWith: "compareWith" }, outputs: { selectionChange: "selectionChange" }, host: { attributes: { "role": "listbox" }, listeners: { "focus": "_focusActiveOption()", "keydown": "_keydown($event)" }, properties: { "id": "id", "attr.tabindex": "_tabIndex", "attr.aria-disabled": "disabled", "attr.aria-multiselectable": "multiple", "attr.aria-activedescendant": "_getAriaActiveDescendant()", "attr.aria-orientation": "orientation" }, classAttribute: "cdk-listbox" }, providers: [CDK_LISTBOX_VALUE_ACCESSOR], queries: [{ propertyName: "_options", predicate: CdkOption, descendants: true }], exportAs: ["cdkListbox"], ngImport: i0 });
+CdkListbox.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkListbox, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+CdkListbox.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.0.0-rc.1", type: CdkListbox, selector: "[cdkListbox]", inputs: { id: "id", enabledTabIndex: ["tabindex", "enabledTabIndex"], value: ["cdkListboxValue", "value"], multiple: ["cdkListboxMultiple", "multiple"], disabled: ["cdkListboxDisabled", "disabled"], useActiveDescendant: ["cdkListboxUseActiveDescendant", "useActiveDescendant"], orientation: ["cdkListboxOrientation", "orientation"], compareWith: ["cdkListboxCompareWith", "compareWith"] }, outputs: { valueChange: "cdkListboxValueChange" }, host: { attributes: { "role": "listbox" }, listeners: { "focus": "_handleFocus()", "keydown": "_handleKeydown($event)", "focusout": "_handleFocusOut($event)" }, properties: { "id": "id", "attr.tabindex": "_getTabIndex()", "attr.aria-disabled": "disabled", "attr.aria-multiselectable": "multiple", "attr.aria-activedescendant": "_getAriaActiveDescendant()", "attr.aria-orientation": "orientation" }, classAttribute: "cdk-listbox" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => CdkListbox),
+            multi: true,
+        },
+        {
+            provide: NG_VALIDATORS,
+            useExisting: forwardRef(() => CdkListbox),
+            multi: true,
+        },
+    ], queries: [{ propertyName: "options", predicate: CdkOption, descendants: true }], exportAs: ["cdkListbox"], ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-rc.1", ngImport: i0, type: CdkListbox, decorators: [{
             type: Directive,
             args: [{
@@ -441,42 +678,56 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.0-rc.1", ng
                         'role': 'listbox',
                         'class': 'cdk-listbox',
                         '[id]': 'id',
-                        '(focus)': '_focusActiveOption()',
-                        '(keydown)': '_keydown($event)',
-                        '[attr.tabindex]': '_tabIndex',
+                        '[attr.tabindex]': '_getTabIndex()',
                         '[attr.aria-disabled]': 'disabled',
                         '[attr.aria-multiselectable]': 'multiple',
                         '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',
                         '[attr.aria-orientation]': 'orientation',
+                        '(focus)': '_handleFocus()',
+                        '(keydown)': '_handleKeydown($event)',
+                        '(focusout)': '_handleFocusOut($event)',
                     },
-                    providers: [CDK_LISTBOX_VALUE_ACCESSOR],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => CdkListbox),
+                            multi: true,
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => CdkListbox),
+                            multi: true,
+                        },
+                    ],
                 }]
-        }], ctorParameters: function () { return [{ type: i2.CdkCombobox, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [CDK_COMBOBOX]
-                }] }, { type: i1.Directionality, decorators: [{
-                    type: Optional
-                }] }]; }, propDecorators: { _options: [{
-                type: ContentChildren,
-                args: [CdkOption, { descendants: true }]
-            }], selectionChange: [{
-                type: Output
-            }], id: [{
+        }], ctorParameters: function () { return []; }, propDecorators: { id: [{
                 type: Input
+            }], enabledTabIndex: [{
+                type: Input,
+                args: ['tabindex']
+            }], value: [{
+                type: Input,
+                args: ['cdkListboxValue']
             }], multiple: [{
-                type: Input
+                type: Input,
+                args: ['cdkListboxMultiple']
             }], disabled: [{
-                type: Input
+                type: Input,
+                args: ['cdkListboxDisabled']
             }], useActiveDescendant: [{
-                type: Input
-            }], autoFocus: [{
-                type: Input
+                type: Input,
+                args: ['cdkListboxUseActiveDescendant']
             }], orientation: [{
                 type: Input,
-                args: ['listboxOrientation']
+                args: ['cdkListboxOrientation']
             }], compareWith: [{
-                type: Input
+                type: Input,
+                args: ['cdkListboxCompareWith']
+            }], valueChange: [{
+                type: Output,
+                args: ['cdkListboxValueChange']
+            }], options: [{
+                type: ContentChildren,
+                args: [CdkOption, { descendants: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listbox.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/listbox/listbox.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  AfterContentInit,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  QueryList,\n} from '@angular/core';\nimport {ActiveDescendantKeyManager, Highlightable, ListKeyManagerOption} from '@angular/cdk/a11y';\nimport {DOWN_ARROW, ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW} from '@angular/cdk/keycodes';\nimport {BooleanInput, coerceArray, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {SelectionChange, SelectionModel} from '@angular/cdk/collections';\nimport {defer, merge, Observable, Subject} from 'rxjs';\nimport {startWith, switchMap, takeUntil} from 'rxjs/operators';\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from '@angular/forms';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {CDK_COMBOBOX, CdkCombobox} from '@angular/cdk-experimental/combobox';\n\nlet nextId = 0;\nlet listboxId = 0;\n\nexport const CDK_LISTBOX_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => CdkListbox),\n  multi: true,\n};\n\n@Directive({\n  selector: '[cdkOption]',\n  exportAs: 'cdkOption',\n  host: {\n    'role': 'option',\n    'class': 'cdk-option',\n    '(click)': 'toggle()',\n    '(focus)': 'activate()',\n    '(blur)': 'deactivate()',\n    '[id]': 'id',\n    '[attr.aria-selected]': 'selected || null',\n    '[attr.tabindex]': '_getTabIndex()',\n    '[attr.aria-disabled]': '_isInteractionDisabled()',\n    '[class.cdk-option-disabled]': '_isInteractionDisabled()',\n    '[class.cdk-option-active]': '_active',\n    '[class.cdk-option-selected]': 'selected',\n  },\n})\nexport class CdkOption<T = unknown> implements ListKeyManagerOption, Highlightable {\n  private _selected: boolean = false;\n  private _disabled: boolean = false;\n  private _value: T;\n  _active: boolean = false;\n\n  /** The id of the option, set to a uniqueid if the user does not provide one. */\n  @Input() id = `cdk-option-${nextId++}`;\n\n  @Input()\n  get selected(): boolean {\n    return this._selected;\n  }\n  set selected(value: BooleanInput) {\n    if (!this._disabled) {\n      this._selected = coerceBooleanProperty(value);\n    }\n  }\n\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n\n  /** The form value of the option. */\n  @Input()\n  get value(): T {\n    return this._value;\n  }\n  set value(value: T) {\n    if (this.selected && value !== this._value) {\n      this.deselect();\n    }\n    this._value = value;\n  }\n\n  /**\n   * The text used to locate this item during menu typeahead. If not specified,\n   * the `textContent` of the item will be used.\n   */\n  @Input() typeahead: string;\n\n  @Output() readonly selectionChange = new EventEmitter<OptionSelectionChangeEvent<T>>();\n\n  constructor(\n    private readonly _elementRef: ElementRef,\n    @Inject(forwardRef(() => CdkListbox)) readonly listbox: CdkListbox<T>,\n  ) {}\n\n  /** Toggles the selected state, emits a change event through the injected listbox. */\n  toggle() {\n    if (!this._isInteractionDisabled()) {\n      this.selected = !this.selected;\n      this._emitSelectionChange(true);\n    }\n  }\n\n  /** Sets the active property true if the option and listbox aren't disabled. */\n  activate() {\n    if (!this._isInteractionDisabled()) {\n      this._active = true;\n    }\n  }\n\n  /** Sets the active property false. */\n  deactivate() {\n    if (!this._isInteractionDisabled()) {\n      this._active = false;\n    }\n  }\n\n  /** Sets the selected property true if it was false. */\n  select() {\n    if (!this.selected) {\n      this.selected = true;\n      this._emitSelectionChange();\n    }\n  }\n\n  /** Sets the selected property false if it was true. */\n  deselect() {\n    if (this.selected) {\n      this.selected = false;\n      this._emitSelectionChange();\n    }\n  }\n\n  /** Applies focus to the option. */\n  focus() {\n    this._elementRef.nativeElement.focus();\n  }\n\n  /** Returns true if the option or listbox are disabled, and false otherwise. */\n  _isInteractionDisabled(): boolean {\n    return this.listbox.disabled || this._disabled;\n  }\n\n  /** Emits a change event extending the Option Selection Change Event interface. */\n  private _emitSelectionChange(isUserInput = false) {\n    this.selectionChange.emit({\n      source: this,\n      isUserInput: isUserInput,\n    });\n  }\n\n  /** Returns the tab index which depends on the disabled property. */\n  _getTabIndex(): string | null {\n    return this._isInteractionDisabled() ? null : '-1';\n  }\n\n  /** Get the label for this element which is required by the FocusableOption interface. */\n  getLabel() {\n    return (this.typeahead ?? this._elementRef.nativeElement.textContent?.trim()) || '';\n  }\n\n  /** Sets the active property to true to enable the active css class. */\n  setActiveStyles() {\n    this._active = true;\n  }\n\n  /** Sets the active property to false to disable the active css class. */\n  setInactiveStyles() {\n    this._active = false;\n  }\n}\n\n@Directive({\n  selector: '[cdkListbox]',\n  exportAs: 'cdkListbox',\n  host: {\n    'role': 'listbox',\n    'class': 'cdk-listbox',\n    '[id]': 'id',\n    '(focus)': '_focusActiveOption()',\n    '(keydown)': '_keydown($event)',\n    '[attr.tabindex]': '_tabIndex',\n    '[attr.aria-disabled]': 'disabled',\n    '[attr.aria-multiselectable]': 'multiple',\n    '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',\n    '[attr.aria-orientation]': 'orientation',\n  },\n  providers: [CDK_LISTBOX_VALUE_ACCESSOR],\n})\nexport class CdkListbox<T> implements AfterContentInit, OnDestroy, OnInit, ControlValueAccessor {\n  _listKeyManager: ActiveDescendantKeyManager<CdkOption<T>>;\n  _selectionModel: SelectionModel<CdkOption<T>>;\n  _tabIndex = 0;\n\n  /** `View -> model callback called when select has been touched` */\n  _onTouched: () => void = () => {};\n\n  /** `View -> model callback called when value changes` */\n  _onChange: (value: T) => void = () => {};\n\n  readonly optionSelectionChanges: Observable<OptionSelectionChangeEvent<T>> = defer(() => {\n    const options = this._options;\n\n    return options.changes.pipe(\n      startWith(options),\n      switchMap(() => merge(...options.map(option => option.selectionChange))),\n    );\n  }) as Observable<OptionSelectionChangeEvent<T>>;\n\n  private _disabled: boolean = false;\n  private _multiple: boolean = false;\n  private _useActiveDescendant: boolean = false;\n  private _autoFocus: boolean = true;\n  private _activeOption: CdkOption<T>;\n  private readonly _destroyed = new Subject<void>();\n\n  @ContentChildren(CdkOption, {descendants: true}) _options: QueryList<CdkOption<T>>;\n\n  @Output() readonly selectionChange = new EventEmitter<ListboxSelectionChangeEvent<T>>();\n\n  @Input() id = `cdk-listbox-${listboxId++}`;\n\n  /**\n   * Whether the listbox allows multiple options to be selected.\n   * If `multiple` switches from `true` to `false`, all options are deselected.\n   */\n  @Input()\n  get multiple(): boolean {\n    return this._multiple;\n  }\n  set multiple(value: BooleanInput) {\n    const coercedValue = coerceBooleanProperty(value);\n    this._updateSelectionOnMultiSelectionChange(coercedValue);\n    this._multiple = coercedValue;\n  }\n\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n\n  /** Whether the listbox will use active descendant or will move focus onto the options. */\n  @Input()\n  get useActiveDescendant(): boolean {\n    return this._useActiveDescendant;\n  }\n  set useActiveDescendant(shouldUseActiveDescendant: BooleanInput) {\n    this._useActiveDescendant = coerceBooleanProperty(shouldUseActiveDescendant);\n  }\n\n  /** Whether on focus the listbox will focus its active option, default to true. */\n  @Input()\n  get autoFocus(): boolean {\n    return this._autoFocus;\n  }\n  set autoFocus(shouldAutoFocus: BooleanInput) {\n    this._autoFocus = coerceBooleanProperty(shouldAutoFocus);\n  }\n\n  /** Determines the orientation for the list key manager. Affects keyboard interaction. */\n  @Input('listboxOrientation') orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  @Input() compareWith: (o1: T, o2: T) => boolean = (a1, a2) => a1 === a2;\n\n  constructor(\n    @Optional() @Inject(CDK_COMBOBOX) private readonly _combobox: CdkCombobox,\n    @Optional() private readonly _dir?: Directionality,\n  ) {}\n\n  ngOnInit() {\n    this._selectionModel = new SelectionModel<CdkOption<T>>(this.multiple);\n  }\n\n  ngAfterContentInit() {\n    this._initKeyManager();\n    this._initSelectionModel();\n    this._combobox?._registerContent(this.id, 'listbox');\n\n    this.optionSelectionChanges.subscribe(event => {\n      this._emitChangeEvent(event.source);\n      this._updateSelectionModel(event.source);\n      this.setActiveOption(event.source);\n      this._updatePanelForSelection(event.source);\n    });\n  }\n\n  ngOnDestroy() {\n    this._listKeyManager.change.complete();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  private _initKeyManager() {\n    this._listKeyManager = new ActiveDescendantKeyManager(this._options)\n      .withWrap()\n      .withTypeAhead()\n      .withHomeAndEnd()\n      .withAllowedModifierKeys(['shiftKey']);\n\n    if (this.orientation === 'vertical') {\n      this._listKeyManager.withVerticalOrientation();\n    } else {\n      this._listKeyManager.withHorizontalOrientation(this._dir?.value || 'ltr');\n    }\n\n    this._listKeyManager.change.pipe(takeUntil(this._destroyed)).subscribe(() => {\n      this._updateActiveOption();\n    });\n  }\n\n  private _initSelectionModel() {\n    this._selectionModel.changed\n      .pipe(takeUntil(this._destroyed))\n      .subscribe((event: SelectionChange<CdkOption<T>>) => {\n        for (const option of event.added) {\n          option.selected = true;\n        }\n\n        for (const option of event.removed) {\n          option.selected = false;\n        }\n      });\n  }\n\n  _keydown(event: KeyboardEvent) {\n    if (this._disabled) {\n      return;\n    }\n\n    const manager = this._listKeyManager;\n    const {keyCode} = event;\n    const previousActiveIndex = manager.activeItemIndex;\n\n    if (keyCode === SPACE || keyCode === ENTER) {\n      if (manager.activeItem && !manager.isTyping()) {\n        this._toggleActiveOption();\n      }\n      event.preventDefault();\n    } else {\n      manager.onKeydown(event);\n    }\n\n    /** Will select an option if shift was pressed while navigating to the option */\n    const isArrow =\n      keyCode === UP_ARROW ||\n      keyCode === DOWN_ARROW ||\n      keyCode === LEFT_ARROW ||\n      keyCode === RIGHT_ARROW;\n    if (isArrow && event.shiftKey && previousActiveIndex !== this._listKeyManager.activeItemIndex) {\n      this._toggleActiveOption();\n    }\n  }\n\n  /** Emits a selection change event, called when an option has its selected state changed. */\n  _emitChangeEvent(option: CdkOption<T>) {\n    this.selectionChange.emit({\n      source: this,\n      option: option,\n    });\n  }\n\n  /** Updates the selection model after a toggle. */\n  _updateSelectionModel(option: CdkOption<T>) {\n    if (!this.multiple && this._selectionModel.selected.length !== 0) {\n      const previouslySelected = this._selectionModel.selected[0];\n      this.deselect(previouslySelected);\n    }\n\n    option.selected ? this._selectionModel.select(option) : this._selectionModel.deselect(option);\n  }\n\n  _updatePanelForSelection(option: CdkOption<T>) {\n    if (this._combobox) {\n      if (!this.multiple) {\n        this._combobox.updateAndClose(option.selected ? option.value : []);\n      } else {\n        this._combobox.updateAndClose(this.getSelectedValues());\n      }\n    }\n  }\n\n  /** Toggles the selected state of the active option if not disabled. */\n  private _toggleActiveOption() {\n    const activeOption = this._listKeyManager.activeItem;\n    if (activeOption && !activeOption.disabled) {\n      activeOption.toggle();\n    }\n  }\n\n  /** Returns the id of the active option if active descendant is being used. */\n  _getAriaActiveDescendant(): string | null | undefined {\n    return this._useActiveDescendant ? this._listKeyManager?.activeItem?.id : null;\n  }\n\n  /** Updates the activeOption and the active and focus properties of the option. */\n  private _updateActiveOption() {\n    if (!this._listKeyManager.activeItem) {\n      return;\n    }\n\n    this._activeOption?.deactivate();\n    this._activeOption = this._listKeyManager.activeItem;\n    this._activeOption.activate();\n\n    if (!this.useActiveDescendant) {\n      this._activeOption.focus();\n    }\n  }\n\n  /** Updates selection states of options when the 'multiple' property changes. */\n  private _updateSelectionOnMultiSelectionChange(value: boolean) {\n    if (this.multiple && !value) {\n      // Deselect all options instead of arbitrarily keeping one of the selected options.\n      this.setAllSelected(false);\n    } else if (!this.multiple && value) {\n      this._selectionModel = new SelectionModel<CdkOption<T>>(\n        value,\n        this._selectionModel?.selected,\n      );\n    }\n  }\n\n  _focusActiveOption() {\n    if (!this.autoFocus) {\n      return;\n    }\n\n    if (this._listKeyManager.activeItem) {\n      this.setActiveOption(this._listKeyManager.activeItem);\n    } else if (this._options.first) {\n      this.setActiveOption(this._options.first);\n    }\n  }\n\n  /** Selects the given option if the option and listbox aren't disabled. */\n  select(option: CdkOption<T>) {\n    if (!this.disabled && !option.disabled) {\n      option.select();\n    }\n  }\n\n  /** Deselects the given option if the option and listbox aren't disabled. */\n  deselect(option: CdkOption<T>) {\n    if (!this.disabled && !option.disabled) {\n      option.deselect();\n    }\n  }\n\n  /** Sets the selected state of all options to be the given value. */\n  setAllSelected(isSelected: boolean) {\n    for (const option of this._options.toArray()) {\n      isSelected ? this.select(option) : this.deselect(option);\n    }\n  }\n\n  /** Updates the key manager's active item to the given option. */\n  setActiveOption(option: CdkOption<T>) {\n    this._listKeyManager.updateActiveItem(option);\n    this._updateActiveOption();\n  }\n\n  /**\n   * Saves a callback function to be invoked when the select's value\n   * changes from user input. Required to implement ControlValueAccessor.\n   */\n  registerOnChange(fn: (value: T) => void): void {\n    this._onChange = fn;\n  }\n\n  /**\n   * Saves a callback function to be invoked when the select is blurred\n   * by the user. Required to implement ControlValueAccessor.\n   */\n  registerOnTouched(fn: () => {}): void {\n    this._onTouched = fn;\n  }\n\n  /** Sets the select's value. Required to implement ControlValueAccessor. */\n  writeValue(values: T | T[]): void {\n    if (this._options) {\n      this._setSelectionByValue(values);\n    }\n  }\n\n  /** Disables the select. Required to implement ControlValueAccessor. */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /** Returns the values of the currently selected options. */\n  getSelectedValues(): T[] {\n    return this._options.filter(option => option.selected).map(option => option.value);\n  }\n\n  /** Selects an option that has the corresponding given value. */\n  private _setSelectionByValue(values: T | T[]) {\n    for (const option of this._options.toArray()) {\n      this.deselect(option);\n    }\n\n    const valuesArray = coerceArray(values);\n    for (const value of valuesArray) {\n      const correspondingOption = this._options.find((option: CdkOption<T>) => {\n        return option.value != null && this.compareWith(option.value, value);\n      });\n\n      if (correspondingOption) {\n        this.select(correspondingOption);\n        if (!this.multiple) {\n          return;\n        }\n      }\n    }\n  }\n}\n\n/** Change event that is being fired whenever the selected state of an option changes. */\nexport interface ListboxSelectionChangeEvent<T> {\n  /** Reference to the listbox that emitted the event. */\n  readonly source: CdkListbox<T>;\n\n  /** Reference to the option that has been changed. */\n  readonly option: CdkOption<T>;\n}\n\n/** Event object emitted by MatOption when selected or deselected. */\nexport interface OptionSelectionChangeEvent<T> {\n  /** Reference to the option that emitted the event. */\n  source: CdkOption<T>;\n\n  /** Whether the change in the option's value was a result of a user action. */\n  isUserInput: boolean;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listbox.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/listbox/listbox.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  AfterContentInit,\n  ChangeDetectorRef,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  forwardRef,\n  inject,\n  InjectFlags,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n} from '@angular/core';\nimport {ActiveDescendantKeyManager, Highlightable, ListKeyManagerOption} from '@angular/cdk/a11y';\nimport {DOWN_ARROW, ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE, UP_ARROW} from '@angular/cdk/keycodes';\nimport {BooleanInput, coerceArray, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {SelectionModel} from '@angular/cdk/collections';\nimport {BehaviorSubject, combineLatest, defer, merge, Observable, Subject} from 'rxjs';\nimport {filter, mapTo, startWith, switchMap, take, takeUntil} from 'rxjs/operators';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator,\n  ValidatorFn,\n  Validators,\n} from '@angular/forms';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {CdkCombobox} from '@angular/cdk-experimental/combobox';\n\n/** The next id to use for creating unique DOM IDs. */\nlet nextId = 0;\n\n// TODO(mmalerba):\n//   - should listbox wrap be configurable?\n//   - should skipping disabled options be configurable?\n\n/** A selectable option in a listbox. */\n@Directive({\n  selector: '[cdkOption]',\n  exportAs: 'cdkOption',\n  host: {\n    'role': 'option',\n    'class': 'cdk-option',\n    '[id]': 'id',\n    '[attr.aria-selected]': 'isSelected() || null',\n    '[attr.tabindex]': '_getTabIndex()',\n    '[attr.aria-disabled]': 'disabled',\n    '[class.cdk-option-disabled]': 'disabled',\n    '[class.cdk-option-active]': 'isActive()',\n    '[class.cdk-option-selected]': 'isSelected()',\n    '(click)': '_clicked.next()',\n    '(focus)': '_handleFocus()',\n  },\n})\nexport class CdkOption<T = unknown> implements ListKeyManagerOption, Highlightable, OnDestroy {\n  /** The id of the option's host element. */\n  @Input()\n  get id() {\n    return this._id || this._generatedId;\n  }\n  set id(value) {\n    this._id = value;\n  }\n  private _id: string;\n  private _generatedId = `cdk-option-${nextId++}`;\n\n  /** The value of this option. */\n  @Input('cdkOption') value: T;\n\n  /**\n   * The text used to locate this item during listbox typeahead. If not specified,\n   * the `textContent` of the item will be used.\n   */\n  @Input('cdkOptionTypeaheadLabel') typeaheadLabel: string;\n\n  /** Whether this option is disabled. */\n  @Input('cdkOptionDisabled')\n  get disabled(): boolean {\n    return this.listbox.disabled || this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled: boolean = false;\n\n  /** The tabindex of the option when it is enabled. */\n  @Input('tabindex')\n  get enabledTabIndex() {\n    return this._enabledTabIndex === undefined\n      ? this.listbox.enabledTabIndex\n      : this._enabledTabIndex;\n  }\n  set enabledTabIndex(value) {\n    this._enabledTabIndex = value;\n  }\n  private _enabledTabIndex?: number | null;\n\n  /** The option's host element */\n  readonly element: HTMLElement = inject(ElementRef).nativeElement;\n\n  /** The parent listbox this option belongs to. */\n  protected readonly listbox: CdkListbox<T> = inject(CdkListbox);\n\n  /** Emits when the option is destroyed. */\n  protected destroyed = new Subject<void>();\n\n  /** Emits when the option is clicked. */\n  readonly _clicked = new Subject<void>();\n\n  /** Whether the option is currently active. */\n  private _active = false;\n\n  ngOnDestroy() {\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  /** Whether this option is selected. */\n  isSelected() {\n    return this.listbox.isSelected(this.value);\n  }\n\n  /** Whether this option is active. */\n  isActive() {\n    return this._active;\n  }\n\n  /** Toggle the selected state of this option. */\n  toggle() {\n    this.listbox.toggle(this);\n  }\n\n  /** Select this option if it is not selected. */\n  select() {\n    this.listbox.select(this);\n  }\n\n  /** Deselect this option if it is selected. */\n  deselect() {\n    this.listbox.deselect(this);\n  }\n\n  /** Focus this option. */\n  focus() {\n    this.element.focus();\n  }\n\n  /** Get the label for this element which is required by the FocusableOption interface. */\n  getLabel() {\n    return (this.typeaheadLabel ?? this.element.textContent?.trim()) || '';\n  }\n\n  /**\n   * Set the option as active.\n   * @docs-private\n   */\n  setActiveStyles() {\n    this._active = true;\n  }\n\n  /**\n   * Set the option as inactive.\n   * @docs-private\n   */\n  setInactiveStyles() {\n    this._active = false;\n  }\n\n  /** Handle focus events on the option. */\n  protected _handleFocus() {\n    // Options can wind up getting focused in active descendant mode if the user clicks on them.\n    // In this case, we push focus back to the parent listbox to prevent an extra tab stop when\n    // the user performs a shift+tab.\n    if (this.listbox.useActiveDescendant) {\n      this.listbox._setActiveOption(this);\n      this.listbox.focus();\n    }\n  }\n\n  /** Get the tabindex for this option. */\n  protected _getTabIndex() {\n    if (this.listbox.useActiveDescendant || this.disabled) {\n      return -1;\n    }\n    return this.isActive() ? this.enabledTabIndex : -1;\n  }\n}\n\n@Directive({\n  selector: '[cdkListbox]',\n  exportAs: 'cdkListbox',\n  host: {\n    'role': 'listbox',\n    'class': 'cdk-listbox',\n    '[id]': 'id',\n    '[attr.tabindex]': '_getTabIndex()',\n    '[attr.aria-disabled]': 'disabled',\n    '[attr.aria-multiselectable]': 'multiple',\n    '[attr.aria-activedescendant]': '_getAriaActiveDescendant()',\n    '[attr.aria-orientation]': 'orientation',\n    '(focus)': '_handleFocus()',\n    '(keydown)': '_handleKeydown($event)',\n    '(focusout)': '_handleFocusOut($event)',\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => CdkListbox),\n      multi: true,\n    },\n    {\n      provide: NG_VALIDATORS,\n      useExisting: forwardRef(() => CdkListbox),\n      multi: true,\n    },\n  ],\n})\nexport class CdkListbox<T = unknown>\n  implements AfterContentInit, OnDestroy, ControlValueAccessor, Validator\n{\n  /** The id of the option's host element. */\n  @Input()\n  get id() {\n    return this._id || this._generatedId;\n  }\n  set id(value) {\n    this._id = value;\n  }\n  private _id: string;\n  private _generatedId = `cdk-listbox-${nextId++}`;\n\n  /** The tabindex to use when the listbox is enabled. */\n  @Input('tabindex')\n  get enabledTabIndex() {\n    return this._enabledTabIndex === undefined ? 0 : this._enabledTabIndex;\n  }\n  set enabledTabIndex(value) {\n    this._enabledTabIndex = value;\n  }\n  private _enabledTabIndex?: number | null;\n\n  /** The value selected in the listbox, represented as an array of option values. */\n  @Input('cdkListboxValue')\n  get value(): readonly T[] {\n    return this.selectionModel().selected;\n  }\n  set value(value: readonly T[]) {\n    this._setSelection(value);\n  }\n\n  /**\n   * Whether the listbox allows multiple options to be selected. If the value switches from `true`\n   * to `false`, and more than one option is selected, all options are deselected.\n   */\n  @Input('cdkListboxMultiple')\n  get multiple(): boolean {\n    return this._multiple;\n  }\n  set multiple(value: BooleanInput) {\n    this._multiple = coerceBooleanProperty(value);\n    this._updateSelectionModel();\n    this._onValidatorChange();\n  }\n  private _multiple: boolean = false;\n\n  /** Whether the listbox is disabled. */\n  @Input('cdkListboxDisabled')\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled: boolean = false;\n\n  /** Whether the listbox will use active descendant or will move focus onto the options. */\n  @Input('cdkListboxUseActiveDescendant')\n  get useActiveDescendant(): boolean {\n    return this._useActiveDescendant;\n  }\n  set useActiveDescendant(shouldUseActiveDescendant: BooleanInput) {\n    this._useActiveDescendant = coerceBooleanProperty(shouldUseActiveDescendant);\n  }\n  private _useActiveDescendant: boolean = false;\n\n  /** The orientation of the listbox. Only affects keyboard interaction, not visual layout. */\n  @Input('cdkListboxOrientation') orientation: 'horizontal' | 'vertical' = 'vertical';\n\n  /** The function used to compare option values. */\n  @Input('cdkListboxCompareWith')\n  get compareWith(): undefined | ((o1: T, o2: T) => boolean) {\n    return this._compareWith;\n  }\n  set compareWith(fn: undefined | ((o1: T, o2: T) => boolean)) {\n    this._compareWith = fn;\n    this._updateSelectionModel();\n  }\n  private _compareWith?: (o1: T, o2: T) => boolean;\n\n  /** Emits when the selected value(s) in the listbox change. */\n  @Output('cdkListboxValueChange') readonly valueChange = new Subject<ListboxValueChangeEvent<T>>();\n\n  /** The child options in this listbox. */\n  @ContentChildren(CdkOption, {descendants: true}) protected options: QueryList<CdkOption<T>>;\n\n  // TODO(mmalerba): Refactor SelectionModel so that its not necessary to create new instances\n  /** The selection model used by the listbox. */\n  protected selectionModelSubject = new BehaviorSubject(\n    new SelectionModel<T>(this.multiple, [], true, this._compareWith),\n  );\n\n  /** The key manager that manages keyboard navigation for this listbox. */\n  protected listKeyManager: ActiveDescendantKeyManager<CdkOption<T>>;\n\n  /** Emits when the listbox is destroyed. */\n  protected readonly destroyed = new Subject<void>();\n\n  /** The host element of the listbox. */\n  protected readonly element: HTMLElement = inject(ElementRef).nativeElement;\n\n  /** The change detector for this listbox. */\n  protected readonly changeDetectorRef = inject(ChangeDetectorRef);\n\n  /** Callback called when the listbox has been touched */\n  private _onTouched = () => {};\n\n  /** Callback called when the listbox value changes */\n  private _onChange: (value: readonly T[]) => void = () => {};\n\n  /** Callback called when the form validator changes. */\n  private _onValidatorChange = () => {};\n\n  /** Emits when an option has been clicked. */\n  private _optionClicked = defer(() =>\n    (this.options.changes as Observable<CdkOption<T>[]>).pipe(\n      startWith(this.options),\n      switchMap(options => merge(...options.map(option => option._clicked.pipe(mapTo(option))))),\n    ),\n  );\n\n  /** The directionality of the page. */\n  private readonly _dir = inject(Directionality, InjectFlags.Optional);\n\n  // TODO(mmalerba): Should not depend on combobox\n  private readonly _combobox = inject(CdkCombobox, InjectFlags.Optional);\n\n  /**\n   * Validator that produces an error if multiple values are selected in a single selection\n   * listbox.\n   * @param control The control to validate\n   * @return A validation error or null\n   */\n  private _validateMultipleValues: ValidatorFn = (control: AbstractControl) => {\n    const controlValue = this._coerceValue(control.value);\n    if (!this.multiple && controlValue.length > 1) {\n      return {'cdkListboxMultipleValues': true};\n    }\n    return null;\n  };\n\n  /**\n   * Validator that produces an error if any selected values are not valid options for this listbox.\n   * @param control The control to validate\n   * @return A validation error or null\n   */\n  private _validateInvalidValues: ValidatorFn = (control: AbstractControl) => {\n    const controlValue = this._coerceValue(control.value);\n    const invalidValues = this._getValuesWithValidity(controlValue, false);\n    if (invalidValues.length) {\n      return {'cdkListboxInvalidValues': {'values': invalidValues}};\n    }\n    return null;\n  };\n\n  /** The combined set of validators for this listbox. */\n  private _validators = Validators.compose([\n    this._validateMultipleValues,\n    this._validateInvalidValues,\n  ])!;\n\n  constructor() {\n    this.selectionModelSubject\n      .pipe(\n        switchMap(selectionModel => selectionModel.changed),\n        takeUntil(this.destroyed),\n      )\n      .subscribe(() => {\n        this._updateInternalValue();\n      });\n  }\n\n  ngAfterContentInit() {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      this._verifyNoOptionValueCollisions();\n    }\n    this._initKeyManager();\n    this._combobox?._registerContent(this.id, 'listbox');\n    this.options.changes.pipe(takeUntil(this.destroyed)).subscribe(() => {\n      this._updateInternalValue();\n      this._onValidatorChange();\n    });\n    this._optionClicked\n      .pipe(\n        filter(option => !option.disabled),\n        takeUntil(this.destroyed),\n      )\n      .subscribe(option => this._handleOptionClicked(option));\n  }\n\n  ngOnDestroy() {\n    this.listKeyManager.change.complete();\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  /**\n   * Toggle the selected state of the given option.\n   * @param option The option to toggle\n   */\n  toggle(option: CdkOption<T>) {\n    this.toggleValue(option.value);\n  }\n\n  /**\n   * Toggle the selected state of the given value.\n   * @param value The value to toggle\n   */\n  toggleValue(value: T) {\n    this.selectionModel().toggle(value);\n  }\n\n  /**\n   * Select the given option.\n   * @param option The option to select\n   */\n  select(option: CdkOption<T>) {\n    this.selectValue(option.value);\n  }\n\n  /**\n   * Select the given value.\n   * @param value The value to select\n   */\n  selectValue(value: T) {\n    this.selectionModel().select(value);\n  }\n\n  /**\n   * Deselect the given option.\n   * @param option The option to deselect\n   */\n  deselect(option: CdkOption<T>) {\n    this.deselectValue(option.value);\n  }\n\n  /**\n   * Deselect the given value.\n   * @param value The value to deselect\n   */\n  deselectValue(value: T) {\n    this.selectionModel().deselect(value);\n  }\n\n  /**\n   * Set the selected state of all options.\n   * @param isSelected The new selected state to set\n   */\n  setAllSelected(isSelected: boolean) {\n    if (!isSelected) {\n      this.selectionModel().clear();\n    } else {\n      this.selectionModel().select(...this.options.toArray().map(option => option.value));\n    }\n  }\n\n  /**\n   * Get whether the given option is selected.\n   * @param option The option to get the selected state of\n   */\n  isSelected(option: CdkOption<T> | T) {\n    return this.selectionModel().isSelected(option instanceof CdkOption ? option.value : option);\n  }\n\n  /**\n   * Registers a callback to be invoked when the listbox's value changes from user input.\n   * @param fn The callback to register\n   * @docs-private\n   */\n  registerOnChange(fn: (value: readonly T[]) => void): void {\n    this._onChange = fn;\n  }\n\n  /**\n   * Registers a callback to be invoked when the listbox is blurred by the user.\n   * @param fn The callback to register\n   * @docs-private\n   */\n  registerOnTouched(fn: () => {}): void {\n    this._onTouched = fn;\n  }\n\n  /**\n   * Sets the listbox's value.\n   * @param value The new value of the listbox\n   * @docs-private\n   */\n  writeValue(value: readonly T[]): void {\n    this._setSelection(value);\n  }\n\n  /**\n   * Sets the disabled state of the listbox.\n   * @param isDisabled The new disabled state\n   * @docs-private\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /**\n   * Validate the given control\n   * @docs-private\n   */\n  validate(control: AbstractControl<any, any>): ValidationErrors | null {\n    return this._validators(control);\n  }\n\n  /**\n   * Registers a callback to be called when the form validator changes.\n   * @param fn The callback to call\n   * @docs-private\n   */\n  registerOnValidatorChange(fn: () => void) {\n    this._onValidatorChange = fn;\n  }\n\n  /** Focus the listbox's host element. */\n  focus() {\n    this.element.focus();\n  }\n\n  /** The selection model used to track the listbox's value. */\n  protected selectionModel() {\n    return this.selectionModelSubject.value;\n  }\n\n  /**\n   * Triggers the given option in response to user interaction.\n   * - In single selection mode: selects the option and deselects any other selected option.\n   * - In multi selection mode: toggles the selected state of the option.\n   * @param option The option to trigger\n   */\n  protected triggerOption(option: CdkOption<T> | null) {\n    if (option && !option.disabled) {\n      let changed = false;\n      this.selectionModel()\n        .changed.pipe(take(1), takeUntil(this.destroyed))\n        .subscribe(() => (changed = true));\n      if (this.multiple) {\n        this.toggle(option);\n      } else {\n        this.select(option);\n      }\n      if (changed) {\n        this._onChange(this.value);\n        this.valueChange.next({\n          value: this.value,\n          listbox: this,\n          option: option,\n        });\n      }\n    }\n  }\n\n  /**\n   * Sets the given option as active.\n   * @param option The option to make active\n   */\n  _setActiveOption(option: CdkOption<T>) {\n    this.listKeyManager.setActiveItem(option);\n  }\n\n  /** Called when the listbox receives focus. */\n  protected _handleFocus() {\n    if (!this.useActiveDescendant) {\n      this.listKeyManager.setNextItemActive();\n      this._focusActiveOption();\n    }\n  }\n\n  /** Called when the user presses keydown on the listbox. */\n  protected _handleKeydown(event: KeyboardEvent) {\n    if (this._disabled) {\n      return;\n    }\n\n    const {keyCode} = event;\n    const previousActiveIndex = this.listKeyManager.activeItemIndex;\n\n    if (keyCode === SPACE || keyCode === ENTER) {\n      this.triggerOption(this.listKeyManager.activeItem);\n      event.preventDefault();\n    } else {\n      this.listKeyManager.onKeydown(event);\n    }\n\n    /** Will select an option if shift was pressed while navigating to the option */\n    const isArrow =\n      keyCode === UP_ARROW ||\n      keyCode === DOWN_ARROW ||\n      keyCode === LEFT_ARROW ||\n      keyCode === RIGHT_ARROW;\n    if (isArrow && event.shiftKey && previousActiveIndex !== this.listKeyManager.activeItemIndex) {\n      this.triggerOption(this.listKeyManager.activeItem);\n    }\n  }\n\n  /**\n   * Called when the focus leaves an element in the listbox.\n   * @param event The focusout event\n   */\n  protected _handleFocusOut(event: FocusEvent) {\n    const otherElement = event.relatedTarget as Element;\n    if (this.element !== otherElement && !this.element.contains(otherElement)) {\n      this._onTouched();\n    }\n  }\n\n  /** Get the id of the active option if active descendant is being used. */\n  protected _getAriaActiveDescendant(): string | null | undefined {\n    return this._useActiveDescendant ? this.listKeyManager?.activeItem?.id : null;\n  }\n\n  /** Get the tabindex for the listbox. */\n  protected _getTabIndex() {\n    if (this.disabled) {\n      return -1;\n    }\n    return this.useActiveDescendant || !this.listKeyManager.activeItem ? this.enabledTabIndex : -1;\n  }\n\n  /** Initialize the key manager. */\n  private _initKeyManager() {\n    this.listKeyManager = new ActiveDescendantKeyManager(this.options)\n      .withWrap()\n      .withTypeAhead()\n      .withHomeAndEnd()\n      .withAllowedModifierKeys(['shiftKey']);\n\n    if (this.orientation === 'vertical') {\n      this.listKeyManager.withVerticalOrientation();\n    } else {\n      this.listKeyManager.withHorizontalOrientation(this._dir?.value || 'ltr');\n    }\n\n    this.listKeyManager.change\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(() => this._focusActiveOption());\n  }\n\n  // TODO(mmalerba): Should not depend on combobox.\n  private _updatePanelForSelection(option: CdkOption<T>) {\n    if (this._combobox) {\n      if (!this.multiple) {\n        this._combobox.updateAndClose(option.isSelected() ? option.value : []);\n      } else {\n        this._combobox.updateAndClose(this.value);\n      }\n    }\n  }\n\n  /** Update the selection mode when the 'multiple' property changes. */\n  private _updateSelectionModel() {\n    this.selectionModelSubject.next(\n      new SelectionModel(\n        this.multiple,\n        !this.multiple && this.value.length > 1 ? [] : this.value.slice(),\n        true,\n        this._compareWith,\n      ),\n    );\n  }\n\n  /** Focus the active option. */\n  private _focusActiveOption() {\n    if (!this.useActiveDescendant) {\n      this.listKeyManager.activeItem?.focus();\n    }\n    this.changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Set the selected values.\n   * @param value The list of new selected values.\n   */\n  private _setSelection(value: readonly T[]) {\n    const coercedValue = this._coerceValue(value);\n    this.selectionModel().setSelection(\n      ...(!this.multiple && coercedValue.length > 1\n        ? []\n        : this._getValuesWithValidity(coercedValue, true)),\n    );\n  }\n\n  /** Update the internal value of the listbox based on the selection model. */\n  private _updateInternalValue() {\n    const indexCache = new Map<T, number>();\n    // Check if we need to remove any values due to them becoming invalid\n    // (e.g. if the option was removed from the DOM.)\n    const selected = this.selectionModel().selected;\n    const validSelected = this._getValuesWithValidity(selected, true);\n    if (validSelected.length != selected.length) {\n      this.selectionModel().setSelection(...validSelected);\n    }\n    this.selectionModel().sort((a: T, b: T) => {\n      const aIndex = this._getIndexForValue(indexCache, a);\n      const bIndex = this._getIndexForValue(indexCache, b);\n      return aIndex - bIndex;\n    });\n    this.changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Gets the index of the given value in the given list of options.\n   * @param cache The cache of indices found so far\n   * @param value The value to find\n   * @return The index of the value in the options list\n   */\n  private _getIndexForValue(cache: Map<T, number>, value: T) {\n    const isEqual = this.compareWith || Object.is;\n    if (!cache.has(value)) {\n      let index = -1;\n      for (let i = 0; i < this.options.length; i++) {\n        if (isEqual(value, this.options.get(i)!.value)) {\n          index = i;\n          break;\n        }\n      }\n      cache.set(value, index);\n    }\n    return cache.get(value)!;\n  }\n\n  /**\n   * Handle the user clicking an option.\n   * @param option The option that was clicked.\n   */\n  private _handleOptionClicked(option: CdkOption<T>) {\n    this.listKeyManager.setActiveItem(option);\n    this.triggerOption(option);\n    this._updatePanelForSelection(option);\n  }\n\n  /** Verifies that no two options represent the same value under the compareWith function. */\n  private _verifyNoOptionValueCollisions() {\n    combineLatest([\n      this.selectionModelSubject,\n      this.options.changes.pipe(startWith(this.options)),\n    ]).subscribe(() => {\n      const isEqual = this.compareWith ?? Object.is;\n      for (let i = 0; i < this.options.length; i++) {\n        const option = this.options.get(i)!;\n        let duplicate: CdkOption<T> | null = null;\n        for (let j = i + 1; j < this.options.length; j++) {\n          const other = this.options.get(j)!;\n          if (isEqual(option.value, other.value)) {\n            duplicate = other;\n            break;\n          }\n        }\n        if (duplicate) {\n          // TODO(mmalerba): Link to docs about this.\n          if (this.compareWith) {\n            console.warn(\n              `Found multiple CdkOption representing the same value under the given compareWith function`,\n              {\n                option1: option.element,\n                option2: duplicate.element,\n                compareWith: this.compareWith,\n              },\n            );\n          } else {\n            console.warn(`Found multiple CdkOption with the same value`, {\n              option1: option.element,\n              option2: duplicate.element,\n            });\n          }\n          return;\n        }\n      }\n    });\n  }\n\n  /**\n   * Coerces a value into an array representing a listbox selection.\n   * @param value The value to coerce\n   * @return An array\n   */\n  private _coerceValue(value: readonly T[]) {\n    return value == null ? [] : coerceArray(value);\n  }\n\n  /**\n   * Get the sublist of values with the given validity.\n   * @param values The list of values\n   * @param valid Whether to get valid values\n   * @return The sublist of values with the requested validity\n   */\n  private _getValuesWithValidity(values: readonly T[], valid: boolean) {\n    const isEqual = this.compareWith || Object.is;\n    const validValues = (this.options || []).map(option => option.value);\n    return values.filter(\n      value => valid === validValues.some(validValue => isEqual(value, validValue)),\n    );\n  }\n}\n\n/** Change event that is fired whenever the value of the listbox changes. */\nexport interface ListboxValueChangeEvent<T> {\n  /** The new value of the listbox. */\n  readonly value: readonly T[];\n\n  /** Reference to the listbox that emitted the event. */\n  readonly listbox: CdkListbox<T>;\n\n  /** Reference to the option that was triggered. */\n  readonly option: CdkOption<T>;\n}\n"]}