@angular/cdk 19.2.3 → 20.0.0-next.1

package/list-key-manager.d-72e9a2e7.d.ts

@@ -0,0 +1,164 @@
+import { QueryList, Signal, Injector } from '@angular/core';
+import { Subject } from 'rxjs';
+
+/** This interface is for items that can be passed to a ListKeyManager. */
+interface ListKeyManagerOption {
+    /** Whether the option is disabled. */
+    disabled?: boolean;
+    /** Gets the label for this option. */
+    getLabel?(): string;
+}
+/** Modifier keys handled by the ListKeyManager. */
+type ListKeyManagerModifierKey = 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey';
+/**
+ * This class manages keyboard events for selectable lists. If you pass it a query list
+ * of items, it will set the active item correctly when arrow events occur.
+ */
+declare class ListKeyManager<T extends ListKeyManagerOption> {
+    private _items;
+    private _activeItemIndex;
+    private _activeItem;
+    private _wrap;
+    private _typeaheadSubscription;
+    private _itemChangesSubscription?;
+    private _vertical;
+    private _horizontal;
+    private _allowedModifierKeys;
+    private _homeAndEnd;
+    private _pageUpAndDown;
+    private _effectRef;
+    private _typeahead?;
+    /**
+     * Predicate function that can be used to check whether an item should be skipped
+     * by the key manager. By default, disabled items are skipped.
+     */
+    private _skipPredicateFn;
+    constructor(items: QueryList<T> | T[] | readonly T[]);
+    constructor(items: Signal<T[]> | Signal<readonly T[]>, injector: Injector);
+    /**
+     * Stream that emits any time the TAB key is pressed, so components can react
+     * when focus is shifted off of the list.
+     */
+    readonly tabOut: Subject<void>;
+    /** Stream that emits whenever the active item of the list manager changes. */
+    readonly change: Subject<number>;
+    /**
+     * Sets the predicate function that determines which items should be skipped by the
+     * list key manager.
+     * @param predicate Function that determines whether the given item should be skipped.
+     */
+    skipPredicate(predicate: (item: T) => boolean): this;
+    /**
+     * Configures wrapping mode, which determines whether the active item will wrap to
+     * the other end of list when there are no more items in the given direction.
+     * @param shouldWrap Whether the list should wrap when reaching the end.
+     */
+    withWrap(shouldWrap?: boolean): this;
+    /**
+     * Configures whether the key manager should be able to move the selection vertically.
+     * @param enabled Whether vertical selection should be enabled.
+     */
+    withVerticalOrientation(enabled?: boolean): this;
+    /**
+     * Configures the key manager to move the selection horizontally.
+     * Passing in `null` will disable horizontal movement.
+     * @param direction Direction in which the selection can be moved.
+     */
+    withHorizontalOrientation(direction: 'ltr' | 'rtl' | null): this;
+    /**
+     * Modifier keys which are allowed to be held down and whose default actions will be prevented
+     * as the user is pressing the arrow keys. Defaults to not allowing any modifier keys.
+     */
+    withAllowedModifierKeys(keys: ListKeyManagerModifierKey[]): this;
+    /**
+     * Turns on typeahead mode which allows users to set the active item by typing.
+     * @param debounceInterval Time to wait after the last keystroke before setting the active item.
+     */
+    withTypeAhead(debounceInterval?: number): this;
+    /** Cancels the current typeahead sequence. */
+    cancelTypeahead(): this;
+    /**
+     * Configures the key manager to activate the first and last items
+     * respectively when the Home or End key is pressed.
+     * @param enabled Whether pressing the Home or End key activates the first/last item.
+     */
+    withHomeAndEnd(enabled?: boolean): this;
+    /**
+     * Configures the key manager to activate every 10th, configured or first/last element in up/down direction
+     * respectively when the Page-Up or Page-Down key is pressed.
+     * @param enabled Whether pressing the Page-Up or Page-Down key activates the first/last item.
+     * @param delta Whether pressing the Home or End key activates the first/last item.
+     */
+    withPageUpDown(enabled?: boolean, delta?: number): this;
+    /**
+     * Sets the active item to the item at the index specified.
+     * @param index The index of the item to be set as active.
+     */
+    setActiveItem(index: number): void;
+    /**
+     * Sets the active item to the specified item.
+     * @param item The item to be set as active.
+     */
+    setActiveItem(item: T): void;
+    /**
+     * Sets the active item depending on the key event passed in.
+     * @param event Keyboard event to be used for determining which element should be active.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /** Index of the currently active item. */
+    get activeItemIndex(): number | null;
+    /** The active item. */
+    get activeItem(): T | null;
+    /** Gets whether the user is currently typing into the manager using the typeahead feature. */
+    isTyping(): boolean;
+    /** Sets the active item to the first enabled item in the list. */
+    setFirstItemActive(): void;
+    /** Sets the active item to the last enabled item in the list. */
+    setLastItemActive(): void;
+    /** Sets the active item to the next enabled item in the list. */
+    setNextItemActive(): void;
+    /** Sets the active item to a previous enabled item in the list. */
+    setPreviousItemActive(): void;
+    /**
+     * Allows setting the active without any other effects.
+     * @param index Index of the item to be set as active.
+     */
+    updateActiveItem(index: number): void;
+    /**
+     * Allows setting the active item without any other effects.
+     * @param item Item to be set as active.
+     */
+    updateActiveItem(item: T): void;
+    /** Cleans up the key manager. */
+    destroy(): void;
+    /**
+     * This method sets the active item, given a list of items and the delta between the
+     * currently active item and the new active item. It will calculate differently
+     * depending on whether wrap mode is turned on.
+     */
+    private _setActiveItemByDelta;
+    /**
+     * Sets the active item properly given "wrap" mode. In other words, it will continue to move
+     * down the list until it finds an item that is not disabled, and it will wrap if it
+     * encounters either end of the list.
+     */
+    private _setActiveInWrapMode;
+    /**
+     * Sets the active item properly given the default mode. In other words, it will
+     * continue to move down the list until it finds an item that is not disabled. If
+     * it encounters either end of the list, it will stop and not wrap.
+     */
+    private _setActiveInDefaultMode;
+    /**
+     * Sets the active item to the first enabled item starting at the index specified. If the
+     * item is disabled, it will move in the fallbackDelta direction until it either
+     * finds an enabled item or encounters the end of the list.
+     */
+    private _setActiveItemByIndex;
+    /** Returns the items as an array. */
+    private _getItemsArray;
+    /** Callback for when the items have changed. */
+    private _itemsChanged;
+}
+
+export { type ListKeyManagerOption as L, type ListKeyManagerModifierKey as a, ListKeyManager as b };

