@angular/aria 0.0.0 → 21.0.0-next.8

package/types/toolbar.d.ts

@@ -0,0 +1,113 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import { ToolbarWidgetPattern, ToolbarWidgetGroupPattern, ToolbarPattern, ToolbarWidgetGroupControls } from '@angular/aria/ui-patterns';
+
+/**
+ * A toolbar widget container.
+ *
+ * Widgets such as radio groups or buttons are nested within a toolbar to allow for a single
+ * place of reference for focus and navigation. The Toolbar is meant to be used in conjunction
+ * with ToolbarWidget and RadioGroup as follows:
+ *
+ * ```html
+ * <div ngToolbar>
+ *  <button ngToolbarWidget>Button</button>
+ *  <div ngRadioGroup>
+ *    <label ngRadioButton value="1">Option 1</label>
+ *    <label ngRadioButton value="2">Option 2</label>
+ *    <label ngRadioButton value="3">Option 3</label>
+ *  </div>
+ * </div>
+ * ```
+ */
+declare class Toolbar<V> {
+    /** A reference to the toolbar element. */
+    private readonly _elementRef;
+    /** The TabList nested inside of the container. */
+    private readonly _widgets;
+    /** A signal wrapper for directionality. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Sorted UIPatterns of the child widgets */
+    readonly items: Signal<(ToolbarWidgetPattern<V> | ToolbarWidgetGroupPattern<V>)[]>;
+    /** Whether the toolbar is vertically or horizontally oriented. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether disabled items in the group should be skipped when navigating. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the toolbar is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether focus should wrap when navigating. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The toolbar UIPattern. */
+    readonly pattern: ToolbarPattern<V>;
+    /** Whether the toolbar has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    register(widget: ToolbarWidget<V> | ToolbarWidgetGroup<V>): void;
+    unregister(widget: ToolbarWidget<V> | ToolbarWidgetGroup<V>): void;
+    /** Finds the toolbar item associated with a given element. */
+    private _getItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toolbar<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Toolbar<any>, "[ngToolbar]", ["ngToolbar"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A widget within a toolbar.
+ *
+ * A widget is anything that is within a toolbar. It should be applied to any native HTML element
+ * that has the purpose of acting as a widget navigatable within a toolbar.
+ */
+declare class ToolbarWidget<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent Toolbar. */
+    private readonly _toolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any>>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the widget is 'hard' disabled, which is different from `aria-disabled`. A hard disabled widget cannot receive focus. */
+    readonly hardDisabled: Signal<boolean>;
+    /** The ToolbarWidget UIPattern. */
+    readonly pattern: ToolbarWidgetPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarWidget<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolbarWidget<any>, "[ngToolbarWidget]", ["ngToolbarWidget"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A directive that groups toolbar widgets, used for more complex widgets like radio groups that
+ * have their own internal navigation.
+ */
+declare class ToolbarWidgetGroup<V> implements OnInit, OnDestroy {
+    /** A reference to the widget element. */
+    private readonly _elementRef;
+    /** The parent Toolbar. */
+    private readonly _toolbar;
+    /** A unique identifier for the widget. */
+    private readonly _generatedId;
+    /** A unique identifier for the widget. */
+    readonly id: Signal<string>;
+    /** The parent Toolbar UIPattern. */
+    readonly toolbar: Signal<ToolbarPattern<any> | undefined>;
+    /** A reference to the widget element to be focused on navigation. */
+    readonly element: Signal<any>;
+    /** Whether the widget group is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The controls that can be performed on the widget group. */
+    readonly controls: _angular_core.WritableSignal<ToolbarWidgetGroupControls | undefined>;
+    /** The ToolbarWidgetGroup UIPattern. */
+    readonly pattern: ToolbarWidgetGroupPattern<V>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolbarWidgetGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToolbarWidgetGroup<any>, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { Toolbar, ToolbarWidget, ToolbarWidgetGroup };

package/types/tree.d.ts

@@ -0,0 +1,151 @@
+import * as _angular_cdk_bidi from '@angular/cdk/bidi';
+import * as _angular_core from '@angular/core';
+import { Signal, OnInit, OnDestroy } from '@angular/core';
+import { TreePattern, TreeItemPattern } from '@angular/aria/ui-patterns';
+import { ComboboxPopup } from './combobox.js';
+import * as i1 from '@angular/aria/deferred-content';
+
+interface HasElement {
+    element: Signal<HTMLElement>;
+}
+/**
+ * A Tree container.
+ *
+ * Transforms nested lists into an accessible, ARIA-compliant tree structure.
+ *
+ * ```html
+ * <ul ngTree [(value)]="selectedItems" [multi]="true">
+ *   <li ngTreeItem [value]="'leaf1'">Leaf Item 1</li>
+ *   <li ngTreeItem [value]="'parent1'">
+ *     Parent Item 1
+ *     <ul ngTreeItemGroup [value]="'parent1'">
+ *       <ng-template ngTreeItemGroupContent>
+ *         <li ngTreeItem [value]="'child1.1'">Child Item 1.1</li>
+ *         <li ngTreeItem [value]="'child1.2'">Child Item 1.2</li>
+ *       </ng-template>
+ *     </ul>
+ *   </li>
+ *   <li ngTreeItem [value]="'leaf2'" [disabled]="true">Disabled Leaf Item 2</li>
+ * </ul>
+ * ```
+ */
+declare class Tree<V> {
+    /** A unique identifier for the tree. */
+    private readonly _generatedId;
+    /** A unique identifier for the tree. */
+    protected id: Signal<string>;
+    /** A reference to the parent combobox popup, if one exists. */
+    private readonly _popup;
+    /** A reference to the tree element. */
+    private readonly _elementRef;
+    /** All TreeItem instances within this tree. */
+    private readonly _unorderedItems;
+    /** Orientation of the tree. */
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    /** Whether multi-selection is allowed. */
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the tree is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The selection strategy used by the tree. */
+    readonly selectionMode: _angular_core.InputSignal<"explicit" | "follow">;
+    /** The focus strategy used by the tree. */
+    readonly focusMode: _angular_core.InputSignal<"roving" | "activedescendant">;
+    /** Whether navigation wraps. */
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to skip disabled items during navigation. */
+    readonly skipDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Typeahead delay. */
+    readonly typeaheadDelay: _angular_core.InputSignal<number>;
+    /** Selected item values. */
+    readonly value: _angular_core.ModelSignal<V[]>;
+    /** Text direction. */
+    readonly textDirection: _angular_core.WritableSignal<_angular_cdk_bidi.Direction>;
+    /** Whether the tree is in navigation mode. */
+    readonly nav: _angular_core.InputSignal<boolean>;
+    /** The aria-current type. */
+    readonly currentType: _angular_core.InputSignal<"page" | "step" | "location" | "date" | "time" | "true" | "false">;
+    /** The UI pattern for the tree. */
+    readonly pattern: TreePattern<V>;
+    /** Whether the tree has received focus yet. */
+    private _hasFocused;
+    constructor();
+    onFocus(): void;
+    register(child: TreeItem<V>): void;
+    unregister(child: TreeItem<V>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tree<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Tree<any>, "[ngTree]", ["ngTree"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "skipDisabled": { "alias": "skipDisabled"; "required": false; "isSignal": true; }; "typeaheadDelay": { "alias": "typeaheadDelay"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "nav": { "alias": "nav"; "required": false; "isSignal": true; }; "currentType": { "alias": "currentType"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof ComboboxPopup; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * A selectable and expandable Tree Item in a Tree.
+ */
+declare class TreeItem<V> implements OnInit, OnDestroy, HasElement {
+    /** A reference to the tree item element. */
+    private readonly _elementRef;
+    /** A unique identifier for the tree item. */
+    private readonly _id;
+    /** The owned tree item group. */
+    private readonly _group;
+    /** The id of the owned group. */
+    readonly ownsId: Signal<string | undefined>;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** The value of the tree item. */
+    readonly value: _angular_core.InputSignal<V>;
+    /** The parent tree root or tree item group. */
+    readonly parent: _angular_core.InputSignal<TreeItemGroup<V> | Tree<V>>;
+    /** Whether the tree item is disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Optional label for typeahead. Defaults to the element's textContent. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** Search term for typeahead. */
+    readonly searchTerm: Signal<any>;
+    /** The tree root. */
+    readonly tree: Signal<Tree<V>>;
+    /** The UI pattern for this item. */
+    pattern: TreeItemPattern<V>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    register(group: TreeItemGroup<V>): void;
+    unregister(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeItem<any>, "[ngTreeItem]", ["ngTreeItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "parent": { "alias": "parent"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Container that designates content as a group.
+ */
+declare class TreeItemGroup<V> implements OnInit, OnDestroy, HasElement {
+    /** A reference to the group element. */
+    private readonly _elementRef;
+    /** The DeferredContentAware host directive. */
+    private readonly _deferredContentAware;
+    /** All groupable items that are descendants of the group. */
+    private readonly _unorderedItems;
+    /** The host native element. */
+    readonly element: Signal<any>;
+    /** Unique ID for the group. */
+    readonly id: string;
+    /** Whether the group is visible. */
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    /** Child items within this group. */
+    readonly children: Signal<TreeItem<V>[]>;
+    /** Tree item that owns the group. */
+    readonly ownedBy: _angular_core.InputSignal<TreeItem<V>>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    register(child: TreeItem<V>): void;
+    unregister(child: TreeItem<V>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeItemGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeItemGroup<any>, "[ngTreeItemGroup]", ["ngTreeItemGroup"], { "ownedBy": { "alias": "ownedBy"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.DeferredContentAware; inputs: { "preserveContent": "preserveContent"; }; outputs: {}; }]>;
+}
+/**
+ * A structural directive that marks the `ng-template` to be used as the content
+ * for a `TreeItemGroup`. This content can be lazily loaded.
+ */
+declare class TreeItemGroupContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeItemGroupContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeItemGroupContent, "ng-template[ngTreeItemGroupContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.DeferredContent; inputs: {}; outputs: {}; }]>;
+}
+
+export { Tree, TreeItem, TreeItemGroup, TreeItemGroupContent };