ng-primitives 0.93.0 → 0.94.0

package/input/index.d.ts

@@ -19,6 +19,7 @@ declare class NgpInput {
         id: _angular_core.Signal<string>;
         disabled: _angular_core.WritableSignal<boolean>;
         status: _angular_core.Signal<ng_primitives_utils.NgpControlStatus>;
+        setDisabled: (value: boolean) => void;
     };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpInput, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpInput, "input[ngpInput]", ["ngpInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -36,6 +37,11 @@ interface NgpInputState {
      * Whether the input is disabled.
      */
     readonly disabled: WritableSignal<boolean>;
+    /**
+     * Set the disabled state of the input.
+     * @param value The disabled state.
+     */
+    setDisabled(value: boolean): void;
 }
 /**
  * Inputs for configuring the Input primitive.
@@ -54,32 +60,39 @@ declare const ngpInput: ({ id, disabled: _disabled }: NgpInputProps) => {
     id: Signal<string>;
     disabled: WritableSignal<boolean>;
     status: Signal<ng_primitives_utils.NgpControlStatus>;
+    setDisabled: (value: boolean) => void;
 };
 declare const injectInputState: {
     (): Signal<{
         id: Signal<string>;
         disabled: WritableSignal<boolean>;
         status: Signal<ng_primitives_utils.NgpControlStatus>;
+        setDisabled: (value: boolean) => void;
     }>;
     (options: {
         hoisted: true;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<{
         id: Signal<string>;
         disabled: WritableSignal<boolean>;
         status: Signal<ng_primitives_utils.NgpControlStatus>;
+        setDisabled: (value: boolean) => void;
     } | null>;
     (options?: {
         hoisted?: boolean;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<{
         id: Signal<string>;
         disabled: WritableSignal<boolean>;
         status: Signal<ng_primitives_utils.NgpControlStatus>;
+        setDisabled: (value: boolean) => void;
     }> | Signal<{
         id: Signal<string>;
         disabled: WritableSignal<boolean>;
         status: Signal<ng_primitives_utils.NgpControlStatus>;
+        setDisabled: (value: boolean) => void;
     } | null>;
 };
 declare const provideInputState: (opts?: {

package/menu/index.d.ts

@@ -1,31 +1,15 @@
-import * as ng_primitives_portal from 'ng-primitives/portal';
-import { NgpOverlayContent, NgpOffset, NgpOffsetInput, NgpOverlay } from 'ng-primitives/portal';
+import { NgpOverlayContent, NgpOffset, NgpOffsetInput } from 'ng-primitives/portal';
 export { injectOverlayContext as injectMenuContext } from 'ng-primitives/portal';
 import * as _angular_core from '@angular/core';
-import { OnDestroy, Provider, InjectionToken } from '@angular/core';
-import * as ng_primitives_state from 'ng-primitives/state';
+import { Provider, Signal } from '@angular/core';
 import { FocusOrigin } from '@angular/cdk/a11y';
 import { BooleanInput } from '@angular/cdk/coercion';
-import * as i1 from 'ng-primitives/roving-focus';
 import { Subject } from 'rxjs';
-import * as i2 from 'ng-primitives/focus-trap';
 
 /**
  * The `NgpMenuTrigger` directive allows you to turn an element into a menu trigger.
  */