package/listbox/index.d.ts

@@ -1,9 +1,10 @@
-import { ListKeyManagerOption, Highlightable, ActiveDescendantKeyManager } from '@angular/cdk/a11y';
-import { SelectionModel } from '@angular/cdk/collections';
 import * as i0 from '@angular/core';
 import { OnDestroy, AfterContentInit, QueryList, NgZone, ChangeDetectorRef } from '@angular/core';
-import { ControlValueAccessor } from '@angular/forms';
+import { H as Highlightable, A as ActiveDescendantKeyManager } from '../activedescendant-key-manager.d-11921e3a.js';
+import { L as ListKeyManagerOption } from '../list-key-manager.d-72e9a2e7.js';
 import { Subject } from 'rxjs';
+import { S as SelectionModel } from '../selection-model.d-1a70542c.js';
+import { ControlValueAccessor } from '@angular/forms';
 
 /**
  * An implementation of SelectionModel that internally always represents the selection as a
@@ -17,7 +18,7 @@ declare class ListboxSelectionModel<T> extends SelectionModel<T> {
     multiple: boolean;
     constructor(multiple?: boolean, initiallySelectedValues?: T[], emitChanges?: boolean, compareWith?: (o1: T, o2: T) => boolean);
     isMultipleSelection(): boolean;
-    select(...values: T[]): boolean | void;
+    select(...values: T[]): boolean;
 }
 /** A selectable option in a listbox. */
 declare class CdkOption<T = unknown> implements ListKeyManagerOption, Highlightable, OnDestroy {

package/menu/index.d.ts

@@ -1,12 +1,20 @@
 import * as i0 from '@angular/core';
 import { ElementRef, Renderer2, QueryList, InjectionToken, Optional, OnDestroy, Injector, ViewContainerRef, EventEmitter, TemplateRef, OnChanges, SimpleChanges, NgZone, AfterContentInit } from '@angular/core';
-import * as i1 from '@angular/cdk/overlay';
-import { ScrollStrategy, ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { S as ScrollStrategy, C as ConnectedPosition, O as OverlayRef, a as OverlayModule } from '../overlay-module.d-5d06db8a.js';
 import * as rxjs from 'rxjs';
 import { Observable, Subject } from 'rxjs';
-import { FocusOrigin, FocusableOption, FocusKeyManager } from '@angular/cdk/a11y';
-import { Directionality } from '@angular/cdk/bidi';
-import { TemplatePortal } from '@angular/cdk/portal';
+import { F as FocusOrigin } from '../focus-monitor.d-810a02e6.js';
+import { F as FocusableOption, a as FocusKeyManager } from '../focus-key-manager.d-415a6958.js';
+import { D as Directionality } from '../bidi-module.d-f8648621.js';
+import { T as TemplatePortal } from '../portal-directives.d-d345bd53.js';
+import '../scrolling-module.d-a08a462d.js';
+import '../data-source.d-7cab2c9d.js';
+import '../number-property.d-ce316715.js';
+import '@angular/common';
+import '../viewport-ruler.d-f3d3e82f.js';
+import '../platform.d-0a5b4792.js';
+import '../style-loader.d-19baab84.js';
+import '../list-key-manager.d-72e9a2e7.js';
 
 /** Item to track for mouse focus events. */
 interface FocusableElement {
@@ -805,7 +813,7 @@ declare class CdkContextMenuTrigger extends CdkMenuTriggerBase implements OnDest
 /** Module that declares components and directives for the CDK menu. */
 declare class CdkMenuModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, never, [typeof i1.OverlayModule, typeof CdkMenuBar, typeof CdkMenu, typeof CdkMenuItem, typeof CdkMenuItemRadio, typeof CdkMenuItemCheckbox, typeof CdkMenuTrigger, typeof CdkMenuGroup, typeof CdkContextMenuTrigger, typeof CdkTargetMenuAim], [typeof CdkMenuBar, typeof CdkMenu, typeof CdkMenuItem, typeof CdkMenuItemRadio, typeof CdkMenuItemCheckbox, typeof CdkMenuTrigger, typeof CdkMenuGroup, typeof CdkContextMenuTrigger, typeof CdkTargetMenuAim]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, never, [typeof OverlayModule, typeof CdkMenuBar, typeof CdkMenu, typeof CdkMenuItem, typeof CdkMenuItemRadio, typeof CdkMenuItemCheckbox, typeof CdkMenuTrigger, typeof CdkMenuGroup, typeof CdkContextMenuTrigger, typeof CdkTargetMenuAim], [typeof CdkMenuBar, typeof CdkMenu, typeof CdkMenuItem, typeof CdkMenuItemRadio, typeof CdkMenuItemCheckbox, typeof CdkMenuTrigger, typeof CdkMenuGroup, typeof CdkContextMenuTrigger, typeof CdkTargetMenuAim]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
 }
 

package/number-property.d-ce316715.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type describing the allowed values for a number input
+ * @docs-private
+ */
+type NumberInput = string | number | null | undefined;
+/** Coerces a data-bound value (typically a string) to a number. */
+declare function coerceNumberProperty(value: any): number;
+declare function coerceNumberProperty<D>(value: any, fallback: D): number | D;
+/**
+ * Whether the provided value is considered a number.
+ * @docs-private
+ */
+declare function _isNumberValue(value: any): boolean;
+
+export { type NumberInput as N, _isNumberValue as _, coerceNumberProperty as c };

package/observe-content.d-c08bc882.d.ts

@@ -0,0 +1,84 @@
+import { N as NumberInput } from './number-property.d-ce316715.js';
+import * as i0 from '@angular/core';
+import { OnDestroy, ElementRef, AfterContentInit, EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/**
+ * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.
+ * @docs-private
+ */
+declare class MutationObserverFactory {
+    create(callback: MutationCallback): MutationObserver | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserverFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MutationObserverFactory>;
+}
+/** An injectable service that allows watching elements for changes to their content. */
+declare class ContentObserver implements OnDestroy {
+    private _mutationObserverFactory;
+    /** Keeps track of the existing MutationObservers so they can be reused. */
+    private _observedElements;
+    private _ngZone;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    /**
+     * Observe content changes on an element.
+     * @param element The element to observe for content changes.
+     */
+    observe(element: Element): Observable<MutationRecord[]>;
+    /**
+     * Observe content changes on an element.
+     * @param element The element to observe for content changes.
+     */
+    observe(element: ElementRef<Element>): Observable<MutationRecord[]>;
+    /**
+     * Observes the given element by using the existing MutationObserver if available, or creating a
+     * new one if not.
+     */
+    private _observeElement;
+    /**
+     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
+     * observing this element.
+     */
+    private _unobserveElement;
+    /** Clean up the underlying MutationObserver for the specified element. */
+    private _cleanupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContentObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContentObserver>;
+}
+/**
+ * Directive that triggers a callback whenever the content of
+ * its associated element has changed.
+ */
+declare class CdkObserveContent implements AfterContentInit, OnDestroy {
+    private _contentObserver;
+    private _elementRef;
+    /** Event emitted for each change in the element's content. */
+    readonly event: EventEmitter<MutationRecord[]>;
+    /**
+     * Whether observing content is disabled. This option can be used
+     * to disconnect the underlying MutationObserver until it is needed.
+     */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    /** Debounce interval for emitting the changes. */
+    get debounce(): number;
+    set debounce(value: NumberInput);
+    private _debounce;
+    private _currentSubscription;
+    constructor(...args: unknown[]);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private _subscribe;
+    private _unsubscribe;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkObserveContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkObserveContent, "[cdkObserveContent]", ["cdkObserveContent"], { "disabled": { "alias": "cdkObserveContentDisabled"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; }, { "event": "cdkObserveContent"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+declare class ObserversModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObserversModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ObserversModule, never, [typeof CdkObserveContent], [typeof CdkObserveContent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ObserversModule>;
+}
+
+export { ContentObserver as C, MutationObserverFactory as M, ObserversModule as O, CdkObserveContent as a };

package/observers/index.d.ts

@@ -1,84 +1,4 @@
-import { NumberInput } from '@angular/cdk/coercion';
-import * as i0 from '@angular/core';
-import { OnDestroy, ElementRef, AfterContentInit, EventEmitter } from '@angular/core';
-import { Observable } from 'rxjs';
-
-/**
- * Factory that creates a new MutationObserver and allows us to stub it out in unit tests.
- * @docs-private
- */
-declare class MutationObserverFactory {
-    create(callback: MutationCallback): MutationObserver | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserverFactory, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MutationObserverFactory>;
-}
-/** An injectable service that allows watching elements for changes to their content. */
-declare class ContentObserver implements OnDestroy {
-    private _mutationObserverFactory;
-    /** Keeps track of the existing MutationObservers so they can be reused. */
-    private _observedElements;
-    private _ngZone;
-    constructor(...args: unknown[]);
-    ngOnDestroy(): void;
-    /**
-     * Observe content changes on an element.
-     * @param element The element to observe for content changes.
-     */
-    observe(element: Element): Observable<MutationRecord[]>;
-    /**
-     * Observe content changes on an element.
-     * @param element The element to observe for content changes.
-     */
-    observe(element: ElementRef<Element>): Observable<MutationRecord[]>;
-    /**
-     * Observes the given element by using the existing MutationObserver if available, or creating a
-     * new one if not.
-     */
-    private _observeElement;
-    /**
-     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
-     * observing this element.
-     */
-    private _unobserveElement;
-    /** Clean up the underlying MutationObserver for the specified element. */
-    private _cleanupObserver;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ContentObserver, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ContentObserver>;
-}
-/**
- * Directive that triggers a callback whenever the content of
- * its associated element has changed.
- */
-declare class CdkObserveContent implements AfterContentInit, OnDestroy {
-    private _contentObserver;
-    private _elementRef;
-    /** Event emitted for each change in the element's content. */
-    readonly event: EventEmitter<MutationRecord[]>;
-    /**
-     * Whether observing content is disabled. This option can be used
-     * to disconnect the underlying MutationObserver until it is needed.
-     */
-    get disabled(): boolean;
-    set disabled(value: boolean);
-    private _disabled;
-    /** Debounce interval for emitting the changes. */
-    get debounce(): number;
-    set debounce(value: NumberInput);
-    private _debounce;
-    private _currentSubscription;
-    constructor(...args: unknown[]);
-    ngAfterContentInit(): void;
-    ngOnDestroy(): void;
-    private _subscribe;
-    private _unsubscribe;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkObserveContent, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkObserveContent, "[cdkObserveContent]", ["cdkObserveContent"], { "disabled": { "alias": "cdkObserveContentDisabled"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; }, { "event": "cdkObserveContent"; }, never, never, true, never>;
-    static ngAcceptInputType_disabled: unknown;
-}
-declare class ObserversModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ObserversModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ObserversModule, never, [typeof CdkObserveContent], [typeof CdkObserveContent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ObserversModule>;
-}
-
-export { CdkObserveContent, ContentObserver, MutationObserverFactory, ObserversModule };
+export { a as CdkObserveContent, C as ContentObserver, M as MutationObserverFactory, O as ObserversModule } from '../observe-content.d-c08bc882.js';
+import '../number-property.d-ce316715.js';
+import '@angular/core';
+import 'rxjs';