@angular/cdk 18.2.0-next.0 → 18.2.0-next.2

package/esm2022/a11y/key-manager/noop-tree-key-manager.mjs

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { Subject } from 'rxjs';
+import { TREE_KEY_MANAGER } from './tree-key-manager';
+// NoopTreeKeyManager is a "noop" implementation of TreeKeyMangerStrategy. Methods are noops. Does
+// not emit to streams.
+//
+// Used for applications built before TreeKeyManager to opt-out of TreeKeyManager and revert to
+// legacy behavior.
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+export class NoopTreeKeyManager {
+    constructor() {
+        this._isNoopTreeKeyManager = true;
+        // Provide change as required by TreeKeyManagerStrategy. NoopTreeKeyManager is a "noop"
+        // implementation that does not emit to streams.
+        this.change = new Subject();
+    }
+    destroy() {
+        this.change.complete();
+    }
+    onKeydown() {
+        // noop
+    }
+    getActiveItemIndex() {
+        // Always return null. NoopTreeKeyManager is a "noop" implementation that does not maintain
+        // the active item.
+        return null;
+    }
+    getActiveItem() {
+        // Always return null. NoopTreeKeyManager is a "noop" implementation that does not maintain
+        // the active item.
+        return null;
+    }
+    focusItem() {
+        // noop
+    }
+}
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+export function NOOP_TREE_KEY_MANAGER_FACTORY() {
+    return () => new NoopTreeKeyManager();
+}
+/**
+ * @docs-private
+ *
+ * Opt-out of Tree of key manager behavior.
+ *
+ * When provided, Tree has same focus management behavior as before TreeKeyManager was introduced.
+ *  - Tree does not respond to keyboard interaction
+ *  - Tree node allows tabindex to be set by Input binding
+ *  - Tree node allows tabindex to be set by attribute binding
+ *
+ * @deprecated NoopTreeKeyManager deprecated. Use TreeKeyManager or inject a
+ * TreeKeyManagerStrategy instead. To be removed in a future version.
+ *
+ * @breaking-change 21.0.0
+ */
+export const NOOP_TREE_KEY_MANAGER_FACTORY_PROVIDER = {
+    provide: TREE_KEY_MANAGER,
+    useFactory: NOOP_TREE_KEY_MANAGER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/a11y/key-manager/tree-key-manager-strategy.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/a11y/key-manager/tree-key-manager.mjs

@@ -0,0 +1,345 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { InjectionToken, QueryList } from '@angular/core';
+import { coerceObservable } from '@angular/cdk/coercion/private';
+import { Subject, Subscription, isObservable, of as observableOf } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { Typeahead } from './typeahead';
+/**
+ * This class manages keyboard events for trees. If you pass it a QueryList or other list of tree
+ * items, it will set the active item, focus, handle expansion and typeahead correctly when
+ * keyboard events occur.
+ */
+export class TreeKeyManager {
+    _initialFocus() {
+        if (this._hasInitialFocused) {
+            return;
+        }
+        if (!this._items.length) {
+            return;
+        }
+        let focusIndex = 0;
+        for (let i = 0; i < this._items.length; i++) {
+            if (!this._skipPredicateFn(this._items[i]) && !this._isItemDisabled(this._items[i])) {
+                focusIndex = i;
+                break;
+            }
+        }
+        this.focusItem(focusIndex);
+        this._hasInitialFocused = true;
+    }
+    /**
+     *
+     * @param items List of TreeKeyManager options. Can be synchronous or asynchronous.
+     * @param config Optional configuration options. By default, use 'ltr' horizontal orientation. By
+     * default, do not skip any nodes. By default, key manager only calls `focus` method when items
+     * are focused and does not call `activate`. If `typeaheadDefaultInterval` is `true`, use a
+     * default interval of 200ms.
+     */
+    constructor(items, config) {
+        /** The index of the currently active (focused) item. */
+        this._activeItemIndex = -1;
+        /** The currently active (focused) item. */
+        this._activeItem = null;
+        /** Whether or not we activate the item when it's focused. */
+        this._shouldActivationFollowFocus = false;
+        /**
+         * The orientation that the tree is laid out in. In `rtl` mode, the behavior of Left and
+         * Right arrow are switched.
+         */
+        this._horizontalOrientation = 'ltr';
+        /**
+         * Predicate function that can be used to check whether an item should be skipped
+         * by the key manager.
+         *
+         * The default value for this doesn't skip any elements in order to keep tree items focusable
+         * when disabled. This aligns with ARIA guidelines:
+         * https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#focusabilityofdisabledcontrols.
+         */
+        this._skipPredicateFn = (_item) => false;
+        /** Function to determine equivalent items. */
+        this._trackByFn = (item) => item;
+        /** Synchronous cache of the items to manage. */
+        this._items = [];
+        this._typeaheadSubscription = Subscription.EMPTY;
+        this._hasInitialFocused = false;
+        /** Stream that emits any time the focused item changes. */
+        this.change = new Subject();
+        // We allow for the items to be an array or Observable because, in some cases, the consumer may
+        // not have access to a QueryList of the items they want to manage (e.g. when the
+        // items aren't being collected via `ViewChildren` or `ContentChildren`).
+        if (items instanceof QueryList) {
+            this._items = items.toArray();
+            items.changes.subscribe((newItems) => {
+                this._items = newItems.toArray();
+                this._typeahead?.setItems(this._items);
+                this._updateActiveItemIndex(this._items);
+                this._initialFocus();
+            });
+        }
+        else if (isObservable(items)) {
+            items.subscribe(newItems => {
+                this._items = newItems;
+                this._typeahead?.setItems(newItems);
+                this._updateActiveItemIndex(newItems);
+                this._initialFocus();
+            });
+        }
+        else {
+            this._items = items;
+            this._initialFocus();
+        }
+        if (typeof config.shouldActivationFollowFocus === 'boolean') {
+            this._shouldActivationFollowFocus = config.shouldActivationFollowFocus;
+        }
+        if (config.horizontalOrientation) {
+            this._horizontalOrientation = config.horizontalOrientation;
+        }
+        if (config.skipPredicate) {
+            this._skipPredicateFn = config.skipPredicate;
+        }
+        if (config.trackBy) {
+            this._trackByFn = config.trackBy;
+        }
+        if (typeof config.typeAheadDebounceInterval !== 'undefined') {
+            this._setTypeAhead(config.typeAheadDebounceInterval);
+        }
+    }
+    /** Cleans up the key manager. */
+    destroy() {
+        this._typeaheadSubscription.unsubscribe();
+        this._typeahead?.destroy();
+        this.change.complete();
+    }
+    /**
+     * Handles a keyboard event on the tree.
+     * @param event Keyboard event that represents the user interaction with the tree.
+     */
+    onKeydown(event) {
+        const key = event.key;
+        switch (key) {
+            case 'Tab':
+                // Return early here, in order to allow Tab to actually tab out of the tree
+                return;
+            case 'ArrowDown':
+                this._focusNextItem();
+                break;
+            case 'ArrowUp':
+                this._focusPreviousItem();
+                break;
+            case 'ArrowRight':
+                this._horizontalOrientation === 'rtl'
+                    ? this._collapseCurrentItem()
+                    : this._expandCurrentItem();
+                break;
+            case 'ArrowLeft':
+                this._horizontalOrientation === 'rtl'
+                    ? this._expandCurrentItem()
+                    : this._collapseCurrentItem();
+                break;
+            case 'Home':
+                this._focusFirstItem();
+                break;
+            case 'End':
+                this._focusLastItem();
+                break;
+            case 'Enter':
+            case ' ':
+                this._activateCurrentItem();
+                break;
+            default:
+                if (event.key === '*') {
+                    this._expandAllItemsAtCurrentItemLevel();
+                    break;
+                }
+                this._typeahead?.handleKey(event);
+                // Return here, in order to avoid preventing the default action of non-navigational
+                // keys or resetting the buffer of pressed letters.
+                return;
+        }
+        // Reset the typeahead since the user has used a navigational key.
+        this._typeahead?.reset();
+        event.preventDefault();
+    }
+    /** Index of the currently active item. */
+    getActiveItemIndex() {
+        return this._activeItemIndex;
+    }
+    /** The currently active item. */
+    getActiveItem() {
+        return this._activeItem;
+    }
+    /** Focus the first available item. */
+    _focusFirstItem() {
+        this.focusItem(this._findNextAvailableItemIndex(-1));
+    }
+    /** Focus the last available item. */
+    _focusLastItem() {
+        this.focusItem(this._findPreviousAvailableItemIndex(this._items.length));
+    }
+    /** Focus the next available item. */
+    _focusNextItem() {
+        this.focusItem(this._findNextAvailableItemIndex(this._activeItemIndex));
+    }
+    /** Focus the previous available item. */
+    _focusPreviousItem() {
+        this.focusItem(this._findPreviousAvailableItemIndex(this._activeItemIndex));
+    }
+    focusItem(itemOrIndex, options = {}) {
+        // Set default options
+        options.emitChangeEvent ??= true;
+        let index = typeof itemOrIndex === 'number'
+            ? itemOrIndex
+            : this._items.findIndex(item => this._trackByFn(item) === this._trackByFn(itemOrIndex));
+        if (index < 0 || index >= this._items.length) {
+            return;
+        }
+        const activeItem = this._items[index];
+        // If we're just setting the same item, don't re-call activate or focus
+        if (this._activeItem !== null &&
+            this._trackByFn(activeItem) === this._trackByFn(this._activeItem)) {
+            return;
+        }
+        const previousActiveItem = this._activeItem;
+        this._activeItem = activeItem ?? null;
+        this._activeItemIndex = index;
+        this._typeahead?.setCurrentSelectedItemIndex(index);
+        this._activeItem?.focus();
+        previousActiveItem?.unfocus();
+        if (options.emitChangeEvent) {
+            this.change.next(this._activeItem);
+        }
+        if (this._shouldActivationFollowFocus) {
+            this._activateCurrentItem();
+        }
+    }
+    _updateActiveItemIndex(newItems) {
+        const activeItem = this._activeItem;
+        if (!activeItem) {
+            return;
+        }
+        const newIndex = newItems.findIndex(item => this._trackByFn(item) === this._trackByFn(activeItem));
+        if (newIndex > -1 && newIndex !== this._activeItemIndex) {
+            this._activeItemIndex = newIndex;
+            this._typeahead?.setCurrentSelectedItemIndex(newIndex);
+        }
+    }
+    _setTypeAhead(debounceInterval) {
+        this._typeahead = new Typeahead(this._items, {
+            debounceInterval: typeof debounceInterval === 'number' ? debounceInterval : undefined,
+            skipPredicate: item => this._skipPredicateFn(item),
+        });
+        this._typeaheadSubscription = this._typeahead.selectedItem.subscribe(item => {
+            this.focusItem(item);
+        });
+    }
+    _findNextAvailableItemIndex(startingIndex) {
+        for (let i = startingIndex + 1; i < this._items.length; i++) {
+            if (!this._skipPredicateFn(this._items[i])) {
+                return i;
+            }
+        }
+        return startingIndex;
+    }
+    _findPreviousAvailableItemIndex(startingIndex) {
+        for (let i = startingIndex - 1; i >= 0; i--) {
+            if (!this._skipPredicateFn(this._items[i])) {
+                return i;
+            }
+        }
+        return startingIndex;
+    }
+    /**
+     * If the item is already expanded, we collapse the item. Otherwise, we will focus the parent.
+     */
+    _collapseCurrentItem() {
+        if (!this._activeItem) {
+            return;
+        }
+        if (this._isCurrentItemExpanded()) {
+            this._activeItem.collapse();
+        }
+        else {
+            const parent = this._activeItem.getParent();
+            if (!parent || this._skipPredicateFn(parent)) {
+                return;
+            }
+            this.focusItem(parent);
+        }
+    }
+    /**
+     * If the item is already collapsed, we expand the item. Otherwise, we will focus the first child.
+     */
+    _expandCurrentItem() {
+        if (!this._activeItem) {
+            return;
+        }
+        if (!this._isCurrentItemExpanded()) {
+            this._activeItem.expand();
+        }
+        else {
+            coerceObservable(this._activeItem.getChildren())
+                .pipe(take(1))
+                .subscribe(children => {
+                const firstChild = children.find(child => !this._skipPredicateFn(child));
+                if (!firstChild) {
+                    return;
+                }
+                this.focusItem(firstChild);
+            });
+        }
+    }
+    _isCurrentItemExpanded() {
+        if (!this._activeItem) {
+            return false;
+        }
+        return typeof this._activeItem.isExpanded === 'boolean'
+            ? this._activeItem.isExpanded
+            : this._activeItem.isExpanded();
+    }
+    _isItemDisabled(item) {
+        return typeof item.isDisabled === 'boolean' ? item.isDisabled : item.isDisabled?.();
+    }
+    /** For all items that are the same level as the current item, we expand those items. */
+    _expandAllItemsAtCurrentItemLevel() {
+        if (!this._activeItem) {
+            return;
+        }
+        const parent = this._activeItem.getParent();
+        let itemsToExpand;
+        if (!parent) {
+            itemsToExpand = observableOf(this._items.filter(item => item.getParent() === null));
+        }
+        else {
+            itemsToExpand = coerceObservable(parent.getChildren());
+        }
+        itemsToExpand.pipe(take(1)).subscribe(items => {
+            for (const item of items) {
+                item.expand();
+            }
+        });
+    }
+    _activateCurrentItem() {
+        this._activeItem?.activate();
+    }
+}
+/** @docs-private */
+export function TREE_KEY_MANAGER_FACTORY() {
+    return (items, options) => new TreeKeyManager(items, options);
+}
+/** Injection token that determines the key manager to use. */
+export const TREE_KEY_MANAGER = new InjectionToken('tree-key-manager', {
+    providedIn: 'root',
+    factory: TREE_KEY_MANAGER_FACTORY,
+});
+/** @docs-private */
+export const TREE_KEY_MANAGER_FACTORY_PROVIDER = {
+    provide: TREE_KEY_MANAGER,
+    useFactory: TREE_KEY_MANAGER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-key-manager.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/key-manager/tree-key-manager.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 {InjectionToken, QueryList} from '@angular/core';\nimport {coerceObservable} from '@angular/cdk/coercion/private';\nimport {Observable, Subject, Subscription, isObservable, of as observableOf} from 'rxjs';\nimport {take} from 'rxjs/operators';\nimport {\n  TreeKeyManagerFactory,\n  TreeKeyManagerItem,\n  TreeKeyManagerOptions,\n  TreeKeyManagerStrategy,\n} from './tree-key-manager-strategy';\nimport {Typeahead} from './typeahead';\n\n/**\n * This class manages keyboard events for trees. If you pass it a QueryList or other list of tree\n * items, it will set the active item, focus, handle expansion and typeahead correctly when\n * keyboard events occur.\n */\nexport class TreeKeyManager<T extends TreeKeyManagerItem> implements TreeKeyManagerStrategy<T> {\n  /** The index of the currently active (focused) item. */\n  private _activeItemIndex = -1;\n  /** The currently active (focused) item. */\n  private _activeItem: T | null = null;\n  /** Whether or not we activate the item when it's focused. */\n  private _shouldActivationFollowFocus = false;\n  /**\n   * The orientation that the tree is laid out in. In `rtl` mode, the behavior of Left and\n   * Right arrow are switched.\n   */\n  private _horizontalOrientation: 'ltr' | 'rtl' = 'ltr';\n\n  /**\n   * Predicate function that can be used to check whether an item should be skipped\n   * by the key manager.\n   *\n   * The default value for this doesn't skip any elements in order to keep tree items focusable\n   * when disabled. This aligns with ARIA guidelines:\n   * https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/#focusabilityofdisabledcontrols.\n   */\n  private _skipPredicateFn = (_item: T) => false;\n\n  /** Function to determine equivalent items. */\n  private _trackByFn: (item: T) => unknown = (item: T) => item;\n\n  /** Synchronous cache of the items to manage. */\n  private _items: T[] = [];\n\n  private _typeahead?: Typeahead<T>;\n  private _typeaheadSubscription = Subscription.EMPTY;\n\n  private _hasInitialFocused = false;\n\n  private _initialFocus() {\n    if (this._hasInitialFocused) {\n      return;\n    }\n\n    if (!this._items.length) {\n      return;\n    }\n\n    let focusIndex = 0;\n    for (let i = 0; i < this._items.length; i++) {\n      if (!this._skipPredicateFn(this._items[i]) && !this._isItemDisabled(this._items[i])) {\n        focusIndex = i;\n        break;\n      }\n    }\n\n    this.focusItem(focusIndex);\n    this._hasInitialFocused = true;\n  }\n\n  /**\n   *\n   * @param items List of TreeKeyManager options. Can be synchronous or asynchronous.\n   * @param config Optional configuration options. By default, use 'ltr' horizontal orientation. By\n   * default, do not skip any nodes. By default, key manager only calls `focus` method when items\n   * are focused and does not call `activate`. If `typeaheadDefaultInterval` is `true`, use a\n   * default interval of 200ms.\n   */\n  constructor(items: Observable<T[]> | QueryList<T> | T[], config: TreeKeyManagerOptions<T>) {\n    // We allow for the items to be an array or Observable because, in some cases, the consumer may\n    // not have access to a QueryList of the items they want to manage (e.g. when the\n    // items aren't being collected via `ViewChildren` or `ContentChildren`).\n    if (items instanceof QueryList) {\n      this._items = items.toArray();\n      items.changes.subscribe((newItems: QueryList<T>) => {\n        this._items = newItems.toArray();\n        this._typeahead?.setItems(this._items);\n        this._updateActiveItemIndex(this._items);\n        this._initialFocus();\n      });\n    } else if (isObservable(items)) {\n      items.subscribe(newItems => {\n        this._items = newItems;\n        this._typeahead?.setItems(newItems);\n        this._updateActiveItemIndex(newItems);\n        this._initialFocus();\n      });\n    } else {\n      this._items = items;\n      this._initialFocus();\n    }\n\n    if (typeof config.shouldActivationFollowFocus === 'boolean') {\n      this._shouldActivationFollowFocus = config.shouldActivationFollowFocus;\n    }\n    if (config.horizontalOrientation) {\n      this._horizontalOrientation = config.horizontalOrientation;\n    }\n    if (config.skipPredicate) {\n      this._skipPredicateFn = config.skipPredicate;\n    }\n    if (config.trackBy) {\n      this._trackByFn = config.trackBy;\n    }\n    if (typeof config.typeAheadDebounceInterval !== 'undefined') {\n      this._setTypeAhead(config.typeAheadDebounceInterval);\n    }\n  }\n\n  /** Stream that emits any time the focused item changes. */\n  readonly change = new Subject<T | null>();\n\n  /** Cleans up the key manager. */\n  destroy() {\n    this._typeaheadSubscription.unsubscribe();\n    this._typeahead?.destroy();\n    this.change.complete();\n  }\n\n  /**\n   * Handles a keyboard event on the tree.\n   * @param event Keyboard event that represents the user interaction with the tree.\n   */\n  onKeydown(event: KeyboardEvent) {\n    const key = event.key;\n\n    switch (key) {\n      case 'Tab':\n        // Return early here, in order to allow Tab to actually tab out of the tree\n        return;\n\n      case 'ArrowDown':\n        this._focusNextItem();\n        break;\n\n      case 'ArrowUp':\n        this._focusPreviousItem();\n        break;\n\n      case 'ArrowRight':\n        this._horizontalOrientation === 'rtl'\n          ? this._collapseCurrentItem()\n          : this._expandCurrentItem();\n        break;\n\n      case 'ArrowLeft':\n        this._horizontalOrientation === 'rtl'\n          ? this._expandCurrentItem()\n          : this._collapseCurrentItem();\n        break;\n\n      case 'Home':\n        this._focusFirstItem();\n        break;\n\n      case 'End':\n        this._focusLastItem();\n        break;\n\n      case 'Enter':\n      case ' ':\n        this._activateCurrentItem();\n        break;\n\n      default:\n        if (event.key === '*') {\n          this._expandAllItemsAtCurrentItemLevel();\n          break;\n        }\n\n        this._typeahead?.handleKey(event);\n        // Return here, in order to avoid preventing the default action of non-navigational\n        // keys or resetting the buffer of pressed letters.\n        return;\n    }\n\n    // Reset the typeahead since the user has used a navigational key.\n    this._typeahead?.reset();\n    event.preventDefault();\n  }\n\n  /** Index of the currently active item. */\n  getActiveItemIndex(): number | null {\n    return this._activeItemIndex;\n  }\n\n  /** The currently active item. */\n  getActiveItem(): T | null {\n    return this._activeItem;\n  }\n\n  /** Focus the first available item. */\n  private _focusFirstItem(): void {\n    this.focusItem(this._findNextAvailableItemIndex(-1));\n  }\n\n  /** Focus the last available item. */\n  private _focusLastItem(): void {\n    this.focusItem(this._findPreviousAvailableItemIndex(this._items.length));\n  }\n\n  /** Focus the next available item. */\n  private _focusNextItem(): void {\n    this.focusItem(this._findNextAvailableItemIndex(this._activeItemIndex));\n  }\n\n  /** Focus the previous available item. */\n  private _focusPreviousItem(): void {\n    this.focusItem(this._findPreviousAvailableItemIndex(this._activeItemIndex));\n  }\n\n  /**\n   * Focus the provided item by index.\n   * @param index The index of the item to focus.\n   * @param options Additional focusing options.\n   */\n  focusItem(index: number, options?: {emitChangeEvent?: boolean}): void;\n  focusItem(item: T, options?: {emitChangeEvent?: boolean}): void;\n  focusItem(itemOrIndex: number | T, options?: {emitChangeEvent?: boolean}): void;\n  focusItem(itemOrIndex: number | T, options: {emitChangeEvent?: boolean} = {}) {\n    // Set default options\n    options.emitChangeEvent ??= true;\n\n    let index =\n      typeof itemOrIndex === 'number'\n        ? itemOrIndex\n        : this._items.findIndex(item => this._trackByFn(item) === this._trackByFn(itemOrIndex));\n    if (index < 0 || index >= this._items.length) {\n      return;\n    }\n    const activeItem = this._items[index];\n\n    // If we're just setting the same item, don't re-call activate or focus\n    if (\n      this._activeItem !== null &&\n      this._trackByFn(activeItem) === this._trackByFn(this._activeItem)\n    ) {\n      return;\n    }\n\n    const previousActiveItem = this._activeItem;\n    this._activeItem = activeItem ?? null;\n    this._activeItemIndex = index;\n    this._typeahead?.setCurrentSelectedItemIndex(index);\n\n    this._activeItem?.focus();\n    previousActiveItem?.unfocus();\n\n    if (options.emitChangeEvent) {\n      this.change.next(this._activeItem);\n    }\n\n    if (this._shouldActivationFollowFocus) {\n      this._activateCurrentItem();\n    }\n  }\n\n  private _updateActiveItemIndex(newItems: T[]) {\n    const activeItem = this._activeItem;\n    if (!activeItem) {\n      return;\n    }\n\n    const newIndex = newItems.findIndex(\n      item => this._trackByFn(item) === this._trackByFn(activeItem),\n    );\n\n    if (newIndex > -1 && newIndex !== this._activeItemIndex) {\n      this._activeItemIndex = newIndex;\n      this._typeahead?.setCurrentSelectedItemIndex(newIndex);\n    }\n  }\n\n  private _setTypeAhead(debounceInterval: number | boolean) {\n    this._typeahead = new Typeahead(this._items, {\n      debounceInterval: typeof debounceInterval === 'number' ? debounceInterval : undefined,\n      skipPredicate: item => this._skipPredicateFn(item),\n    });\n\n    this._typeaheadSubscription = this._typeahead.selectedItem.subscribe(item => {\n      this.focusItem(item);\n    });\n  }\n\n  private _findNextAvailableItemIndex(startingIndex: number) {\n    for (let i = startingIndex + 1; i < this._items.length; i++) {\n      if (!this._skipPredicateFn(this._items[i])) {\n        return i;\n      }\n    }\n    return startingIndex;\n  }\n\n  private _findPreviousAvailableItemIndex(startingIndex: number) {\n    for (let i = startingIndex - 1; i >= 0; i--) {\n      if (!this._skipPredicateFn(this._items[i])) {\n        return i;\n      }\n    }\n    return startingIndex;\n  }\n\n  /**\n   * If the item is already expanded, we collapse the item. Otherwise, we will focus the parent.\n   */\n  private _collapseCurrentItem() {\n    if (!this._activeItem) {\n      return;\n    }\n\n    if (this._isCurrentItemExpanded()) {\n      this._activeItem.collapse();\n    } else {\n      const parent = this._activeItem.getParent();\n      if (!parent || this._skipPredicateFn(parent as T)) {\n        return;\n      }\n      this.focusItem(parent as T);\n    }\n  }\n\n  /**\n   * If the item is already collapsed, we expand the item. Otherwise, we will focus the first child.\n   */\n  private _expandCurrentItem() {\n    if (!this._activeItem) {\n      return;\n    }\n\n    if (!this._isCurrentItemExpanded()) {\n      this._activeItem.expand();\n    } else {\n      coerceObservable(this._activeItem.getChildren())\n        .pipe(take(1))\n        .subscribe(children => {\n          const firstChild = children.find(child => !this._skipPredicateFn(child as T));\n          if (!firstChild) {\n            return;\n          }\n          this.focusItem(firstChild as T);\n        });\n    }\n  }\n\n  private _isCurrentItemExpanded() {\n    if (!this._activeItem) {\n      return false;\n    }\n    return typeof this._activeItem.isExpanded === 'boolean'\n      ? this._activeItem.isExpanded\n      : this._activeItem.isExpanded();\n  }\n\n  private _isItemDisabled(item: TreeKeyManagerItem) {\n    return typeof item.isDisabled === 'boolean' ? item.isDisabled : item.isDisabled?.();\n  }\n\n  /** For all items that are the same level as the current item, we expand those items. */\n  private _expandAllItemsAtCurrentItemLevel() {\n    if (!this._activeItem) {\n      return;\n    }\n\n    const parent = this._activeItem.getParent();\n    let itemsToExpand;\n    if (!parent) {\n      itemsToExpand = observableOf(this._items.filter(item => item.getParent() === null));\n    } else {\n      itemsToExpand = coerceObservable(parent.getChildren());\n    }\n\n    itemsToExpand.pipe(take(1)).subscribe(items => {\n      for (const item of items) {\n        item.expand();\n      }\n    });\n  }\n\n  private _activateCurrentItem() {\n    this._activeItem?.activate();\n  }\n}\n\n/** @docs-private */\nexport function TREE_KEY_MANAGER_FACTORY<T extends TreeKeyManagerItem>(): TreeKeyManagerFactory<T> {\n  return (items, options) => new TreeKeyManager(items, options);\n}\n\n/** Injection token that determines the key manager to use. */\nexport const TREE_KEY_MANAGER = new InjectionToken<TreeKeyManagerFactory<any>>('tree-key-manager', {\n  providedIn: 'root',\n  factory: TREE_KEY_MANAGER_FACTORY,\n});\n\n/** @docs-private */\nexport const TREE_KEY_MANAGER_FACTORY_PROVIDER = {\n  provide: TREE_KEY_MANAGER,\n  useFactory: TREE_KEY_MANAGER_FACTORY,\n};\n"]}

package/esm2022/a11y/key-manager/typeahead.mjs

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 { A, NINE, Z, ZERO } from '@angular/cdk/keycodes';
+import { Subject } from 'rxjs';
+import { debounceTime, filter, map, tap } from 'rxjs/operators';
+const DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS = 200;
+/**
+ * Selects items based on keyboard inputs. Implements the typeahead functionality of
+ * `role="listbox"` or `role="tree"` and other related roles.
+ */
+export class Typeahead {
+    constructor(initialItems, config) {
+        this._letterKeyStream = new Subject();
+        this._items = [];
+        this._selectedItemIndex = -1;
+        /** Buffer for the letters that the user has pressed */
+        this._pressedLetters = [];
+        this._selectedItem = new Subject();
+        this.selectedItem = this._selectedItem;
+        const typeAheadInterval = typeof config?.debounceInterval === 'number'
+            ? config.debounceInterval
+            : DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS;
+        if (config?.skipPredicate) {
+            this._skipPredicateFn = config.skipPredicate;
+        }
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) &&
+            initialItems.length &&
+            initialItems.some(item => typeof item.getLabel !== 'function')) {
+            throw new Error('KeyManager items in typeahead mode must implement the `getLabel` method.');
+        }
+        this.setItems(initialItems);
+        this._setupKeyHandler(typeAheadInterval);
+    }
+    destroy() {
+        this._pressedLetters = [];
+        this._letterKeyStream.complete();
+        this._selectedItem.complete();
+    }
+    setCurrentSelectedItemIndex(index) {
+        this._selectedItemIndex = index;
+    }
+    setItems(items) {
+        this._items = items;
+    }
+    handleKey(event) {
+        const keyCode = event.keyCode;
+        // Attempt to use the `event.key` which also maps it to the user's keyboard language,
+        // otherwise fall back to resolving alphanumeric characters via the keyCode.
+        if (event.key && event.key.length === 1) {
+            this._letterKeyStream.next(event.key.toLocaleUpperCase());
+        }
+        else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {
+            this._letterKeyStream.next(String.fromCharCode(keyCode));
+        }
+    }
+    /** Gets whether the user is currently typing into the manager using the typeahead feature. */
+    isTyping() {
+        return this._pressedLetters.length > 0;
+    }
+    /** Resets the currently stored sequence of typed letters. */
+    reset() {
+        this._pressedLetters = [];
+    }
+    _setupKeyHandler(typeAheadInterval) {
+        // Debounce the presses of non-navigational keys, collect the ones that correspond to letters
+        // and convert those letters back into a string. Afterwards find the first item that starts
+        // with that string and select it.
+        this._letterKeyStream
+            .pipe(tap(letter => this._pressedLetters.push(letter)), debounceTime(typeAheadInterval), filter(() => this._pressedLetters.length > 0), map(() => this._pressedLetters.join('').toLocaleUpperCase()))
+            .subscribe(inputString => {
+            // Start at 1 because we want to start searching at the item immediately
+            // following the current active item.
+            for (let i = 1; i < this._items.length + 1; i++) {
+                const index = (this._selectedItemIndex + i) % this._items.length;
+                const item = this._items[index];
+                if (!this._skipPredicateFn?.(item) &&
+                    item.getLabel?.().toLocaleUpperCase().trim().indexOf(inputString) === 0) {
+                    this._selectedItem.next(item);
+                    break;
+                }
+            }
+            this._pressedLetters = [];
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead.js","sourceRoot":"","sources":["../../../../../../../src/cdk/a11y/key-manager/typeahead.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 {A, NINE, Z, ZERO} from '@angular/cdk/keycodes';\nimport {Subject, Observable} from 'rxjs';\nimport {debounceTime, filter, map, tap} from 'rxjs/operators';\n\nconst DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS = 200;\n\ninterface TypeaheadItem {\n  getLabel?(): string;\n}\n\ninterface TypeaheadConfig<T> {\n  debounceInterval?: number;\n  skipPredicate?: (item: T) => boolean | undefined;\n}\n\n/**\n * Selects items based on keyboard inputs. Implements the typeahead functionality of\n * `role=\"listbox\"` or `role=\"tree\"` and other related roles.\n */\nexport class Typeahead<T extends TypeaheadItem> {\n  private readonly _letterKeyStream = new Subject<string>();\n  private _items: readonly T[] = [];\n  private _selectedItemIndex = -1;\n\n  /** Buffer for the letters that the user has pressed */\n  private _pressedLetters: string[] = [];\n\n  private _skipPredicateFn?: (item: T) => boolean | undefined;\n\n  private readonly _selectedItem = new Subject<T>();\n  readonly selectedItem: Observable<T> = this._selectedItem;\n\n  constructor(initialItems: readonly T[], config?: TypeaheadConfig<T>) {\n    const typeAheadInterval =\n      typeof config?.debounceInterval === 'number'\n        ? config.debounceInterval\n        : DEFAULT_TYPEAHEAD_DEBOUNCE_INTERVAL_MS;\n\n    if (config?.skipPredicate) {\n      this._skipPredicateFn = config.skipPredicate;\n    }\n\n    if (\n      (typeof ngDevMode === 'undefined' || ngDevMode) &&\n      initialItems.length &&\n      initialItems.some(item => typeof item.getLabel !== 'function')\n    ) {\n      throw new Error('KeyManager items in typeahead mode must implement the `getLabel` method.');\n    }\n\n    this.setItems(initialItems);\n    this._setupKeyHandler(typeAheadInterval);\n  }\n\n  destroy() {\n    this._pressedLetters = [];\n    this._letterKeyStream.complete();\n    this._selectedItem.complete();\n  }\n\n  setCurrentSelectedItemIndex(index: number) {\n    this._selectedItemIndex = index;\n  }\n\n  setItems(items: readonly T[]) {\n    this._items = items;\n  }\n\n  handleKey(event: KeyboardEvent): void {\n    const keyCode = event.keyCode;\n\n    // Attempt to use the `event.key` which also maps it to the user's keyboard language,\n    // otherwise fall back to resolving alphanumeric characters via the keyCode.\n    if (event.key && event.key.length === 1) {\n      this._letterKeyStream.next(event.key.toLocaleUpperCase());\n    } else if ((keyCode >= A && keyCode <= Z) || (keyCode >= ZERO && keyCode <= NINE)) {\n      this._letterKeyStream.next(String.fromCharCode(keyCode));\n    }\n  }\n\n  /** Gets whether the user is currently typing into the manager using the typeahead feature. */\n  isTyping(): boolean {\n    return this._pressedLetters.length > 0;\n  }\n\n  /** Resets the currently stored sequence of typed letters. */\n  reset(): void {\n    this._pressedLetters = [];\n  }\n\n  private _setupKeyHandler(typeAheadInterval: number) {\n    // Debounce the presses of non-navigational keys, collect the ones that correspond to letters\n    // and convert those letters back into a string. Afterwards find the first item that starts\n    // with that string and select it.\n    this._letterKeyStream\n      .pipe(\n        tap(letter => this._pressedLetters.push(letter)),\n        debounceTime(typeAheadInterval),\n        filter(() => this._pressedLetters.length > 0),\n        map(() => this._pressedLetters.join('').toLocaleUpperCase()),\n      )\n      .subscribe(inputString => {\n        // Start at 1 because we want to start searching at the item immediately\n        // following the current active item.\n        for (let i = 1; i < this._items.length + 1; i++) {\n          const index = (this._selectedItemIndex + i) % this._items.length;\n          const item = this._items[index];\n\n          if (\n            !this._skipPredicateFn?.(item) &&\n            item.getLabel?.().toLocaleUpperCase().trim().indexOf(inputString) === 0\n          ) {\n            this._selectedItem.next(item);\n            break;\n          }\n        }\n\n        this._pressedLetters = [];\n      });\n  }\n}\n"]}