@angular/cdk-experimental 20.0.0-next.1 → 20.0.0-next.10

package/list-navigation.d-DfOSxsSp.d.ts

@@ -0,0 +1,247 @@
+import * as i0 from '@angular/core';
+
+type SignalLike<T> = () => T;
+interface WritableSignalLike<T> extends SignalLike<T> {
+    set(value: T): void;
+    update(updateFn: (value: T) => T): void;
+}
+/** Converts a getter setter style signal to a WritableSignalLike. */
+declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
+
+/**
+ * Options that are applicable to all event handlers.
+ *
+ * This library has not yet had a need for stopPropagationImmediate.
+ */
+interface EventHandlerOptions {
+    stopPropagation: boolean;
+    preventDefault: boolean;
+}
+/** A basic event handler. */
+type EventHandler<T extends Event> = (event: T) => void;
+/** A function that determines whether an event is to be handled. */
+type EventMatcher<T extends Event> = (event: T) => boolean;
+/** A config that specifies how to handle a particular event. */
+interface EventHandlerConfig<T extends Event> extends EventHandlerOptions {
+    matcher: EventMatcher<T>;
+    handler: EventHandler<T>;
+}
+/** Bit flag representation of the possible modifier keys that can be present on an event. */
+declare enum ModifierKey {
+    None = 0,
+    Ctrl = 1,
+    Shift = 2,
+    Alt = 4,
+    Meta = 8,
+    Any = "Any"
+}
+type ModifierInputs = ModifierKey | ModifierKey[];
+/**
+ * Abstract base class for all event managers.
+ *
+ * Event managers are designed to normalize how event handlers are authored and create a safety net
+ * for common event handling gotchas like remembering to call preventDefault or stopPropagation.
+ */
+declare abstract class EventManager<T extends Event> {
+    protected configs: EventHandlerConfig<T>[];
+    abstract options: EventHandlerOptions;
+    /** Runs the handlers that match with the given event. */
+    handle(event: T): void;
+    /** Configures the event manager to handle specific events. (See subclasses for more). */
+    abstract on(...args: [...unknown[]]): this;
+}
+
+/**
+ * Used to represent a keycode.
+ *
+ * This is used to match whether an events keycode should be handled. The ability to match using a
+ * string, SignalLike, or Regexp gives us more flexibility when authoring event handlers.
+ */
+type KeyCode = string | SignalLike<string> | RegExp;
+/**
+ * An event manager that is specialized for handling keyboard events. By default this manager stops
+ * propagation and prevents default on all events it handles.
+ */
+declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /** Configures this event manager to handle events with a specific key and no modifiers. */
+    on(key: KeyCode, handler: EventHandler<T>): this;
+    /**  Configures this event manager to handle events with a specific modifer and key combination. */
+    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>): this;
+    private _normalizeInputs;
+    private _isMatch;
+}
+
+/**
+ * The different mouse buttons that may appear on a pointer event.
+ */
+declare enum MouseButton {
+    Main = 0,
+    Auxiliary = 1,
+    Secondary = 2
+}
+/** An event manager that is specialized for handling pointer events. */
+declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
+    options: EventHandlerOptions;
+    /**
+     * Configures this event manager to handle events with a specific modifer and mouse button
+     * combination.
+     */
+    on(button: MouseButton, modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with a specific mouse button and no modifiers.
+     */
+    on(modifiers: ModifierInputs, handler: EventHandler<T>): this;
+    /**
+     * Configures this event manager to handle events with the main mouse button and no modifiers.
+     *
+     * @param handler The handler function
+     * @param options Options for whether to stop propagation or prevent default.
+     */
+    on(handler: EventHandler<T>): this;
+    private _normalizeInputs;
+    _isMatch(event: PointerEvent, button: MouseButton, modifiers: ModifierInputs): boolean;
+}
+
+/** Represents an item in a collection, such as a listbox option, than may receive focus. */
+interface ListFocusItem {
+    /** A unique identifier for the item. */
+    id: SignalLike<string>;
+    /** The html element that should receive focus. */
+    element: SignalLike<HTMLElement>;
+    /** Whether an item is disabled. */
+    disabled: SignalLike<boolean>;
+}
+/** Represents the required inputs for a collection that contains focusable items. */
+interface ListFocusInputs<T extends ListFocusItem> {
+    /** The focus strategy used by the list. */
+    focusMode: SignalLike<'roving' | 'activedescendant'>;
+    /** Whether the list is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The items in the list. */
+    items: SignalLike<T[]>;
+    /** The index of the current active item. */
+    activeIndex: WritableSignalLike<number>;
+    /** Whether disabled items in the list should be skipped when navigating. */
+    skipDisabled: SignalLike<boolean>;
+}
+/** Controls focus for a list of items. */
+declare class ListFocus<T extends ListFocusItem> {
+    readonly inputs: ListFocusInputs<T>;
+    /** The last index that was active. */
+    prevActiveIndex: i0.WritableSignal<number>;
+    /** The current active item. */
+    activeItem: i0.Signal<T>;
+    constructor(inputs: ListFocusInputs<T>);
+    /** Whether the list is in a disabled state. */
+    isListDisabled(): boolean;
+    /** The id of the current active item. */
+    getActiveDescendant(): string | undefined;
+    /** The tabindex for the list. */
+    getListTabindex(): -1 | 0;
+    /** Returns the tabindex for the given item. */
+    getItemTabindex(item: T): -1 | 0;
+    /** Moves focus to the given item if it is focusable. */
+    focus(item: T): boolean;
+    /** Returns true if the given item can be navigated to. */
+    isFocusable(item: T): boolean;
+}
+
+/** Represents an item in a collection, such as a listbox option, than can be selected. */
+interface ListSelectionItem<V> extends ListFocusItem {
+    /** The value of the item. */
+    value: SignalLike<V>;
+}
+/** Represents the required inputs for a collection that contains selectable items. */
+interface ListSelectionInputs<T extends ListSelectionItem<V>, V> extends ListFocusInputs<T> {
+    /** Whether multiple items in the list can be selected at once. */
+    multi: SignalLike<boolean>;
+    /** The current value of the list selection. */
+    value: WritableSignalLike<V[]>;
+    /** The selection strategy used by the list. */
+    selectionMode: SignalLike<'follow' | 'explicit'>;
+}
+/** Controls selection for a list of items. */
+declare class ListSelection<T extends ListSelectionItem<V>, V> {
+    readonly inputs: ListSelectionInputs<T, V> & {
+        focusManager: ListFocus<T>;
+    };
+    /** The start index to use for range selection. */
+    rangeStartIndex: i0.WritableSignal<number>;
+    /** The end index to use for range selection. */
+    rangeEndIndex: i0.WritableSignal<number>;
+    constructor(inputs: ListSelectionInputs<T, V> & {
+        focusManager: ListFocus<T>;
+    });
+    /** Selects the item at the current active index. */
+    select(item?: ListSelectionItem<V>, opts?: {
+        anchor: boolean;
+    }): void;
+    /** Deselects the item at the current active index. */
+    deselect(item?: T): void;
+    /** Toggles the item at the current active index. */
+    toggle(): void;
+    /** Toggles only the item at the current active index. */
+    toggleOne(): void;
+    /** Selects all items in the list. */
+    selectAll(): void;
+    /** Deselects all items in the list. */
+    deselectAll(): void;
+    /**
+     * Selects all items in the list or deselects all
+     * items in the list if all items are already selected.
+     */
+    toggleAll(): void;
+    /** Sets the selection to only the current active item. */
+    selectOne(): void;
+    /**
+     * Selects all items in the list up to the anchor item.
+     *
+     * Deselects all items that were previously within the
+     * selected range that are now outside of the selected range
+     */
+    selectRange(opts?: {
+        anchor: boolean;
+    }): void;
+    /** Marks the given index as the start of a range selection. */
+    beginRangeSelection(index?: number): void;
+    /** Returns the items in the list starting from the given index.  */
+    private _getItemsFromIndex;
+}
+
+/** Represents an item in a collection, such as a listbox option, than can be navigated to. */
+interface ListNavigationItem extends ListFocusItem {
+}
+/** Represents the required inputs for a collection that has navigable items. */
+interface ListNavigationInputs<T extends ListNavigationItem> extends ListFocusInputs<T> {
+    /** Whether focus should wrap when navigating. */
+    wrap: SignalLike<boolean>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** The direction that text is read based on the users locale. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
+}
+/** Controls navigation for a list of items. */
+declare class ListNavigation<T extends ListNavigationItem> {
+    readonly inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    };
+    constructor(inputs: ListNavigationInputs<T> & {
+        focusManager: ListFocus<T>;
+    });
+    /** Navigates to the given item. */
+    goto(item?: T): boolean;
+    /** Navigates to the next item in the list. */
+    next(): boolean;
+    /** Navigates to the previous item in the list. */
+    prev(): boolean;
+    /** Navigates to the first item in the list. */
+    first(): boolean;
+    /** Navigates to the last item in the list. */
+    last(): boolean;
+    /** Advances to the next or previous focusable item in the list based on the given delta. */
+    private _advance;
+}
+
+export { KeyboardEventManager as K, PointerEventManager as P, convertGetterSetterToWritableSignalLike as c, ListNavigation as g, ListSelection as h, ListFocus as i };
+export type { ListNavigationItem as L, SignalLike as S, WritableSignalLike as W, ListSelectionItem as a, ListFocusItem as b, ListNavigationInputs as d, ListSelectionInputs as e, ListFocusInputs as f };