-declare class NgpMenuTrigger<T = unknown> implements OnDestroy {
-    /**
-     * Access the trigger element
-     */
-    private readonly trigger;
-    /**
-     * Access the injector.
-     */
-    private readonly injector;
-    /**
-     * Access the view container reference.
-     */
-    private readonly viewContainerRef;
+declare class NgpMenuTrigger<T = unknown> {
     /**
      * Access the global menu configuration.
      */
@@ -69,36 +53,25 @@ declare class NgpMenuTrigger<T = unknown> implements OnDestroy {
      * Provide context to the menu. This can be used to pass data to the menu content.
      */
     readonly context: _angular_core.InputSignal<T | undefined>;
-    /**
-     * The overlay that manages the menu
-     * @internal
-     */
-    readonly overlay: _angular_core.WritableSignal<NgpOverlay<T> | null>;
-    /**
-     * The open state of the menu.
-     * @internal
-     */
-    readonly open: _angular_core.Signal<boolean>;
     /**
      * The menu trigger state.
      */
-    readonly state: ng_primitives_state.CreatedState<NgpMenuTrigger<T>>;
-    ngOnDestroy(): void;
-    protected onClick(event: MouseEvent): void;
-    toggle(event: MouseEvent): void;
+    private readonly state;
     /**
      * Show the menu.
      */
     show(): void;
     /**
-     * @internal
      * Hide the menu.
+     * @param origin - The focus origin
+     * @internal
      */
     hide(origin?: FocusOrigin): void;
     /**
-     * Create the overlay that will contain the menu
+     * Toggle the menu.
+     * @param event - The mouse event
      */
-    private createOverlay;
+    toggle(event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuTrigger<any>, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuTrigger<any>, "[ngpMenuTrigger]", ["ngpMenuTrigger"], { "menu": { "alias": "ngpMenuTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpMenuTriggerDisabled"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpMenuTriggerPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpMenuTriggerOffset"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpMenuTriggerFlip"; "required": false; "isSignal": true; }; "container": { "alias": "ngpMenuTriggerContainer"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "ngpMenuTriggerScrollBehavior"; "required": false; "isSignal": true; }; "context": { "alias": "ngpMenuTriggerContext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -143,78 +116,186 @@ declare function provideMenuConfig(config: Partial<NgpMenuConfig>): Provider[];
  * The `NgpMenuItem` directive represents a menu item.
  */
 declare class NgpMenuItem {
-    /** Access the injector */
-    private readonly injector;
-    /** Access the button element */
-    private readonly elementRef;
-    /** Access the parent menu */
-    private readonly parentMenu;
     /** Whether the menu item is disabled */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     constructor();
-    /** Close the menu when the item is clicked */
-    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuItem, "[ngpMenuItem]", ["ngpMenuItem"], { "disabled": { "alias": "ngpMenuItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpMenuItemState {
+}
+interface NgpMenuItemProps {
     /**
-     * If the user presses the left arrow key (in LTR) and there is a parent menu,
-     * we want to close the menu and focus the parent menu item.
+     * Whether the menu item is disabled.
      */
-    protected handleArrowKey(event: Event): void;
+    readonly disabled?: Signal<boolean>;
+}
+declare const injectMenuItemState: {
+    (): Signal<{}>;
+    (options: {
+        hoisted: true;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{} | null>;
+    (options?: {
+        hoisted?: boolean;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{}> | Signal<{} | null>;
+};
+declare const provideMenuItemState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+interface NgpMenuTriggerState {
     /**
-     * If the user hovers over the trigger, we want to open the submenu
+     * The computed placement of the menu.
      */
-    protected showSubmenuOnHover(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuItem, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuItem, "[ngpMenuItem]", ["ngpMenuItem"], { "disabled": { "alias": "ngpMenuItemDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpRovingFocusItem; inputs: { "ngpRovingFocusItemDisabled": "ngpMenuItemDisabled"; }; outputs: {}; }]>;
+    readonly placement: Signal<NgpMenuPlacement>;
+    /**
+     * Show the menu.
+     */
+    show(): void;
+    /**
+     * Hide the menu.
+     * @param origin - The focus origin
+     * @internal
+     */
+    hide(origin?: FocusOrigin): void;
+    /**
+     * Toggle the menu.
+     * @param event - The mouse event
+     */
+    toggle(event: MouseEvent): void;
 }
-
-/**
- * Provides the MenuTrigger state.
- */
-declare const provideMenuTriggerState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
-/**
- * Injects the MenuTrigger state.
- */
-declare const injectMenuTriggerState: <U = NgpMenuTrigger<unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
+interface NgpMenuTriggerProps<T = unknown> {
+    /**
+     * Whether the trigger is disabled.
+     */
+    readonly disabled?: Signal<boolean>;
+    /**
+     * The menu template or component.
+     */
+    readonly menu?: Signal<NgpOverlayContent<T> | undefined>;
+    /**
+     * The placement of the menu.
+     */
+    readonly placement?: Signal<NgpMenuPlacement>;
+    /**
+     * The offset of the menu.
+     */
+    readonly offset?: Signal<NgpOffset>;
+    /**
+     * Whether the menu should flip when there is not enough space.
+     */
+    readonly flip?: Signal<boolean>;
+    /**
+     * The container in which the menu should be attached.
+     */
+    readonly container?: Signal<HTMLElement | string | null>;
+    /**
+     * How the menu behaves when the window is scrolled.
+     */
+    readonly scrollBehavior?: Signal<'reposition' | 'block'>;
+    /**
+     * Context to provide to the menu.
+     */
+    readonly context?: Signal<T | undefined>;
+}
+declare const injectMenuTriggerState: {
+    (): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    }>;
+    (options: {
+        hoisted: true;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    }> | Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    } | null>;
+};
+declare const provideMenuTriggerState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
 
 /**
  * The `NgpMenu` is a container for menu items.
  */
 declare class NgpMenu {
-    /** Access the overlay. */
-    protected readonly overlay: ng_primitives_portal.NgpOverlay<unknown>;
-    /** Access the menu trigger state */
-    private readonly menuTrigger;
-    /** Access any parent menus */
-    private readonly parentMenu;
-    /** @internal Whether we should close submenus */
-    readonly closeSubmenus: Subject<HTMLElement>;
+    private readonly state;
+    constructor();
     /** @internal Close the menu and any parent menus */
     closeAllMenus(origin: FocusOrigin): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenu, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenu, "[ngpMenu]", ["ngpMenu"], {}, {}, never, never, true, [{ directive: typeof i1.NgpRovingFocusGroup; inputs: {}; outputs: {}; }, { directive: typeof i2.NgpFocusTrap; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenu, "[ngpMenu]", ["ngpMenu"], {}, {}, never, never, true, never>;
 }
 
-declare const NgpMenuToken: InjectionToken<NgpMenu>;
-/**
- * Inject the Menu directive instance
- */
-declare function injectMenu(): NgpMenu;
-
-declare class NgpSubmenuTrigger<T = unknown> {
+interface NgpMenuState {
     /**
-     * Access the menu trigger element.
+     * Close the menu and any parent menus.
+     * @param origin - The focus origin
      */
-    private readonly trigger;
-    /**
-     * Access the injector.
-     */
-    private readonly injector;
+    closeAllMenus(origin: FocusOrigin): void;
     /**
-     * Access the view container reference.
+     * Subject that emits when submenus should be closed.
+     * @internal
      */
-    private readonly viewContainerRef;
-    /** Access the parent menu */
-    private readonly parentMenu;
+    readonly closeSubmenus: Subject<HTMLElement>;
+}
+interface NgpMenuProps {
+}
+declare const injectMenuState: {
+    (): _angular_core.Signal<{
+        closeAllMenus: (origin: FocusOrigin) => void;
+        closeSubmenus: Subject<HTMLElement>;
+    }>;
+    (options: {
+        hoisted: true;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): _angular_core.Signal<{
+        closeAllMenus: (origin: FocusOrigin) => void;
+        closeSubmenus: Subject<HTMLElement>;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): _angular_core.Signal<{
+        closeAllMenus: (origin: FocusOrigin) => void;
+        closeSubmenus: Subject<HTMLElement>;
+    }> | _angular_core.Signal<{
+        closeAllMenus: (origin: FocusOrigin) => void;
+        closeSubmenus: Subject<HTMLElement>;
+    } | null>;
+};
+declare const provideMenuState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
+
+declare class NgpSubmenuTrigger<T = unknown> {
     /**
      * Access the submenu template ref.
      */
@@ -241,58 +322,104 @@ declare class NgpSubmenuTrigger<T = unknown> {
      */
     readonly flip: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * The overlay that manages the menu
-     * @internal
+     * Access the menu trigger state.
      */
-    readonly overlay: _angular_core.WritableSignal<NgpOverlay<T> | null>;
+    private readonly state;
     /**
-     * The open state of the menu.
-     * @internal
+     * Show the menu.
      */
-    readonly open: _angular_core.Signal<boolean>;
+    show(): void;
     /**
-     * Access the menu trigger state.
+     * Hide the menu.
      */
-    readonly state: ng_primitives_state.CreatedState<NgpSubmenuTrigger<T>>;
-    constructor();
-    protected toggle(event: MouseEvent): void;
+    hide(origin?: FocusOrigin): void;
+    /**
+     * Toggle the menu.
+     * @param event - The mouse event
+     */
+    toggle(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSubmenuTrigger<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSubmenuTrigger<any>, "[ngpSubmenuTrigger]", ["ngpSubmenuTrigger"], { "menu": { "alias": "ngpSubmenuTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpSubmenuTriggerDisabled"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpSubmenuTriggerPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpSubmenuTriggerOffset"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpSubmenuTriggerFlip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NgpSubmenuTriggerState {
+    /**
+     * The computed placement of the menu.
+     */
+    readonly placement: Signal<NgpMenuPlacement>;
     /**
      * Show the menu.
      */
     show(): void;
     /**
-     * @internal
      * Hide the menu.
+     * @param origin - The focus origin
      */
     hide(origin?: FocusOrigin): void;
     /**
-     * Create the overlay that will contain the menu
+     * Toggle the menu.
+     * @param event - The mouse event
+     */
+    toggle(event: MouseEvent): void;
+}
+interface NgpSubmenuTriggerProps<T = unknown> {
+    /**
+     * Whether the trigger is disabled.
      */
-    private createOverlay;
+    readonly disabled?: Signal<boolean>;
     /**
-     * If the user presses the right arrow key, we want to open the submenu
-     * and focus the first item in the submenu.
-     * If the user presses the left arrow key, we want to close the submenu.
-     * This behavior will be inverted if the direction is RTL.
-     * @param event
+     * The menu template or component.
      */
-    protected handleArrowKey(event: Event): void;
+    readonly menu?: Signal<NgpOverlayContent<T> | undefined>;
     /**
-     * If the user hovers over the trigger, we want to open the submenu
+     * The placement of the menu.
      */
-    protected showSubmenuOnHover(event: PointerEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpSubmenuTrigger<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpSubmenuTrigger<any>, "[ngpSubmenuTrigger]", ["ngpSubmenuTrigger"], { "menu": { "alias": "ngpSubmenuTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "ngpSubmenuTriggerDisabled"; "required": false; "isSignal": true; }; "placement": { "alias": "ngpSubmenuTriggerPlacement"; "required": false; "isSignal": true; }; "offset": { "alias": "ngpSubmenuTriggerOffset"; "required": false; "isSignal": true; }; "flip": { "alias": "ngpSubmenuTriggerFlip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    readonly placement?: Signal<NgpMenuPlacement>;
+    /**
+     * The offset of the menu.
+     */
+    readonly offset?: Signal<NgpOffset>;
+    /**
+     * Whether the menu should flip when there is not enough space.
+     */
+    readonly flip?: Signal<boolean>;
 }
+declare const injectSubmenuTriggerState: {
+    (): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    }>;
+    (options: {
+        hoisted: true;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    } | null>;
+    (options?: {
+        hoisted?: boolean;
+        optional?: boolean;
+        skipSelf?: boolean;
+    }): Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    }> | Signal<{
+        placement: Signal<NgpMenuPlacement>;
+        show: () => void;
+        hide: (origin?: FocusOrigin) => void;
+        toggle: (event: MouseEvent) => void;
+    } | null>;
+};
+declare const provideSubmenuTriggerState: (opts?: {
+    inherit?: boolean;
+}) => _angular_core.FactoryProvider;
 
-/**
- * Provides the SubmenuTrigger state.
- */
-declare const provideSubmenuTriggerState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
-/**
- * Injects the SubmenuTrigger state.
- */
-declare const injectSubmenuTriggerState: <U = NgpSubmenuTrigger<unknown>>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
-
-export { NgpMenu, NgpMenuItem, NgpMenuToken, NgpMenuTrigger, NgpSubmenuTrigger, injectMenu, injectMenuTriggerState, injectSubmenuTriggerState, provideMenuConfig, provideMenuTriggerState, provideSubmenuTriggerState };
-export type { NgpMenuConfig, NgpMenuPlacement };
+export { NgpMenu, NgpMenuItem, NgpMenuTrigger, NgpSubmenuTrigger, injectMenuItemState, injectMenuState, injectMenuTriggerState, injectSubmenuTriggerState, provideMenuConfig, provideMenuItemState, provideMenuState, provideMenuTriggerState, provideSubmenuTriggerState };
+export type { NgpMenuConfig, NgpMenuItemProps, NgpMenuItemState, NgpMenuPlacement, NgpMenuProps, NgpMenuState, NgpMenuTriggerProps, NgpMenuTriggerState, NgpSubmenuTriggerProps, NgpSubmenuTriggerState };

package/package.json

@@ -2,7 +2,7 @@
   "name": "ng-primitives",
   "description": "Angular Primitives is a low-level headless UI component library with a focus on accessibility, customization, and developer experience. ",
   "license": "Apache-2.0",
-  "version": "0.93.0",
+  "version": "0.94.0",
   "keywords": [
     "angular",
     "primitives",

package/roving-focus/index.d.ts

@@ -8,10 +8,26 @@ import { BooleanInput } from '@angular/cdk/coercion';
  * The state interface for the RovingFocusItem pattern.
  */
 interface NgpRovingFocusItemState {
+    /**
+     * The unique id of the roving focus item.
+     */
     readonly id: Signal<string>;
+    /**
+     * Whether the item is disabled.
+     */
     readonly disabled: Signal<boolean>;
+    /**
+     * The tabindex of the roving focus item.
+     */
     readonly tabindex: Signal<number>;
+    /**
+     * The element reference of the roving focus item.
+     */
     readonly element: ElementRef<HTMLElement>;
+    /**
+     * Focus the roving focus item.
+     * @param origin The focus origin
+     */
     focus(origin: FocusOrigin): void;
 }
 /**
@@ -30,10 +46,12 @@ declare const injectRovingFocusItemState: {
     (options: {
         hoisted: true;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<NgpRovingFocusItemState | null>;
     (options?: {
         hoisted?: boolean;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<NgpRovingFocusItemState> | Signal<NgpRovingFocusItemState | null>;
 };
 declare const provideRovingFocusItemState: (opts?: {
@@ -41,23 +59,75 @@ declare const provideRovingFocusItemState: (opts?: {
 }) => _angular_core.FactoryProvider;
 
 interface NgpRovingFocusGroupState {
-    orientation: Signal<NgpOrientation>;
-    wrap: Signal<boolean>;
-    homeEnd: Signal<boolean>;
-    disabled: Signal<boolean>;
-    activeItem: Signal<string | null>;
+    /**
+     * The orientation of the roving focus group.
+     */
+    readonly orientation: Signal<NgpOrientation>;
+    /**
+     * Whether the roving focus group should wrap around.
+     */
+    readonly wrap: Signal<boolean>;
+    /**
+     * Whether the Home and End keys are enabled.
+     */
+    readonly homeEnd: Signal<boolean>;
+    /**
+     * Whether the roving focus group is disabled.
+     */
+    readonly disabled: Signal<boolean>;
+    /**
+     * The id of the currently active item.
+     */
+    readonly activeItem: Signal<string | null>;
+    /**
+     * Handle keyboard navigation.
+     * @param event The keyboard event
+     */
     onKeydown(event: KeyboardEvent): void;
+    /**
+     * Set the active item by id.
+     * @param id The id of the item to activate
+     * @param origin The origin of the focus change
+     */
     setActiveItem(id: string | null, origin?: FocusOrigin): void;
+    /**
+     * Register an item with the roving focus group.
+     * @param item The item to register
+     */
     register(item: NgpRovingFocusItemState): void;
+    /**
+     * Unregister an item from the roving focus group.
+     * @param item The item to unregister
+     * @internal
+     */
     unregister(item: NgpRovingFocusItemState): void;
+    /**
+     * Set the orientation of the roving focus group.
+     * @param orientation The orientation value
+     */
     setOrientation(orientation: NgpOrientation): void;
 }
 interface NgpRovingFocusGroupProps {
-    orientation?: Signal<NgpOrientation>;
-    wrap?: Signal<boolean>;
-    homeEnd?: Signal<boolean>;
-    disabled?: Signal<boolean>;
-    inherit?: boolean;
+    /**
+     * The orientation of the roving focus group.
+     */
+    readonly orientation?: Signal<NgpOrientation>;
+    /**
+     * Whether the roving focus group should wrap around.
+     */
+    readonly wrap?: Signal<boolean>;
+    /**
+     * Whether the Home and End keys are enabled.
+     */
+    readonly homeEnd?: Signal<boolean>;
+    /**
+     * Whether the roving focus group is disabled.
+     */
+    readonly disabled?: Signal<boolean>;
+    /**
+     * Whether to inherit state from a parent roving focus group.
+     */
+    readonly inherit?: boolean;
 }
 declare const NgpRovingFocusGroupStateToken: _angular_core.InjectionToken<_angular_core.WritableSignal<NgpRovingFocusGroupState>>;
 declare const ngpRovingFocusGroup: ({ orientation: _orientation, wrap, homeEnd, disabled, inherit, }: NgpRovingFocusGroupProps) => NgpRovingFocusGroupState;
@@ -66,10 +136,12 @@ declare const injectRovingFocusGroupState: {
     (options: {
         hoisted: true;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<NgpRovingFocusGroupState | null>;
     (options?: {
         hoisted?: boolean;
         optional?: boolean;
+        skipSelf?: boolean;
     }): Signal<NgpRovingFocusGroupState> | Signal<NgpRovingFocusGroupState | null>;
 };
 declare const provideRovingFocusGroupState: (opts?: {

package/separator/index.d.ts

@@ -22,6 +22,7 @@ declare class NgpSeparator {
      * The orientation of the separator.
      */
     readonly orientation: i0.InputSignal<NgpOrientation>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<NgpSeparator, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgpSeparator, "[ngpSeparator]", ["ngpSeparator"], { "orientation": { "alias": "ngpSeparatorOrientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }