@angular/aria 21.0.3 → 21.0.4

package/types/_combobox-chunk.d.ts

@@ -1,98 +1,194 @@
-import * as _angular_core from '@angular/core';
-import * as _angular_cdk_bidi from '@angular/cdk/bidi';
-import * as i1 from '@angular/aria/private';
-import { ComboboxListboxControls, ComboboxTreeControls, ComboboxDialogPattern, ComboboxPattern } from '@angular/aria/private';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { PointerEventManager } from './_pointer-event-manager-chunk.js';
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { ListItem } from './_list-chunk.js';
 
-/**
- * Identifies an element as a popup for an `ngCombobox`.
- *
- * This directive acts as a bridge, allowing the `ngCombobox` to discover and interact
- * with the underlying control (e.g., `ngListbox`, `ngTree`, or `ngComboboxDialog`) that
- * manages the options. It's primarily used as a host directive and is responsible for
- * exposing the popup's control pattern to the parent combobox.
- *
- * @developerPreview 21.0
- */
-declare class ComboboxPopup<V> {
-    /** The combobox that the popup belongs to. */
-    readonly combobox: Combobox<V> | null;
-    /** The popup controls exposed to the combobox. */
-    readonly _controls: _angular_core.WritableSignal<ComboboxListboxControls<any, V> | ComboboxTreeControls<any, V> | ComboboxDialogPattern | undefined>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComboboxPopup<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComboboxPopup<any>, "[ngComboboxPopup]", ["ngComboboxPopup"], {}, {}, never, never, true, never>;
-}
-
-/**
- * The container element that wraps a combobox input and popup, and orchestrates its behavior.
- *
- * The `ngCombobox` directive is the main entry point for creating a combobox and customizing its
- * behavior. It coordinates the interactions between the `ngComboboxInput` and the popup, which
- * is defined by a `ng-template` with the `ngComboboxPopupContainer` directive. If using the
- * `CdkOverlay`, the `cdkConnectedOverlay` directive takes the place of `ngComboboxPopupContainer`.
- *
- * ```html
- * <div ngCombobox filterMode="highlight">
- *   <input
- *     ngComboboxInput
- *     placeholder="Search for a state..."
- *     [(value)]="searchString"
- *   />
- *
- *   <ng-template ngComboboxPopupContainer>
- *     <div ngListbox [(value)]="selectedValue">
- *       @for (option of filteredOptions(); track option) {
- *         <div ngOption [value]="option" [label]="option">
- *           <span>{{option}}</span>
- *         </div>
- *       }
- *     </div>
- *   </ng-template>
- * </div>
- * ```
- *
- * @developerPreview 21.0
- */
-declare class Combobox<V> {
-    /** The directionality (LTR / RTL) context for the application (or a subtree of it). */
-    private readonly _directionality;
-    /** A signal wrapper for directionality. */
-    protected textDirection: _angular_core.Signal<_angular_cdk_bidi.Direction>;
-    /** The element that the combobox is attached to. */
-    private readonly _elementRef;
-    /** A reference to the combobox element. */
-    readonly element: HTMLElement;
-    /** The DeferredContentAware host directive. */
-    private readonly _deferredContentAware;
-    /** The combobox popup. */
-    readonly popup: _angular_core.Signal<ComboboxPopup<V> | undefined>;
-    /**
-     * The filter mode for the combobox.
-     * - `manual`: The consumer is responsible for filtering the options.
-     * - `auto-select`: The combobox automatically selects the first matching option.
-     * - `highlight`: The combobox highlights matching text in the options without changing selection.
-     */
-    filterMode: _angular_core.InputSignal<"manual" | "auto-select" | "highlight">;
+/** Represents the required inputs for a combobox. */
+interface ComboboxInputs<T extends ListItem<V>, V> {
+    /** The controls for the popup associated with the combobox. */
+    popupControls: SignalLike<ComboboxListboxControls<T, V> | ComboboxTreeControls<T, V> | ComboboxDialogPattern | undefined>;
+    /** The HTML input element that serves as the combobox input. */
+    inputEl: SignalLike<HTMLInputElement | undefined>;
+    /** The HTML element that serves as the combobox container. */
+    containerEl: SignalLike<HTMLElement | undefined>;
+    /** The filtering mode for the combobox. */
+    filterMode: SignalLike<'manual' | 'auto-select' | 'highlight'>;
+    /** The current value of the combobox. */
+    inputValue?: WritableSignalLike<string>;
+    /** The value of the first matching item in the popup. */
+    firstMatch: SignalLike<V | undefined>;
     /** Whether the combobox is disabled. */
-    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    disabled: SignalLike<boolean>;
     /** Whether the combobox is read-only. */
-    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** The value of the first matching item in the popup. */
-    readonly firstMatch: _angular_core.InputSignal<V | undefined>;
+    readonly: SignalLike<boolean>;
+    /** Whether the combobox is in a right-to-left context. */
+    textDirection: SignalLike<'rtl' | 'ltr'>;
+    /** Whether the combobox is always expanded. */
+    alwaysExpanded: SignalLike<boolean>;
+}
+/** An interface that allows combobox popups to expose the necessary controls for the combobox. */
+interface ComboboxListboxControls<T extends ListItem<V>, V> {
+    /** A unique identifier for the popup. */
+    id: () => string;
+    /** The ARIA role for the popup. */
+    role: SignalLike<'listbox' | 'tree' | 'grid'>;
+    /** Whether multiple items in the popup can be selected at once. */
+    multi: SignalLike<boolean>;
+    /** The ID of the active item in the popup. */
+    activeId: SignalLike<string | undefined>;
+    /** The list of items in the popup. */
+    items: SignalLike<T[]>;
+    /** Navigates to the given item in the popup. */
+    focus: (item: T, opts?: {
+        focusElement?: boolean;
+    }) => void;
+    /** Navigates to the next item in the popup. */
+    next: () => void;
+    /** Navigates to the previous item in the popup. */
+    prev: () => void;
+    /** Navigates to the first item in the popup. */
+    first: () => void;
+    /** Navigates to the last item in the popup. */
+    last: () => void;
+    /** Selects the current item in the popup. */
+    select: (item?: T) => void;
+    /** Toggles the selection state of the given item in the popup. */
+    toggle: (item?: T) => void;
+    /** Clears the selection state of the popup. */
+    clearSelection: () => void;
+    /** Removes focus from any item in the popup. */
+    unfocus: () => void;
+    /** Returns the item corresponding to the given event. */
+    getItem: (e: PointerEvent) => T | undefined;
+    /** Returns the currently active (focused) item in the popup. */
+    getActiveItem: () => T | undefined;
+    /** Returns the currently selected items in the popup. */
+    getSelectedItems: () => T[];
+    /** Sets the value of the combobox based on the selected item. */
+    setValue: (value: V | undefined) => void;
+}
+interface ComboboxTreeControls<T extends ListItem<V>, V> extends ComboboxListboxControls<T, V> {
+    /** Whether the currently active item in the popup is collapsible. */
+    isItemCollapsible: () => boolean;
+    /** Expands the currently active item in the popup. */
+    expandItem: () => void;
+    /** Collapses the currently active item in the popup. */
+    collapseItem: () => void;
+    /** Checks if the currently active item in the popup is expandable. */
+    isItemExpandable: (item?: T) => boolean;
+    /** Expands all nodes in the tree. */
+    expandAll: () => void;
+    /** Collapses all nodes in the tree. */
+    collapseAll: () => void;
+    /** Toggles the expansion state of the currently active item in the popup. */
+    toggleExpansion: (item?: T) => void;
+    /** Whether the current active item is selectable. */
+    isItemSelectable: (item?: T) => boolean;
+}
+/** Controls the state of a combobox. */
+declare class ComboboxPattern<T extends ListItem<V>, V> {
+    readonly inputs: ComboboxInputs<T, V>;
     /** Whether the combobox is expanded. */
-    readonly expanded: _angular_core.Signal<boolean>;
-    /** Whether the combobox popup should always be expanded, regardless of user interaction. */
-    readonly alwaysExpanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Input element connected to the combobox, if any. */
-    readonly inputElement: _angular_core.Signal<HTMLInputElement | undefined>;
-    /** The combobox ui pattern. */
-    readonly _pattern: ComboboxPattern<any, V>;
-    constructor();
-    /** Opens the combobox to the selected item. */
-    open(): void;
+    expanded: WritableSignalLike<boolean>;
+    /** Whether the combobox is disabled. */
+    disabled: () => boolean;
+    /** The ID of the active item in the combobox. */
+    activeDescendant: SignalLike<string | null>;
+    /** The currently highlighted item in the combobox. */
+    highlightedItem: WritableSignalLike<T | undefined>;
+    /** Whether the most recent input event was a deletion. */
+    isDeleting: boolean;
+    /** Whether the combobox is focused. */
+    isFocused: WritableSignalLike<boolean>;
+    /** Whether the combobox has ever been focused. */
+    hasBeenFocused: WritableSignalLike<boolean>;
+    /** The key used to navigate to the previous item in the list. */
+    expandKey: SignalLike<"ArrowLeft" | "ArrowRight">;
+    /** The key used to navigate to the next item in the list. */
+    collapseKey: SignalLike<"ArrowLeft" | "ArrowRight">;
+    /** The ID of the popup associated with the combobox. */
+    popupId: SignalLike<string | null>;
+    /** The autocomplete behavior of the combobox. */
+    autocomplete: SignalLike<"both" | "list">;
+    /** The ARIA role of the popup associated with the combobox. */
+    hasPopup: SignalLike<"listbox" | "tree" | "grid" | "dialog" | null>;
+    /** Whether the combobox is read-only. */
+    readonly: SignalLike<true | null>;
+    /** Returns the listbox controls for the combobox. */
+    listControls: () => ComboboxListboxControls<T, V> | null | undefined;
+    /** Returns the tree controls for the combobox. */
+    treeControls: () => ComboboxTreeControls<T, V> | null;
+    /** The keydown event manager for the combobox. */
+    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    /** The click event manager for the combobox. */
+    click: SignalLike<PointerEventManager<PointerEvent>>;
+    constructor(inputs: ComboboxInputs<T, V>);
+    /** Handles keydown events for the combobox. */
+    onKeydown(event: KeyboardEvent): void;
+    /** Handles click events for the combobox. */
+    onClick(event: MouseEvent): void;
+    /** Handles input events for the combobox. */
+    onInput(event: Event): void;
+    /** Handles focus in events for the combobox. */
+    onFocusIn(): void;
+    /** Handles focus out events for the combobox. */
+    onFocusOut(event: FocusEvent): void;
+    /** The first matching item in the combobox. */
+    firstMatch: SignalLike<T | undefined>;
+    /** Handles filtering logic for the combobox. */
+    onFilter(): void;
+    /** Highlights the currently selected item in the combobox. */
+    highlight(): void;
     /** Closes the combobox. */
-    close(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Combobox<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Combobox<any>, "[ngCombobox]", ["ngCombobox"], { "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "firstMatch": { "alias": "firstMatch"; "required": false; "isSignal": true; }; "alwaysExpanded": { "alias": "alwaysExpanded"; "required": false; "isSignal": true; }; }, {}, ["popup"], never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+    close(opts?: {
+        reset: boolean;
+    }): void;
+    /** Opens the combobox. */
+    open(nav?: {
+        first?: boolean;
+        last?: boolean;
+        selected?: boolean;
+    }): void;
+    /** Navigates to the next focusable item in the combobox popup. */
+    next(): void;
+    /** Navigates to the previous focusable item in the combobox popup. */
+    prev(): void;
+    /** Navigates to the first focusable item in the combobox popup. */
+    first(): void;
+    /** Navigates to the last focusable item in the combobox popup. */
+    last(): void;
+    /** Collapses the currently focused item in the combobox. */
+    collapseItem(): void;
+    /** Expands the currently focused item in the combobox. */
+    expandItem(): void;
+    /** Selects an item in the combobox popup. */
+    select(opts?: {
+        item?: T;
+        commit?: boolean;
+        close?: boolean;
+    }): void;
+    /** Updates the value of the input based on the currently selected item. */
+    commit(): void;
+    /** Navigates and handles additional actions based on filter mode. */
+    private _navigate;
+}
+declare class ComboboxDialogPattern {
+    readonly inputs: {
+        combobox: ComboboxPattern<any, any>;
+        element: SignalLike<HTMLDialogElement>;
+        id: SignalLike<string>;
+    };
+    id: () => string;
+    role: () => "dialog";
+    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    constructor(inputs: {
+        combobox: ComboboxPattern<any, any>;
+        element: SignalLike<HTMLDialogElement>;
+        id: SignalLike<string>;
+    });
+    onKeydown(event: KeyboardEvent): void;
+    onClick(event: MouseEvent): void;
 }
 
-export { Combobox, ComboboxPopup };
+export { ComboboxDialogPattern, ComboboxPattern };
+export type { ComboboxInputs, ComboboxListboxControls, ComboboxTreeControls };

package/types/_deferred-content-chunk.d.ts

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+/**
+ * A container directive controls the visibility of its content.
+ */
+declare class DeferredContentAware {
+    readonly contentVisible: _angular_core.WritableSignal<boolean>;
+    readonly preserveContent: _angular_core.ModelSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContentAware, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContentAware, never, never, { "preserveContent": { "alias": "preserveContent"; "required": false; "isSignal": true; }; }, { "preserveContent": "preserveContentChange"; }, never, never, true, never>;
+}
+/**
+ * DeferredContent loads/unloads the content based on the visibility.
+ * The visibilty signal is sent from a parent directive implements
+ * DeferredContentAware.
+ *
+ * Use this directive as a host directive. For example:
+ *
+ * ```ts
+ *   @Directive({
+ *     selector: 'ng-template[AccordionContent]',
+ *     hostDirectives: [DeferredContent],
+ *   })
+ *   class AccordionContent {}
+ * ```
+ */
+declare class DeferredContent implements OnDestroy {
+    private readonly _deferredContentAware;
+    private readonly _templateRef;
+    private readonly _viewContainerRef;
+    private _currentViewRef;
+    private _isRendered;
+    readonly deferredContentAware: _angular_core.WritableSignal<DeferredContentAware | null>;
+    constructor();
+    ngOnDestroy(): void;
+    private _destroyContent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeferredContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DeferredContent, never, never, {}, {}, never, never, true, never>;
+}
+
+export { DeferredContent, DeferredContentAware };

package/types/_expansion-chunk.d.ts

@@ -0,0 +1,40 @@
+import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+
+/** Represents an item that can be expanded or collapsed. */
+interface ExpansionItem {
+    /** Whether the item is expandable. */
+    expandable: SignalLike<boolean>;
+    /** Whether the item is expanded. */
+    expanded: WritableSignalLike<boolean>;
+    /** Whether the expansion is disabled. */
+    disabled: SignalLike<boolean>;
+}
+/** Represents the required inputs for an expansion behavior. */
+interface ListExpansionInputs {
+    /** Whether multiple items can be expanded at once. */
+    multiExpandable: SignalLike<boolean>;
+    /** An array of expansion items. */
+    items: SignalLike<ExpansionItem[]>;
+    /** Whether all expansions are disabled. */
+    disabled: SignalLike<boolean>;
+}
+/** Manages the expansion state of a list of items. */
+declare class ListExpansion {
+    readonly inputs: ListExpansionInputs;
+    constructor(inputs: ListExpansionInputs);
+    /** Opens the specified item. */
+    open(item: ExpansionItem): boolean;
+    /** Closes the specified item. */
+    close(item: ExpansionItem): boolean;
+    /** Toggles the expansion state of the specified item. */
+    toggle(item: ExpansionItem): boolean;
+    /** Opens all focusable items in the list. */
+    openAll(): void;
+    /** Closes all focusable items in the list. */
+    closeAll(): void;
+    /** Checks whether the specified item is expandable / collapsible. */
+    isExpandable(item: ExpansionItem): boolean;
+}
+
+export { ListExpansion };
+export type { ExpansionItem, ListExpansionInputs };

package/types/_grid-chunk.d.ts

@@ -1,6 +1,6 @@
-import * as _angular_core from '@angular/core';
-import { WritableSignal, Signal } from '@angular/core';
-import { SignalLike, WritableSignalLike, ListNavigationItem, KeyboardEventManager, ListNavigationInputs, ListFocus, ListNavigation, PointerEventManager } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike, ListNavigationItem, ListNavigationInputs, ListFocus, ListNavigation } from './_list-navigation-chunk.js';
+import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
+import { PointerEventManager } from './_pointer-event-manager-chunk.js';
 
 /** Represents coordinates in a grid. */
 interface RowCol {
@@ -27,9 +27,9 @@ declare class GridData<T extends BaseGridCell> {
     /** The two-dimensional array of cells that represents the grid. */
     readonly cells: SignalLike<T[][]>;
     /** The maximum number of rows in the grid, accounting for row spans. */
-    readonly maxRowCount: _angular_core.Signal<number>;
+    readonly maxRowCount: SignalLike<number>;
     /** The maximum number of columns in the grid, accounting for column spans. */
-    readonly maxColCount: _angular_core.Signal<number>;
+    readonly maxColCount: SignalLike<number>;
     /** A map from a cell to its primary and spanned coordinates. */
     private readonly _coordsMap;
     /** A map from a coordinate string to the cell at that coordinate. */
@@ -80,11 +80,11 @@ interface GridFocusDeps<T extends GridFocusCell> {
 declare class GridFocus<T extends GridFocusCell> {
     readonly inputs: GridFocusInputs & GridFocusDeps<T>;
     /** The current active cell. */
-    readonly activeCell: WritableSignal<T | undefined>;
+    readonly activeCell: WritableSignalLike<T | undefined>;
     /** The current active cell coordinates. */
-    readonly activeCoords: WritableSignal<RowCol>;
+    readonly activeCoords: WritableSignalLike<RowCol>;
     /** Whether the grid active state is empty (no active cell or coordinates). */
-    readonly stateEmpty: _angular_core.Signal<boolean>;
+    readonly stateEmpty: SignalLike<boolean>;
     /**
      * Whether the grid focus state is stale.
      *
@@ -92,13 +92,13 @@ declare class GridFocus<T extends GridFocusCell> {
      * current grid data, for example if the underlying cells have changed.
      * A stale state should be re-initialized.
      */
-    readonly stateStale: _angular_core.Signal<boolean>;
+    readonly stateStale: SignalLike<boolean>;
     /** The id of the current active cell, for ARIA activedescendant. */
-    readonly activeDescendant: _angular_core.Signal<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** Whether the grid is in a disabled state. */
-    readonly gridDisabled: _angular_core.Signal<boolean>;
+    readonly gridDisabled: SignalLike<boolean>;
     /** The tab index for the grid container. */
-    readonly gridTabIndex: _angular_core.Signal<0 | -1>;
+    readonly gridTabIndex: SignalLike<0 | -1>;
     constructor(inputs: GridFocusInputs & GridFocusDeps<T>);
     /** Returns the tab index for the given grid cell cell. */
     getCellTabIndex(cell: T): -1 | 0;
@@ -263,11 +263,11 @@ declare class Grid<T extends GridCell> {
     /** Controls selection for the grid. */
     readonly selectionBehavior: GridSelection<T>;
     /** The anchor point for range selection, linked to the active coordinates. */
-    readonly selectionAnchor: _angular_core.WritableSignal<RowCol>;
+    readonly selectionAnchor: WritableSignalLike<RowCol>;
     /** The cell at the selection anchor. */
-    readonly selectionAnchorCell: _angular_core.Signal<T | undefined>;
+    readonly selectionAnchorCell: SignalLike<T | undefined>;
     /** Whether a range selection has settled. */
-    readonly selectionStabled: _angular_core.WritableSignal<boolean>;
+    readonly selectionStabled: WritableSignalLike<boolean>;
     /** Whether all selectable cells are selected. */
     readonly allSelected: SignalLike<boolean>;
     /** The tab index for the grid container. */
@@ -353,23 +353,23 @@ declare class GridCellWidgetPattern implements ListNavigationItem {
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
     /** The element that should receive focus. */
-    readonly widgetHost: Signal<HTMLElement>;
+    readonly widgetHost: SignalLike<HTMLElement>;
     /** The index of the widget within the cell. */
-    readonly index: Signal<number>;
+    readonly index: SignalLike<number>;
     /** Whether the widget is disabled. */
-    readonly disabled: Signal<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The tab index for the widget. */
-    readonly tabIndex: Signal<-1 | 0>;
+    readonly tabIndex: SignalLike<-1 | 0>;
     /** Whether the widget is the active item in the widget list. */
-    readonly active: Signal<boolean>;
+    readonly active: SignalLike<boolean>;
     /** Whether the widget is currently activated. */
-    readonly isActivated: WritableSignal<boolean>;
+    readonly isActivated: WritableSignalLike<boolean>;
     /** The last event that caused the widget to be activated. */
-    readonly lastActivateEvent: WritableSignal<KeyboardEvent | FocusEvent | undefined>;
+    readonly lastActivateEvent: WritableSignalLike<KeyboardEvent | FocusEvent | undefined>;
     /** The last event that caused the widget to be deactivated. */
-    readonly lastDeactivateEvent: WritableSignal<KeyboardEvent | FocusEvent | undefined>;
+    readonly lastDeactivateEvent: WritableSignalLike<KeyboardEvent | FocusEvent | undefined>;
     /** The keyboard event manager for the widget. */
-    readonly keydown: Signal<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellWidgetInputs);
     /** Handles keydown events for the widget. */
     onKeydown(event: KeyboardEvent): void;
@@ -408,7 +408,7 @@ declare class GridCellPattern implements GridCell {
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
     /** Whether the cell has focus. */
-    readonly isFocused: WritableSignal<boolean>;
+    readonly isFocused: WritableSignalLike<boolean>;
     /** Whether the cell is selected. */
     readonly selected: WritableSignalLike<boolean>;
     /** Whether the cell is selectable. */
@@ -452,11 +452,11 @@ declare class GridCellPattern implements GridCell {
     /** Whether the cell or widget inside the cell is activated. */
     readonly isActivated: SignalLike<boolean>;
     /** The key used to navigate to the previous widget. */
-    readonly prevKey: _angular_core.Signal<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
     /** The key used to navigate to the next widget. */
-    readonly nextKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
     /** The keyboard event manager for the cell. */
-    readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellInputs);
     /** Handles keydown events for the cell. */
     onKeydown(event: KeyboardEvent): void;
@@ -518,35 +518,35 @@ declare class GridPattern {
     /** The underlying grid behavior that this pattern is built on. */
     readonly gridBehavior: Grid<GridCellPattern>;
     /** The cells in the grid. */
-    readonly cells: _angular_core.Signal<GridCellPattern[][]>;
+    readonly cells: SignalLike<GridCellPattern[][]>;
     /** The tab index for the grid. */
-    readonly tabIndex: _angular_core.Signal<0 | -1>;
+    readonly tabIndex: SignalLike<0 | -1>;
     /** Whether the grid is disabled. */
-    readonly disabled: _angular_core.Signal<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The ID of the currently active descendant cell. */
-    readonly activeDescendant: _angular_core.Signal<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** The currently active cell. */
-    readonly activeCell: _angular_core.Signal<GridCellPattern | undefined>;
+    readonly activeCell: SignalLike<GridCellPattern | undefined>;
     /** The current selection anchor cell. */
     readonly anchorCell: SignalLike<GridCellPattern | undefined>;
     /** Whether to pause grid navigation and give the keyboard control to cell or widget. */
     readonly pauseNavigation: SignalLike<boolean>;
     /** Whether the focus is in the grid. */
-    readonly isFocused: _angular_core.WritableSignal<boolean>;
+    readonly isFocused: WritableSignalLike<boolean>;
     /** Whether the grid has been focused once. */
-    readonly hasBeenFocused: _angular_core.WritableSignal<boolean>;
+    readonly hasBeenFocused: WritableSignalLike<boolean>;
     /** Whether the user is currently dragging to select a range of cells. */
-    readonly dragging: _angular_core.WritableSignal<boolean>;
+    readonly dragging: WritableSignalLike<boolean>;
     /** The key for navigating to the previous column. */
-    readonly prevColKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft">;
+    readonly prevColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
     /** The key for navigating to the next column. */
-    readonly nextColKey: _angular_core.Signal<"ArrowRight" | "ArrowLeft">;
+    readonly nextColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
     /** The keydown event manager for the grid. */
-    readonly keydown: _angular_core.Signal<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the grid. */
-    readonly pointerdown: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    readonly pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
     /** The pointerup event manager for the grid. */
-    readonly pointerup: _angular_core.Signal<PointerEventManager<PointerEvent>>;
+    readonly pointerup: SignalLike<PointerEventManager<PointerEvent>>;
     /** Indicates maybe the losing focus is caused by row/cell deletion. */
     private readonly _maybeDeletion;
     /** Indicates the losing focus is certainly caused by row/cell deletion. */

package/types/_keyboard-event-manager-chunk.d.ts

@@ -0,0 +1,68 @@
+import { SignalLike } from './_list-navigation-chunk.js';
+
+/**
+ * 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 Modifier {
+    None = 0,
+    Ctrl = 1,
+    Shift = 2,
+    Alt = 4,
+    Meta = 8,
+    Any = "Any"
+}
+type ModifierInputs = Modifier | Modifier[];
+/**
+ * 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>, options?: Partial<EventHandlerOptions>): this;
+    /**  Configures this event manager to handle events with a specific modifer and key combination. */
+    on(modifiers: ModifierInputs, key: KeyCode, handler: EventHandler<T>, options?: Partial<EventHandlerOptions>): this;
+    private _normalizeInputs;
+    private _isMatch;
+}
+
+export { EventManager, KeyboardEventManager };
+export type { EventHandler, EventHandlerOptions, ModifierInputs };