package/listbox/index.d.ts

@@ -1,6 +1,8 @@
 import * as i0 from '@angular/core';
+import { AfterViewInit } from '@angular/core';
 import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import { O as OptionPattern, L as ListboxPattern } from '../listbox.d-8e28229b.js';
+import { b as OptionPattern, a as ListboxPattern } from '../listbox.d-QWPLmxRe.js';
+import '../list-navigation.d-DfOSxsSp.js';
 
 /**
  * A listbox container.
@@ -10,13 +12,13 @@ import { O as OptionPattern, L as ListboxPattern } from '../listbox.d-8e28229b.j
  *
  * ```html
  * <ul cdkListbox>
- *   <li cdkOption>Item 1</li>
- *   <li cdkOption>Item 2</li>
- *   <li cdkOption>Item 3</li>
+ *   <li [value]="1" cdkOption>Item 1</li>
+ *   <li [value]="2" cdkOption>Item 2</li>
+ *   <li [value]="3" cdkOption>Item 3</li>
  * </ul>
  * ```
  */
-declare class CdkListbox {
+declare class CdkListbox<V> implements AfterViewInit {
     /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
     private readonly _directionality;
     /** The CdkOptions nested inside of the CdkListbox. */
@@ -24,11 +26,11 @@ declare class CdkListbox {
     /** A signal wrapper for directionality. */
     protected textDirection: i0.Signal<_angular_cdk_bidi.Direction>;
     /** The Option UIPatterns of the child CdkOptions. */
-    protected items: i0.Signal<OptionPattern[]>;
+    protected items: i0.Signal<OptionPattern<any>[]>;
     /** Whether the list is vertically or horizontally oriented. */
     orientation: i0.InputSignal<"vertical" | "horizontal">;
     /** Whether multiple items in the list can be selected at once. */
-    multiselectable: i0.InputSignalWithTransform<boolean, unknown>;
+    multi: i0.InputSignalWithTransform<boolean, unknown>;
     /** Whether focus should wrap when navigating. */
     wrap: i0.InputSignalWithTransform<boolean, unknown>;
     /** Whether disabled items in the list should be skipped when navigating. */
@@ -41,17 +43,26 @@ declare class CdkListbox {
     typeaheadDelay: i0.InputSignal<number>;
     /** Whether the listbox is disabled. */
     disabled: i0.InputSignalWithTransform<boolean, unknown>;
-    /** The ids of the current selected items. */
-    selectedIds: i0.ModelSignal<string[]>;
+    /** Whether the listbox is readonly. */
+    readonly: i0.InputSignalWithTransform<boolean, unknown>;
+    /** The values of the current selected items. */
+    value: i0.ModelSignal<V[]>;
     /** The current index that has been navigated to. */
     activeIndex: i0.ModelSignal<number>;
     /** The Listbox UIPattern. */
-    pattern: ListboxPattern;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkListbox, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkListbox, "[cdkListbox]", ["cdkListbox"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multiselectable": { "alias": "multiselectable"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "selectedIds": "selectedIdsChange"; "activeIndex": "activeIndexChange"; }, ["_cdkOptions"], never, true, never>;
+    pattern: ListboxPattern<V>;
+    /** Whether the listbox has received focus yet. */
+    private _hasFocused;
+    /** Whether the options in the listbox have been initialized. */
+    private _isViewInitialized;
+    constructor();
+    ngAfterViewInit(): void;
+    onFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkListbox<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkListbox<any>, "[cdkListbox]", ["cdkListbox"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "activeIndex": "activeIndexChange"; }, ["_cdkOptions"], never, true, never>;
 }
 /** A selectable option in a CdkListbox. */
-declare class CdkOption {
+declare class CdkOption<V> {
     /** A reference to the option element. */
     private readonly _elementRef;
     /** The parent CdkListbox. */
@@ -60,10 +71,12 @@ declare class CdkOption {
     private readonly _generatedId;
     /** A unique identifier for the option. */
     protected id: i0.Signal<string>;
+    /** The value of the option. */
+    protected value: i0.InputSignal<V>;
     /** The text used by the typeahead search. */
     protected searchTerm: i0.Signal<any>;
     /** The parent Listbox UIPattern. */
-    protected listbox: i0.Signal<ListboxPattern>;
+    protected listbox: i0.Signal<ListboxPattern<any>>;
     /** A reference to the option element to be focused on navigation. */
     protected element: i0.Signal<any>;
     /** Whether an item is disabled. */
@@ -71,9 +84,9 @@ declare class CdkOption {
     /** The text used by the typeahead search. */
     label: i0.InputSignal<string | undefined>;
     /** The Option UIPattern. */
-    pattern: OptionPattern;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOption, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOption, "[cdkOption]", ["cdkOption"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    pattern: OptionPattern<V>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkOption<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkOption<any>, "[cdkOption]", ["cdkOption"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { CdkListbox, CdkOption };

package/listbox.d-QWPLmxRe.d.ts

@@ -0,0 +1,193 @@
+import * as i0 from '@angular/core';
+import { b as ListFocusItem, S as SignalLike, f as ListFocusInputs, i as ListFocus, L as ListNavigationItem, a as ListSelectionItem, h as ListSelection, g as ListNavigation, d as ListNavigationInputs, e as ListSelectionInputs, K as KeyboardEventManager, P as PointerEventManager } from './list-navigation.d-DfOSxsSp.js';
+
+/**
+ * Represents an item in a collection, such as a listbox option, than can be navigated to by
+ * typeahead.
+ */
+interface ListTypeaheadItem extends ListFocusItem {
+    /** The text used by the typeahead search. */
+    searchTerm: SignalLike<string>;
+}
+/**
+ * Represents the required inputs for a collection that contains items that can be navigated to by
+ * typeahead.
+ */
+interface ListTypeaheadInputs<T extends ListTypeaheadItem> extends ListFocusInputs<T> {
+    /** The amount of time before the typeahead search is reset. */
+    typeaheadDelay: SignalLike<number>;
+}
+/** Controls typeahead for a list of items. */
+declare class ListTypeahead<T extends ListTypeaheadItem> {
+    readonly inputs: ListTypeaheadInputs<T> & {
+        focusManager: ListFocus<T>;
+    };
+    /** A reference to the timeout for resetting the typeahead search. */
+    timeout?: ReturnType<typeof setTimeout> | undefined;
+    /** The focus controller of the parent list. */
+    focusManager: ListFocus<T>;
+    /** Whether the user is actively typing a typeahead search query. */
+    isTyping: i0.Signal<boolean>;
+    /** Keeps track of the characters that typeahead search is being called with. */
+    private _query;
+    /** The index where that the typeahead search was initiated from. */
+    private _startIndex;
+    constructor(inputs: ListTypeaheadInputs<T> & {
+        focusManager: ListFocus<T>;
+    });
+    /** Performs a typeahead search, appending the given character to the search string. */
+    search(char: string): boolean;
+    /**
+     * Returns the first item whose search term matches the
+     * current query starting from the the current anchor index.
+     */
+    private _getItem;
+}
+
+/**
+ * Represents the properties exposed by a listbox that need to be accessed by an option.
+ * This exists to avoid circular dependency errors between the listbox and option.
+ */
+interface ListboxPattern$1<V> {
+    focusManager: ListFocus<OptionPattern<V>>;
+    selection: ListSelection<OptionPattern<V>, V>;
+    navigation: ListNavigation<OptionPattern<V>>;
+}
+/** Represents the required inputs for an option in a listbox. */
+interface OptionInputs<V> extends ListNavigationItem, ListSelectionItem<V>, ListTypeaheadItem, ListFocusItem {
+    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+}
+/** Represents an option in a listbox. */
+declare class OptionPattern<V> {
+    /** A unique identifier for the option. */
+    id: SignalLike<string>;
+    /** The value of the option. */
+    value: SignalLike<V>;
+    /** The position of the option in the list. */
+    index: i0.Signal<number>;
+    /** Whether the option is active. */
+    active: i0.Signal<boolean>;
+    /** Whether the option is selected. */
+    selected: i0.Signal<boolean | undefined>;
+    /** Whether the option is disabled. */
+    disabled: SignalLike<boolean>;
+    /** The text used by the typeahead search. */
+    searchTerm: SignalLike<string>;
+    /** A reference to the parent listbox. */
+    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+    /** The tabindex of the option. */
+    tabindex: i0.Signal<0 | -1 | undefined>;
+    /** The html element that should receive focus. */
+    element: SignalLike<HTMLElement>;
+    constructor(args: OptionInputs<V>);
+}
+
+/** The selection operations that the listbox can perform. */
+interface SelectOptions {
+    toggle?: boolean;
+    selectOne?: boolean;
+    selectRange?: boolean;
+    anchor?: boolean;
+}
+/** Represents the required inputs for a listbox. */
+type ListboxInputs<V> = ListNavigationInputs<OptionPattern<V>> & ListSelectionInputs<OptionPattern<V>, V> & ListTypeaheadInputs<OptionPattern<V>> & ListFocusInputs<OptionPattern<V>> & {
+    readonly: SignalLike<boolean>;
+};
+/** Controls the state of a listbox. */
+declare class ListboxPattern<V> {
+    readonly inputs: ListboxInputs<V>;
+    /** Controls navigation for the listbox. */
+    navigation: ListNavigation<OptionPattern<V>>;
+    /** Controls selection for the listbox. */
+    selection: ListSelection<OptionPattern<V>, V>;
+    /** Controls typeahead for the listbox. */
+    typeahead: ListTypeahead<OptionPattern<V>>;
+    /** Controls focus for the listbox. */
+    focusManager: ListFocus<OptionPattern<V>>;
+    /** Whether the list is vertically or horizontally oriented. */
+    orientation: SignalLike<'vertical' | 'horizontal'>;
+    /** Whether the listbox is disabled. */
+    disabled: i0.Signal<boolean>;
+    /** Whether the listbox is readonly. */
+    readonly: SignalLike<boolean>;
+    /** The tabindex of the listbox. */
+    tabindex: i0.Signal<0 | -1>;
+    /** The id of the current active item. */
+    activedescendant: i0.Signal<string | undefined>;
+    /** Whether multiple items in the list can be selected at once. */
+    multi: SignalLike<boolean>;
+    /** The number of items in the listbox. */
+    setsize: i0.Signal<number>;
+    /** Whether the listbox selection follows focus. */
+    followFocus: i0.Signal<boolean>;
+    /** Whether the listbox should wrap. Used to disable wrapping while range selecting. */
+    wrap: i0.WritableSignal<boolean>;
+    /** The key used to navigate to the previous item in the list. */
+    prevKey: i0.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    /** The key used to navigate to the next item in the list. */
+    nextKey: i0.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    /** Represents the space key. Does nothing when the user is actively using typeahead. */
+    dynamicSpaceKey: i0.Signal<"" | " ">;
+    /** The regexp used to decide if a key should trigger typeahead. */
+    typeaheadRegexp: RegExp;
+    /**
+     * The uncommitted index for selecting a range of options.
+     *
+     * NOTE: This is subtly distinct from the "rangeStartIndex" in the ListSelection behavior.
+     * The anchorIndex does not necessarily represent the start of a range, but represents the most
+     * recent index where the user showed intent to begin a range selection. Usually, this is wherever
+     * the user most recently pressed the "Shift" key, but if the user presses shift + space to select
+     * from the anchor, the user is not intending to start a new range from this index.
+     *
+     * In other words, "rangeStartIndex" is only set when a user commits to starting a range selection
+     * while "anchorIndex" is set whenever a user indicates they may be starting a range selection.
+     */
+    anchorIndex: i0.WritableSignal<number>;
+    /** The keydown event manager for the listbox. */
+    keydown: i0.Signal<KeyboardEventManager<KeyboardEvent>>;
+    /** The pointerdown event manager for the listbox. */
+    pointerdown: i0.Signal<PointerEventManager<PointerEvent>>;
+    constructor(inputs: ListboxInputs<V>);
+    /** Handles keydown events for the listbox. */
+    onKeydown(event: KeyboardEvent): void;
+    onPointerdown(event: PointerEvent): void;
+    /** Navigates to the first option in the listbox. */
+    first(opts?: SelectOptions): void;
+    /** Navigates to the last option in the listbox. */
+    last(opts?: SelectOptions): void;
+    /** Navigates to the next option in the listbox. */
+    next(opts?: SelectOptions): void;
+    /** Navigates to the previous option in the listbox. */
+    prev(opts?: SelectOptions): void;
+    /** Navigates to the given item in the listbox. */
+    goto(event: PointerEvent, opts?: SelectOptions): void;
+    /** Handles typeahead search navigation for the listbox. */
+    search(char: string, opts?: SelectOptions): void;
+    /**
+     * Sets the listbox to it's default initial state.
+     *
+     * Sets the active index of the listbox to the first focusable selected
+     * item if one exists. Otherwise, sets focus to the first focusable item.
+     *
+     * This method should be called once the listbox and it's options are properly initialized,
+     * meaning the ListboxPattern and OptionPatterns should have references to each other before this
+     * is called.
+     */
+    setDefaultState(): void;
+    /**
+     * Safely performs a navigation operation.
+     *
+     * Handles conditionally disabling wrapping for when a navigation
+     * operation is occurring while the user is selecting a range of options.
+     *
+     * Handles boilerplate calling of focus & selection operations. Also ensures these
+     * additional operations are only called if the navigation operation moved focus to a new option.
+     */
+    private _navigate;
+    /** Handles updating selection for the listbox. */
+    private _updateSelection;
+    private _getItem;
+}
+
+export { ListboxPattern as a, OptionPattern as b };
+export type { ListboxInputs as L, OptionInputs as O };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/cdk-experimental",
-  "version": "20.0.0-next.1",
+  "version": "20.0.0-next.10",
   "description": "Experimental components for Angular CDK",
   "repository": {
     "type": "git",
@@ -12,9 +12,12 @@
   },
   "homepage": "https://github.com/angular/components#readme",
   "peerDependencies": {
-    "@angular/cdk": "20.0.0-next.1",
+    "@angular/cdk": "20.0.0-next.10",
     "@angular/core": "^20.0.0-0 || ^20.1.0-0 || ^20.2.0-0 || ^20.3.0-0 || ^21.0.0-0"
   },
+  "devDependencies": {
+    "@angular/cdk": "workspace:*"
+  },
   "dependencies": {
     "tslib": "^2.3.0"
   },
@@ -49,6 +52,10 @@
       "types": "./combobox/index.d.ts",
       "default": "./fesm2022/combobox.mjs"
     },
+    "./deferred-content": {
+      "types": "./deferred-content/index.d.ts",
+      "default": "./fesm2022/deferred-content.mjs"
+    },
     "./listbox": {
       "types": "./listbox/index.d.ts",
       "default": "./fesm2022/listbox.mjs"
@@ -69,6 +76,10 @@
       "types": "./table-scroll-container/index.d.ts",
       "default": "./fesm2022/table-scroll-container.mjs"
     },
+    "./tabs": {
+      "types": "./tabs/index.d.ts",
+      "default": "./fesm2022/tabs.mjs"
+    },
     "./ui-patterns": {
       "types": "./ui-patterns/index.d.ts",
       "default": "./fesm2022/ui-patterns.mjs"

package/popover-edit/index.d.ts

@@ -3,7 +3,7 @@ import * as i0 from '@angular/core';
 import { OnDestroy, OnInit, ElementRef, EventEmitter, NgZone, AfterViewInit, ViewContainerRef, TemplateRef, EmbeddedViewRef } from '@angular/core';
 import { Directionality } from '@angular/cdk/bidi';
 import * as i1 from '@angular/cdk/overlay';
-import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { OverlayRef } from '@angular/cdk/overlay';
 import { FocusTrapFactory, FocusTrap, InteractivityChecker } from '@angular/cdk/a11y';
 import { ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';
 
@@ -260,7 +260,6 @@ declare class EditServices {
     readonly focusDispatcher: FocusDispatcher;
     readonly focusTrapFactory: FocusTrapFactory;
     readonly ngZone: NgZone;
-    readonly overlay: Overlay;
     readonly scrollDispatcher: ScrollDispatcher;
     readonly viewportRuler: ViewportRuler;
     static ɵfac: i0.ɵɵFactoryDeclaration<EditServices, never>;
@@ -317,7 +316,8 @@ declare class CdkEditable implements AfterViewInit, OnDestroy {
     protected readonly ngZone: NgZone;
     private readonly _renderer;
     protected readonly destroyed: Subject<void>;
-    private _rendered;
+    private _rowsRendered;
+    private _rowMutationObserver;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;
@@ -335,6 +335,7 @@ declare class CdkPopoverEdit<C> implements AfterViewInit, OnDestroy {
     protected readonly services: EditServices;
     protected readonly elementRef: ElementRef<any>;
     protected readonly viewContainerRef: ViewContainerRef;
+    private _injector;
     /** The edit lens template shown over the cell on edit. */
     template: TemplateRef<any> | null;
     /**
@@ -445,4 +446,5 @@ declare const CELL_SELECTOR = ".cdk-cell, .mat-cell, td";
 /** closest implementation that is able to start from non-Element Nodes. */
 declare function closest(element: EventTarget | Element | null | undefined, selector: string): Element | null;
 
-export { CdkEditClose, CdkEditControl, CdkEditOpen, CdkEditRevert, CdkEditable, CdkPopoverEdit, type CdkPopoverEditColspan, CdkPopoverEditModule, CdkPopoverEditTabOut, CdkRowHoverContent, EditEventDispatcher, EditRef, type Entry, FocusDispatcher, FormValueContainer, HoverContentState, type PopoverEditClickOutBehavior, CELL_SELECTOR as _CELL_SELECTOR, closest as _closest };
+export { CdkEditClose, CdkEditControl, CdkEditOpen, CdkEditRevert, CdkEditable, CdkPopoverEdit, CdkPopoverEditModule, CdkPopoverEditTabOut, CdkRowHoverContent, EditEventDispatcher, EditRef, FocusDispatcher, FormValueContainer, HoverContentState, CELL_SELECTOR as _CELL_SELECTOR, closest as _closest };
+export type { CdkPopoverEditColspan, Entry, PopoverEditClickOutBehavior };

package/selection/index.d.ts

@@ -225,4 +225,5 @@ declare class CdkSelectionModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<CdkSelectionModule>;
 }
 
-export { CdkRowSelection, CdkSelectAll, CdkSelection, CdkSelectionColumn, CdkSelectionModule, CdkSelectionToggle, type SelectableWithIndex, type SelectionChange, SelectionSet };
+export { CdkRowSelection, CdkSelectAll, CdkSelection, CdkSelectionColumn, CdkSelectionModule, CdkSelectionToggle, SelectionSet };
+export type { SelectableWithIndex, SelectionChange };