@angular/aria 22.0.0-next.3 → 22.0.0-next.5

package/types/_grid-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike, WritableSignalLike, ListNavigationItem, ListNavigationInputs, ListFocus, ListNavigation } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
 import { PointerEventManager } from './_pointer-event-manager-chunk.js';
 
@@ -335,7 +335,9 @@ declare class Grid<T extends GridCell> {
 }
 
 /** The inputs for the `GridCellWidgetPattern`. */
-interface GridCellWidgetInputs extends Omit<ListNavigationItem, 'index'> {
+interface GridCellWidgetInputs {
+    /** Whether the widget is disabled. */
+    disabled: SignalLike<boolean>;
     /** The `GridCellPattern` that this widget belongs to. */
     cell: SignalLike<GridCellPattern>;
     /** The html element that should receive focus. */
@@ -346,21 +348,17 @@ interface GridCellWidgetInputs extends Omit<ListNavigationItem, 'index'> {
     focusTarget: SignalLike<HTMLElement | undefined>;
 }
 /** The UI pattern for a widget inside a grid cell. */
-declare class GridCellWidgetPattern implements ListNavigationItem {
+declare class GridCellWidgetPattern {
     readonly inputs: GridCellWidgetInputs;
-    /** A unique identifier for the widget. */
-    readonly id: SignalLike<string>;
     /** The html element that should receive focus. */
     readonly element: SignalLike<HTMLElement>;
     /** The element that should receive focus. */
     readonly widgetHost: SignalLike<HTMLElement>;
-    /** The index of the widget within the cell. */
-    readonly index: SignalLike<number>;
     /** Whether the widget is disabled. */
     readonly disabled: SignalLike<boolean>;
     /** The tab index for the widget. */
     readonly tabIndex: SignalLike<-1 | 0>;
-    /** Whether the widget is the active item in the widget list. */
+    /** Whether the widget is the active widget in the cell. */
     readonly active: SignalLike<boolean>;
     /** Whether the widget is currently activated. */
     readonly isActivated: WritableSignalLike<boolean>;
@@ -386,13 +384,13 @@ declare class GridCellWidgetPattern implements ListNavigationItem {
 }
 
 /** The inputs for the `GridCellPattern`. */
-interface GridCellInputs extends GridCell, Omit<ListNavigationInputs<GridCellWidgetPattern>, 'focusMode' | 'items' | 'activeItem' | 'softDisabled' | 'element'> {
+interface GridCellInputs extends GridCell {
     /** The `GridPattern` that this cell belongs to. */
     grid: SignalLike<GridPattern>;
     /** The `GridRowPattern` that this cell belongs to. */
     row: SignalLike<GridRowPattern>;
-    /** The widget patterns contained within this cell, if any. */
-    widgets: SignalLike<GridCellWidgetPattern[]>;
+    /** The widget pattern contained within this cell, if any. */
+    widget: SignalLike<GridCellWidgetPattern | undefined>;
     /** The index of this cell's row within the grid. */
     rowIndex: SignalLike<number | undefined>;
     /** The index of this cell's column within the grid. */
@@ -433,30 +431,10 @@ declare class GridCellPattern implements GridCell {
     private readonly _tabIndex;
     /** The tab index for the cell. If the cell contains a widget, the cell's tab index is -1. */
     readonly tabIndex: SignalLike<-1 | 0>;
-    /** Whether the cell contains a single widget. */
-    readonly singleWidgetMode: SignalLike<boolean>;
-    /** Whether the cell contains multiple widgets. */
-    readonly multiWidgetMode: SignalLike<boolean>;
-    /** Whether navigation between widgets is disabled. */
-    readonly navigationDisabled: SignalLike<boolean>;
-    /** The focus behavior for the widgets in the cell. */
-    readonly focusBehavior: ListFocus<GridCellWidgetPattern>;
-    /** The navigation behavior for the widgets in the cell. */
-    readonly navigationBehavior: ListNavigation<GridCellWidgetPattern>;
-    /** The currently active widget in the cell. */
-    readonly activeWidget: WritableSignalLike<GridCellWidgetPattern | undefined>;
-    /** Whether navigation between widgets is activated. */
-    readonly navigationActivated: WritableSignalLike<boolean>;
-    /** Whether any widget within the cell is activated. */
-    readonly widgetActivated: SignalLike<boolean>;
+    /** The widget in the cell. */
+    readonly widget: SignalLike<GridCellWidgetPattern | undefined>;
     /** 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: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
-    /** The key used to navigate to the next widget. */
-    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
-    /** The keyboard event manager for the cell. */
-    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: GridCellInputs);
     /** Handles keydown events for the cell. */
     onKeydown(event: KeyboardEvent): void;
@@ -468,12 +446,6 @@ declare class GridCellPattern implements GridCell {
     focus(): void;
     /** Gets the tab index for the widget within the cell. */
     widgetTabIndex(): -1 | 0;
-    /** Starts navigation between widgets. */
-    startNavigation(): void;
-    /** Stops navigation between widgets and restores focus to the cell. */
-    stopNavigation(): void;
-    /** Executes a navigation operation and focuses the new active widget. */
-    private _advance;
 }
 
 /** The inputs for the `GridRowPattern`. */
@@ -507,8 +479,6 @@ interface GridInputs extends Omit<GridInputs$1<GridCellPattern>, 'cells'> {
     multi: SignalLike<boolean>;
     /** The selection strategy used by the grid. */
     selectionMode: SignalLike<'follow' | 'explicit'>;
-    /** Whether enable range selection. */
-    enableRangeSelection: SignalLike<boolean>;
     /** A function that returns the grid cell associated with a given element. */
     getCell: (e: Element | null) => GridCellPattern | undefined;
 }
@@ -535,22 +505,18 @@ declare class GridPattern {
     readonly pauseNavigation: SignalLike<boolean>;
     /** Whether the focus is in the grid. */
     readonly isFocused: WritableSignalLike<boolean>;
-    /** Whether the grid has been focused once. */
-    readonly hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the grid has received focus once. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** Whether the user is currently dragging to select a range of cells. */
     readonly dragging: WritableSignalLike<boolean>;
     /** The key for navigating to the previous column. */
     readonly prevColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
     /** The key for navigating to the next column. */
     readonly nextColKey: SignalLike<"ArrowRight" | "ArrowLeft">;
-    /** Whether the grid pattern is currently accepting `pointermove` events. */
-    readonly acceptsPointerMove: SignalLike<boolean>;
     /** The keydown event manager for the grid. */
     readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     /** The pointerdown event manager for the grid. */
     readonly pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
-    /** The pointerup event manager for the grid. */
-    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. */
@@ -562,10 +528,6 @@ declare class GridPattern {
     onKeydown(event: KeyboardEvent): void;
     /** Handles pointerdown events on the grid. */
     onPointerdown(event: PointerEvent): void;
-    /** Handles pointermove events on the grid. */
-    onPointermove(event: PointerEvent): void;
-    /** Handles pointerup events on the grid. */
-    onPointerup(event: PointerEvent): void;
     /** Handles focusin events on the grid. */
     onFocusIn(event: FocusEvent): void;
     /** Handles focusout events on the grid. */

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

@@ -1,4 +1,4 @@
-import { SignalLike } from './_list-navigation-chunk.js';
+import { SignalLike } from './_signal-like-chunk.js';
 
 /**
  * Options that are applicable to all event handlers.
@@ -56,7 +56,7 @@ type KeyCode = string | SignalLike<string> | RegExp;
  * propagation and prevents default on all events it handles.
  */
 declare class KeyboardEventManager<T extends KeyboardEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
+    readonly 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. */

package/types/_list-chunk.d.ts

@@ -1,4 +1,5 @@
-import { ListFocusItem, SignalLike, ListFocusInputs, WritableSignalLike, ListFocus, ListNavigationItem, ListNavigationInputs, ListNavigation } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
+import { ListFocusItem, ListFocusInputs, ListFocus, ListNavigationItem, ListNavigationInputs, ListNavigation } from './_list-navigation-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, that can be selected. */
 interface ListSelectionItem<V> extends ListFocusItem {
@@ -22,11 +23,11 @@ declare class ListSelection<T extends ListSelectionItem<V>, V> {
         focusManager: ListFocus<T>;
     };
     /** The start index to use for range selection. */
-    rangeStartIndex: WritableSignalLike<number>;
+    readonly rangeStartIndex: WritableSignalLike<number>;
     /** The end index to use for range selection. */
-    rangeEndIndex: WritableSignalLike<number>;
+    readonly rangeEndIndex: WritableSignalLike<number>;
     /** The currently selected items. */
-    selectedItems: SignalLike<T[]>;
+    readonly selectedItems: SignalLike<T[]>;
     constructor(inputs: ListSelectionInputs<T, V> & {
         focusManager: ListFocus<T>;
     });
@@ -90,13 +91,13 @@ declare class ListTypeahead<T extends ListTypeaheadItem> {
     /** 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>;
+    readonly focusManager: ListFocus<T>;
     /** Whether the user is actively typing a typeahead search query. */
-    isTyping: SignalLike<boolean>;
+    readonly isTyping: SignalLike<boolean>;
     /** Keeps track of the characters that typeahead search is being called with. */
-    private _query;
+    private readonly _query;
     /** The index where that the typeahead search was initiated from. */
-    private _startIndex;
+    private readonly _startIndex;
     constructor(inputs: ListTypeaheadInputs<T> & {
         focusManager: ListFocus<T>;
     });
@@ -127,21 +128,21 @@ type ListInputs<T extends ListItem<V>, V> = ListFocusInputs<T> & ListNavigationI
 declare class List<T extends ListItem<V>, V> {
     readonly inputs: ListInputs<T, V>;
     /** Controls navigation for the list. */
-    navigationBehavior: ListNavigation<T>;
+    readonly navigationBehavior: ListNavigation<T>;
     /** Controls selection for the list. */
-    selectionBehavior: ListSelection<T, V>;
+    readonly selectionBehavior: ListSelection<T, V>;
     /** Controls typeahead for the list. */
-    typeaheadBehavior: ListTypeahead<T>;
+    readonly typeaheadBehavior: ListTypeahead<T>;
     /** Controls focus for the list. */
-    focusBehavior: ListFocus<T>;
+    readonly focusBehavior: ListFocus<T>;
     /** Whether the list is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The id of the current active item. */
-    activeDescendant: SignalLike<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** The tab index of the list. */
-    tabIndex: SignalLike<0 | -1>;
+    readonly tabIndex: SignalLike<0 | -1>;
     /** The index of the currently active item in the list. */
-    activeIndex: SignalLike<number>;
+    readonly activeIndex: SignalLike<number>;
     /**
      * The uncommitted index for selecting a range of options.
      *
@@ -154,9 +155,9 @@ declare class List<T extends ListItem<V>, V> {
      * 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.
      */
-    private _anchorIndex;
+    private readonly _anchorIndex;
     /** Whether the list should wrap. Used to disable wrapping while range selecting. */
-    private _wrap;
+    private readonly _wrap;
     constructor(inputs: ListInputs<T, V>);
     /** Returns the tab index for the given item. */
     getItemTabindex(item: T): 0 | -1;

package/types/_list-navigation-chunk.d.ts

@@ -1,14 +1,4 @@
-type SignalLike<T> = () => T;
-interface WritableSignalLike<T> extends SignalLike<T> {
-    set(value: T): void;
-    update(updateFn: (value: T) => T): void;
-    asReadonly(): SignalLike<T>;
-}
-/** Converts a getter setter style signal to a WritableSignalLike. */
-declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
-declare function computed<T>(computation: () => T): SignalLike<T>;
-declare function signal<T>(initialValue: T): WritableSignalLike<T>;
-declare function linkedSignal<T>(sourceFn: () => T): WritableSignalLike<T>;
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 
 /** Represents an item in a collection, such as a listbox option, than may receive focus. */
 interface ListFocusItem {
@@ -38,11 +28,11 @@ interface ListFocusInputs<T extends ListFocusItem> {
 declare class ListFocus<T extends ListFocusItem> {
     readonly inputs: ListFocusInputs<T>;
     /** The last item that was active. */
-    prevActiveItem: WritableSignalLike<T | undefined>;
+    readonly prevActiveItem: WritableSignalLike<T | undefined>;
     /** The index of the last item that was active. */
-    prevActiveIndex: SignalLike<number>;
+    readonly prevActiveIndex: SignalLike<number>;
     /** The current active index in the list. */
-    activeIndex: SignalLike<number>;
+    readonly activeIndex: SignalLike<number>;
     constructor(inputs: ListFocusInputs<T>);
     /** Whether the list is in a disabled state. */
     isListDisabled(): boolean;
@@ -117,5 +107,5 @@ declare class ListNavigation<T extends ListNavigationItem> {
     private _peek;
 }
 
-export { ListFocus, ListNavigation, computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal };
-export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem, SignalLike, WritableSignalLike };
+export { ListFocus, ListNavigation };
+export type { ListFocusInputs, ListFocusItem, ListNavigationInputs, ListNavigationItem };

package/types/_listbox-chunk.d.ts

@@ -1,7 +1,7 @@
-import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { ListInputs, List, ListItem } from './_list-chunk.js';
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
-import { PointerEventManager } from './_pointer-event-manager-chunk.js';
+import { ClickEventManager } from './_click-event-manager-chunk.js';
 
 /**
  * Represents the properties exposed by a listbox that need to be accessed by an option.
@@ -18,27 +18,27 @@ interface OptionInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
 /** Represents an option in a listbox. */
 declare class OptionPattern<V> {
     /** A unique identifier for the option. */
-    id: SignalLike<string>;
+    readonly id: SignalLike<string>;
     /** The value of the option. */
-    value: SignalLike<V>;
+    readonly value: SignalLike<V>;
     /** The position of the option in the list. */
-    index: SignalLike<number>;
+    readonly index: SignalLike<number>;
     /** Whether the option is active. */
-    active: SignalLike<boolean>;
+    readonly active: SignalLike<boolean>;
     /** Whether the option is selected. */
-    selected: SignalLike<boolean | undefined>;
+    readonly selected: SignalLike<boolean | undefined>;
     /** Whether the option is selectable. */
-    selectable: () => boolean;
+    readonly selectable: () => boolean;
     /** Whether the option is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** The text used by the typeahead search. */
-    searchTerm: SignalLike<string>;
+    readonly searchTerm: SignalLike<string>;
     /** A reference to the parent listbox. */
-    listbox: SignalLike<ListboxPattern$1<V> | undefined>;
+    readonly listbox: SignalLike<ListboxPattern$1<V> | undefined>;
     /** The tab index of the option. */
-    tabIndex: SignalLike<0 | -1 | undefined>;
+    readonly tabIndex: SignalLike<0 | -1 | undefined>;
     /** The html element that should receive focus. */
-    element: SignalLike<HTMLElement | undefined>;
+    readonly element: SignalLike<HTMLElement | undefined>;
     constructor(args: OptionInputs<V>);
 }
 
@@ -52,43 +52,46 @@ type ListboxInputs<V> = ListInputs<OptionPattern<V>, V> & {
 /** Controls the state of a listbox. */
 declare class ListboxPattern<V> {
     readonly inputs: ListboxInputs<V>;
-    listBehavior: List<OptionPattern<V>, V>;
+    readonly listBehavior: List<OptionPattern<V>, V>;
+    /** Whether the listbox has been interacted with. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** Whether the list is vertically or horizontally oriented. */
-    orientation: SignalLike<'vertical' | 'horizontal'>;
+    readonly orientation: SignalLike<'vertical' | 'horizontal'>;
     /** Whether the listbox is disabled. */
-    disabled: SignalLike<boolean>;
+    readonly disabled: SignalLike<boolean>;
     /** Whether the listbox is readonly. */
-    readonly: SignalLike<boolean>;
+    readonly readonly: SignalLike<boolean>;
     /** The tab index of the listbox. */
-    tabIndex: SignalLike<-1 | 0>;
+    readonly tabIndex: SignalLike<-1 | 0>;
     /** The id of the current active item. */
-    activeDescendant: SignalLike<string | undefined>;
+    readonly activeDescendant: SignalLike<string | undefined>;
     /** Whether multiple items in the list can be selected at once. */
     multi: SignalLike<boolean>;
     /** The number of items in the listbox. */
-    setsize: SignalLike<number>;
+    readonly setsize: SignalLike<number>;
     /** Whether the listbox selection follows focus. */
-    followFocus: SignalLike<boolean>;
+    readonly followFocus: SignalLike<boolean>;
     /** Whether the listbox should wrap. Used to disable wrapping while range selecting. */
-    wrap: WritableSignalLike<boolean>;
+    readonly wrap: WritableSignalLike<boolean>;
     /** The key used to navigate to the previous item in the list. */
-    prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
+    readonly prevKey: SignalLike<"ArrowUp" | "ArrowRight" | "ArrowLeft">;
     /** The key used to navigate to the next item in the list. */
-    nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
+    readonly nextKey: SignalLike<"ArrowRight" | "ArrowLeft" | "ArrowDown">;
     /** Represents the space key. Does nothing when the user is actively using typeahead. */
-    dynamicSpaceKey: SignalLike<"" | " ">;
+    readonly dynamicSpaceKey: SignalLike<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
-    typeaheadRegexp: RegExp;
+    readonly typeaheadRegexp: RegExp;
     /** The keydown event manager for the listbox. */
-    keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
-    /** The pointerdown event manager for the listbox. */
-    pointerdown: SignalLike<PointerEventManager<PointerEvent>>;
+    readonly keydown: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    /** The click event manager for the listbox. */
+    readonly clickManager: SignalLike<ClickEventManager<PointerEvent>>;
     constructor(inputs: ListboxInputs<V>);
     /** Returns a set of violations */
     validate(): string[];
     /** Handles keydown events for the listbox. */
     onKeydown(event: KeyboardEvent): void;
-    onPointerdown(event: PointerEvent): void;
+    onClick(event: PointerEvent): void;
+    onFocusIn(): void;
     /**
      * Sets the listbox to it's default initial state.
      *
@@ -100,6 +103,10 @@ declare class ListboxPattern<V> {
      * is called.
      */
     setDefaultState(): void;
+    /**
+     * Sets the default active state of the listbox before receiving interaction for the first time.
+     */
+    setDefaultStateEffect(): void;
     protected _getItem(e: PointerEvent): OptionPattern<V> | undefined;
 }
 

package/types/_menu-chunk.d.ts

@@ -1,4 +1,4 @@
-import { SignalLike, WritableSignalLike } from './_list-navigation-chunk.js';
+import { SignalLike, WritableSignalLike } from './_signal-like-chunk.js';
 import { KeyboardEventManager } from './_keyboard-event-manager-chunk.js';
 import { ListInputs, ListItem, List } from './_list-chunk.js';
 
@@ -48,44 +48,46 @@ interface MenuItemInputs<V> extends Omit<ListItem<V>, 'index' | 'selectable'> {
 declare class MenuPattern<V> {
     readonly inputs: MenuInputs<V>;
     /** The unique ID of the menu. */
-    id: SignalLike<string>;
+    readonly id: SignalLike<string>;
     /** The role of the menu. */
-    role: () => string;
+    readonly role: () => string;
     /** Whether the menu is disabled. */
-    disabled: () => boolean;
+    readonly disabled: () => boolean;
     /** Whether the menu is visible. */
-    visible: SignalLike<boolean>;
+    readonly visible: SignalLike<boolean>;
     /** Controls list behavior for the menu items. */
-    listBehavior: List<MenuItemPattern<V>, V>;
+    readonly listBehavior: List<MenuItemPattern<V>, V>;
     /** Whether the menu or any of its child elements are currently focused. */
-    isFocused: WritableSignalLike<boolean>;
-    /** Whether the menu has received focus. */
-    hasBeenFocused: WritableSignalLike<boolean>;
+    readonly isFocused: WritableSignalLike<boolean>;
+    /** Whether the menu has received interaction. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** Whether the menu trigger has been hovered. */
-    hasBeenHovered: WritableSignalLike<boolean>;
+    readonly hasBeenHovered: WritableSignalLike<boolean>;
     /** Timeout used to open sub-menus on hover. */
     _openTimeout: any;
     /** Timeout used to close sub-menus on hover out. */
     _closeTimeout: any;
     /** The tab index of the menu. */
-    tabIndex: () => 0 | -1;
+    readonly tabIndex: () => 0 | -1;
     /** Whether the menu should be focused on mouse over. */
-    shouldFocus: SignalLike<boolean>;
+    readonly shouldFocus: SignalLike<boolean>;
     /** The key used to expand sub-menus. */
-    private _expandKey;
+    private readonly _expandKey;
     /** The key used to collapse sub-menus. */
-    private _collapseKey;
+    private readonly _collapseKey;
     /** Represents the space key. Does nothing when the user is actively using typeahead. */
-    dynamicSpaceKey: SignalLike<"" | " ">;
+    readonly dynamicSpaceKey: SignalLike<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
-    typeaheadRegexp: RegExp;
+    readonly typeaheadRegexp: RegExp;
     /** The root of the menu. */
-    root: SignalLike<MenuTriggerPattern<V> | MenuBarPattern<V> | MenuPattern<V> | undefined>;
+    readonly root: SignalLike<MenuTriggerPattern<V> | MenuBarPattern<V> | MenuPattern<V> | undefined>;
     /** Handles keyboard events for the menu. */
-    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: MenuInputs<V>);
     /** Sets the default state for the menu. */
     setDefaultState(): void;
+    /** Sets the default active state of the menu before receiving interaction for the first time. */
+    setDefaultStateEffect(): void;
     /** Handles keyboard events for the menu. */
     onKeydown(event: KeyboardEvent): void;
     /** Handles mouseover events for the menu. */
@@ -133,28 +135,30 @@ declare class MenuPattern<V> {
 declare class MenuBarPattern<V> {
     readonly inputs: MenuBarInputs<V>;
     /** Controls list behavior for the menu items. */
-    listBehavior: List<MenuItemPattern<V>, V>;
+    readonly listBehavior: List<MenuItemPattern<V>, V>;
     /** The tab index of the menu. */
-    tabIndex: () => 0 | -1;
+    readonly tabIndex: () => 0 | -1;
     /** The key used to navigate to the next item. */
-    private _nextKey;
+    private readonly _nextKey;
     /** The key used to navigate to the previous item. */
-    private _previousKey;
+    private readonly _previousKey;
     /** Represents the space key. Does nothing when the user is actively using typeahead. */
-    dynamicSpaceKey: SignalLike<"" | " ">;
+    readonly dynamicSpaceKey: SignalLike<"" | " ">;
     /** The regexp used to decide if a key should trigger typeahead. */
-    typeaheadRegexp: RegExp;
+    readonly typeaheadRegexp: RegExp;
     /** Whether the menubar or any of its children are currently focused. */
-    isFocused: WritableSignalLike<boolean>;
-    /** Whether the menubar has been focused. */
-    hasBeenFocused: WritableSignalLike<boolean>;
+    readonly isFocused: WritableSignalLike<boolean>;
+    /** Whether the menubar has been interacted with. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** Whether the menubar is disabled. */
-    disabled: () => boolean;
+    readonly disabled: () => boolean;
     /** Handles keyboard events for the menu. */
-    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: MenuBarInputs<V>);
     /** Sets the default state for the menubar. */
     setDefaultState(): void;
+    /** Sets the default active state of the menubar before receiving interaction for the first time. */
+    setDefaultStateEffect(): void;
     /** Handles keyboard events for the menu. */
     onKeydown(event: KeyboardEvent): void;
     /** Handles click events for the menu bar. */
@@ -179,22 +183,22 @@ declare class MenuBarPattern<V> {
 /** The menu trigger ui pattern class. */
 declare class MenuTriggerPattern<V> {
     readonly inputs: MenuTriggerInputs<V>;
-    /** Whether the menu is expanded. */
-    expanded: WritableSignalLike<boolean>;
-    /** Whether the menu trigger has received focus. */
-    hasBeenFocused: WritableSignalLike<boolean>;
+    /** Whether the menu trigger is expanded. */
+    readonly expanded: WritableSignalLike<boolean>;
+    /** Whether the menu trigger has received interaction. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** The role of the menu trigger. */
-    role: () => string;
+    readonly role: () => string;
     /** Whether the menu trigger has a popup. */
-    hasPopup: () => boolean;
+    readonly hasPopup: () => boolean;
     /** The menu associated with the trigger. */
-    menu: SignalLike<MenuPattern<V> | undefined>;
+    readonly menu: SignalLike<MenuPattern<V> | undefined>;
     /** The tab index of the menu trigger. */
-    tabIndex: SignalLike<-1 | 0>;
+    readonly tabIndex: SignalLike<-1 | 0>;
     /** Whether the menu trigger is disabled. */
-    disabled: () => boolean;
+    readonly disabled: () => boolean;
     /** Handles keyboard events for the menu trigger. */
-    keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
+    readonly keydownManager: SignalLike<KeyboardEventManager<KeyboardEvent>>;
     constructor(inputs: MenuTriggerInputs<V>);
     /** Handles keyboard events for the menu trigger. */
     onKeydown(event: KeyboardEvent): void;
@@ -218,37 +222,37 @@ declare class MenuTriggerPattern<V> {
 declare class MenuItemPattern<V> implements ListItem<V> {
     readonly inputs: MenuItemInputs<V>;
     /** The value of the menu item. */
-    value: SignalLike<V>;
+    readonly value: SignalLike<V>;
     /** The unique ID of the menu item. */
-    id: SignalLike<string>;
+    readonly id: SignalLike<string>;
     /** Whether the menu item is disabled. */
-    disabled: () => boolean;
+    readonly disabled: () => boolean;
     /** The search term for the menu item. */
-    searchTerm: SignalLike<string>;
+    readonly searchTerm: SignalLike<string>;
     /** The element of the menu item. */
-    element: SignalLike<HTMLElement | undefined>;
+    readonly element: SignalLike<HTMLElement | undefined>;
     /** Whether the menu item is active. */
-    active: SignalLike<boolean>;
-    /** Whether the menu item has received focus. */
-    hasBeenFocused: WritableSignalLike<boolean>;
+    readonly active: SignalLike<boolean>;
+    /** Whether the menu item has received interaction. */
+    readonly hasBeenInteracted: WritableSignalLike<boolean>;
     /** The tab index of the menu item. */
-    tabIndex: SignalLike<0 | -1>;
+    readonly tabIndex: SignalLike<0 | -1>;
     /** The position of the menu item in the menu. */
-    index: SignalLike<number>;
+    readonly index: SignalLike<number>;
     /** Whether the menu item is expanded. */
-    expanded: SignalLike<boolean | null>;
+    readonly expanded: SignalLike<boolean | null>;
     /** Whether the menu item is expanded. */
-    _expanded: WritableSignalLike<boolean>;
+    readonly _expanded: WritableSignalLike<boolean>;
     /** The ID of the menu that the menu item controls. */
-    controls: WritableSignalLike<string | undefined>;
+    readonly controls: WritableSignalLike<string | undefined>;
     /** The role of the menu item. */
-    role: () => string;
+    readonly role: () => string;
     /** Whether the menu item has a popup. */
-    hasPopup: SignalLike<boolean>;
+    readonly hasPopup: SignalLike<boolean>;
     /** The submenu associated with the menu item. */
-    submenu: SignalLike<MenuPattern<V> | undefined>;
+    readonly submenu: SignalLike<MenuPattern<V> | undefined>;
     /** Whether the menu item is selectable. */
-    selectable: SignalLike<boolean>;
+    readonly selectable: SignalLike<boolean>;
     constructor(inputs: MenuItemInputs<V>);
     /** Opens the submenu. */
     open(opts?: {

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

@@ -10,7 +10,7 @@ declare enum MouseButton {
 }
 /** An event manager that is specialized for handling pointer events. */
 declare class PointerEventManager<T extends PointerEvent> extends EventManager<T> {
-    options: EventHandlerOptions;
+    readonly options: EventHandlerOptions;
     /**
      * Configures this event manager to handle events with a specific modifer and mouse button
      * combination.

package/types/_signal-like-chunk.d.ts

@@ -0,0 +1,14 @@
+type SignalLike<T> = () => T;
+interface WritableSignalLike<T> extends SignalLike<T> {
+    set(value: T): void;
+    update(updateFn: (value: T) => T): void;
+    asReadonly(): SignalLike<T>;
+}
+/** Converts a getter setter style signal to a WritableSignalLike. */
+declare function convertGetterSetterToWritableSignalLike<T>(getter: () => T, setter: (v: T) => void): WritableSignalLike<T>;
+declare function computed<T>(computation: () => T): SignalLike<T>;
+declare function signal<T>(initialValue: T): WritableSignalLike<T>;
+declare function linkedSignal<T>(sourceFn: () => T): WritableSignalLike<T>;
+
+export { computed, convertGetterSetterToWritableSignalLike, linkedSignal, signal };
+export type { SignalLike, WritableSignalLike };