@radix-ng/primitives 0.42.0 → 0.44.0

package/navigation-menu/index.d.ts

@@ -1,28 +1,405 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/navigation-menu.directive";
-import * as i2 from "./src/navigation-menu-sub.directive";
-import * as i3 from "./src/navigation-menu-list.directive";
-import * as i4 from "./src/navigation-menu-item.directive";
-import * as i5 from "./src/navigation-menu-trigger.directive";
-import * as i6 from "./src/navigation-menu-link.directive";
-import * as i7 from "./src/navigation-menu-indicator.directive";
-import * as i8 from "./src/navigation-menu-content.directive";
-import * as i9 from "./src/navigation-menu-viewport.directive";
-import * as i10 from "./src/navigation-menu-a11y.component";
-export * from './src/navigation-menu-a11y.component';
-export * from './src/navigation-menu-content.directive';
-export * from './src/navigation-menu-indicator.directive';
-export * from './src/navigation-menu-item.directive';
-export * from './src/navigation-menu-link.directive';
-export * from './src/navigation-menu-list.directive';
-export * from './src/navigation-menu-sub.directive';
-export * from './src/navigation-menu-trigger.directive';
-export * from './src/navigation-menu-viewport.directive';
-export * from './src/navigation-menu.directive';
-export * from './src/navigation-menu.token';
-export * from './src/navigation-menu.types';
-export declare class RdxNavigationMenuModule {
+import * as i0 from '@angular/core';
+import { OnDestroy, WritableSignal, ElementRef, Signal, AfterContentInit, AfterViewInit, InjectionToken, Type, Provider, OnInit, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+import { FocusableOption, FocusKeyManager } from '@angular/cdk/a11y';
+import * as i1 from '@radix-ng/primitives/roving-focus';
+
+declare enum RdxNavigationMenuAnimationStatus {
+    OPEN_STARTED = "open_started",
+    OPEN_ENDED = "open_ended",
+    CLOSED_STARTED = "closed_started",
+    CLOSED_ENDED = "closed_ended"
+}
+/**
+ * A stub class solely used to query a single type of focusable element in the navigation menu.
+ */
+declare abstract class RdxNavigationMenuFocusableOption implements FocusableOption {
+    focus(): void;
+}
+
+declare enum RdxNavigationMenuAction {
+    OPEN = "open",
+    CLOSE = "close"
+}
+declare class RdxNavigationMenuDirective implements OnDestroy {
+    #private;
+    private readonly elementRef;
+    private readonly document;
+    private readonly window;
+    readonly baseId: string;
+    userDismissedByClick: () => boolean;
+    resetUserDismissed: () => void;
+    private openTimerRef;
+    private closeTimerRef;
+    private skipDelayTimerRef;
+    private recentlyActivatedTimerRef;
+    private readonly recentlyActivatedItem;
+    private documentMouseLeaveHandler;
+    readonly actionSubject$: Subject<{
+        action: RdxNavigationMenuAction;
+        itemValue?: string;
+    }>;
+    orientation: 'horizontal' | 'vertical';
+    dir: 'ltr' | 'rtl';
+    clickIgnoreDuration: number;
+    delayDuration: number;
+    skipDelayDuration: number;
+    loop: boolean;
+    cssAnimation: boolean;
+    cssOpeningAnimation: boolean;
+    cssClosingAnimation: boolean;
+    readonly isRootMenu = true;
+    readonly cssAnimationStatus: WritableSignal<RdxNavigationMenuAnimationStatus | null>;
+    value: () => string;
+    previousValue: () => string;
+    rootNavigationMenu: () => HTMLElement | null;
+    indicatorTrack: () => HTMLElement | null;
+    viewport: () => HTMLElement | null;
+    viewportContent: () => Map<string, any>;
+    setTriggerPointerState: (isOver: boolean) => void;
+    setContentPointerState: (isOver: boolean) => void;
+    isPointerInSystem: () => boolean;
+    getCssAnimation: () => boolean;
+    getCssOpeningAnimation: () => boolean;
+    getCssClosingAnimation: () => boolean;
+    constructor();
+    ngOnDestroy(): void;
+    onIndicatorTrackChange(track: HTMLElement | null): void;
+    onViewportChange(viewport: HTMLElement | null): void;
+    onTriggerEnter(itemValue: string): void;
+    onTriggerLeave(): void;
+    onContentEnter(): void;
+    onContentLeave(): void;
+    handleClose(): void;
+    onItemSelect(itemValue: string): void;
+    onItemDismiss(): void;
+    onViewportContentChange(contentValue: string, contentData: any): void;
+    onViewportContentRemove(contentValue: string): void;
+    private setValue;
+    private startCloseTimer;
+    private handleOpen;
+    private handleDelayedOpen;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuDirective, "[rdxNavigationMenu]", ["rdxNavigationMenu"], { "orientation": { "alias": "orientation"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "clickIgnoreDuration": { "alias": "clickIgnoreDuration"; "required": false; }; "delayDuration": { "alias": "delayDuration"; "required": false; }; "skipDelayDuration": { "alias": "skipDelayDuration"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "cssAnimation": { "alias": "cssAnimation"; "required": false; }; "cssOpeningAnimation": { "alias": "cssOpeningAnimation"; "required": false; }; "cssClosingAnimation": { "alias": "cssClosingAnimation"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_clickIgnoreDuration: unknown;
+    static ngAcceptInputType_delayDuration: unknown;
+    static ngAcceptInputType_skipDelayDuration: unknown;
+    static ngAcceptInputType_loop: unknown;
+    static ngAcceptInputType_cssAnimation: unknown;
+    static ngAcceptInputType_cssOpeningAnimation: unknown;
+    static ngAcceptInputType_cssClosingAnimation: unknown;
+}
+
+declare class RdxNavigationMenuSubDirective {
+    readonly orientation: i0.InputSignal<"horizontal" | "vertical">;
+    set defaultValue(val: string);
+    readonly valueChange: i0.OutputEmitterRef<string>;
+    readonly value: i0.WritableSignal<string>;
+    readonly previousValue: i0.WritableSignal<string>;
+    readonly baseId: string;
+    readonly isRootMenu = false;
+    private readonly parent;
+    get dir(): 'ltr' | 'rtl';
+    get rootNavigationMenu(): HTMLElement | null;
+    onTriggerEnter(itemValue: string): void;
+    onItemSelect(itemValue: string): void;
+    onItemDismiss(): void;
+    private setValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuSubDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuSubDirective, "[rdxNavigationMenuSub]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class RdxNavigationMenuItemDirective implements FocusableOption {
+    readonly elementRef: ElementRef<any>;
+    private readonly context;
+    readonly value: i0.InputSignal<string>;
+    /**
+     * @ignore
+     */
+    readonly triggerOrLink: Signal<RdxNavigationMenuFocusableOption | undefined>;
+    readonly triggerRef: i0.WritableSignal<HTMLElement | null>;
+    readonly contentRef: i0.WritableSignal<HTMLElement | null>;
+    readonly focusProxyRef: i0.WritableSignal<HTMLElement | null>;
+    readonly wasEscapeCloseRef: i0.WritableSignal<boolean>;
+    private readonly _restoreContentTabOrderRef;
+    get restoreContentTabOrderRef(): Signal<(() => void) | null>;
+    /**
+     * Handle keyboard entry into content from trigger
+     */
+    onEntryKeyDown(): void;
+    focus(): void;
+    /**
+     * Ensure elements are in the tab order by restoring any previously removed tabindex values
+     */
+    private ensureTabOrder;
+    /**
+     * Handle focus coming from the focus proxy element
+     * @param side Which side the focus is coming from (start = from trigger, end = from after content)
+     */
+    onFocusProxyEnter(side?: 'start' | 'end'): void;
+    /**
+     * Handle focus moving outside of the content
+     * Remove elements from tab order when not focused
+     */
+    onContentFocusOutside(): void;
+    /**
+     * Handle content being closed from root menu
+     */
+    onRootContentClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuItemDirective, "[rdxNavigationMenuItem]", ["rdxNavigationMenuItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, ["triggerOrLink"], never, true, never>;
+}
+
+declare class RdxNavigationMenuListDirective implements AfterContentInit, AfterViewInit {
+    private readonly context;
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly rovingFocusGroup;
+    /**
+     * @private
+     * @ignore
+     */
+    readonly items: i0.Signal<readonly any[]>;
+    /**
+     * @ignore
+     */
+    protected keyManager: FocusKeyManager<RdxNavigationMenuItemDirective>;
+    /**
+     * @ignore
+     */
+    ngAfterContentInit(): void;
+    /**
+     * @ignore
+     */
+    ngAfterViewInit(): void;
+    /**
+     * @ignore
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /**
+     * @ignore
+     */
+    setActiveItem(item: RdxNavigationMenuItemDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuListDirective, "[rdxNavigationMenuList]", never, {}, {}, ["items"], never, true, [{ directive: typeof i1.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
+}
+
+interface NavigationMenuContext {
+    isRootMenu: boolean;
+    value: () => string;
+    previousValue: () => string;
+    baseId: string;
+    dir: 'ltr' | 'rtl';
+    orientation: 'horizontal' | 'vertical';
+    loop: boolean;
+    rootNavigationMenu: () => HTMLElement | null;
+    indicatorTrack?: () => HTMLElement | null;
+    onIndicatorTrackChange?: (track: HTMLElement | null) => void;
+    userDismissedByClick?: () => boolean;
+    resetUserDismissed?: () => void;
+    viewport?: () => HTMLElement | null;
+    onViewportChange?: (viewport: HTMLElement | null) => void;
+    viewportContent?: () => Map<string, any>;
+    onViewportContentChange?: (contentValue: string, contentData: any) => void;
+    onViewportContentRemove?: (contentValue: string) => void;
+    onTriggerEnter?: (itemValue: string) => void;
+    onTriggerLeave?: () => void;
+    onContentEnter?: () => void;
+    onContentLeave?: () => void;
+    onItemSelect?: (itemValue: string) => void;
+    onItemDismiss?: () => void;
+    handleClose?: (force?: boolean) => void;
+    setTriggerPointerState?: (isOver: boolean) => void;
+    setContentPointerState?: (isOver: boolean) => void;
+    isPointerInSystem?: () => boolean;
+}
+declare const RDX_NAVIGATION_MENU_TOKEN: InjectionToken<NavigationMenuContext>;
+declare function injectNavigationMenu(): NavigationMenuContext;
+declare function isRootNavigationMenu(context: NavigationMenuContext): boolean;
+declare function provideNavigationMenuContext(provider: Type<RdxNavigationMenuDirective | RdxNavigationMenuSubDirective>): Provider;
+
+declare class RdxNavigationMenuTriggerDirective extends RdxNavigationMenuFocusableOption implements OnInit, OnDestroy {
+    protected readonly context: NavigationMenuContext;
+    private readonly item;
+    private readonly list;
+    private readonly rovingFocusItem;
+    private readonly elementRef;
+    private readonly viewContainerRef;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly openOnHover: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly triggerId: string;
+    readonly contentId: string;
+    readonly open: i0.Signal<boolean>;
+    private focusProxyRef;
+    private ariaOwnsRef;
+    private hasPointerMoveOpened;
+    private wasClickClose;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    private createAccessibilityComponents;
+    private removeAccessibilityComponents;
+    onPointerEnter(): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerLeave(event: PointerEvent): void;
+    onClick(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuTriggerDirective, "[rdxNavigationMenuTrigger]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxNavigationMenuLinkDirective extends RdxNavigationMenuFocusableOption implements OnInit {
+    private readonly rovingFocusItem;
+    private readonly uniqueId;
+    readonly active: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly onSelect: i0.InputSignal<((event: Event) => void) | undefined>;
+    readonly elementRef: ElementRef<any>;
+    ngOnInit(): void;
+    focus(): void;
+    onClick(event: MouseEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuLinkDirective, "[rdxNavigationMenuLink]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "onSelect": { "alias": "onSelect"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxRovingFocusItemDirective; inputs: { "focusable": "focusable"; }; outputs: {}; }]>;
+}
+
+declare class RdxNavigationMenuIndicatorDirective implements OnDestroy {
+    private readonly context;
+    private readonly elementRef;
+    private readonly renderer;
+    /**
+     * Used to keep the indicator rendered and available in the DOM, even when hidden.
+     * Useful for animations.
+     * @default false
+     */
+    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
+    /** @ignore */
+    private readonly _position;
+    /** @ignore */
+    private readonly _activeTrigger;
+    /** @ignore */
+    private readonly _resizeObserver;
+    readonly isVisible: i0.Signal<boolean>;
+    constructor();
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    private findAndSetActiveTrigger;
+    /** @ignore */
+    private updatePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuIndicatorDirective, "[rdxNavigationMenuIndicator]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxNavigationMenuContentDirective implements OnInit, OnDestroy {
+    private readonly elementRef;
+    private readonly ngZone;
+    private readonly template;
+    private readonly document;
+    private readonly item;
+    private readonly context;
+    set rdxNavigationMenuContent(value: boolean);
+    /**
+     * Used to keep the content rendered and available in the DOM, even when closed.
+     * Useful for animations or SEO.
+     * @default false
+     */
+    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
+    /** @ignore */
+    readonly contentId: string;
+    /** @ignore */
+    readonly triggerId: string;
+    private escapeHandler;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore - Compute motion attribute for animations */
+    getMotionAttribute(): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuContentDirective, "[rdxNavigationMenuContent]", never, { "rdxNavigationMenuContent": { "alias": "rdxNavigationMenuContent"; "required": false; }; "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_rdxNavigationMenuContent: unknown;
+}
+
+declare class RdxNavigationMenuViewportDirective implements OnInit, OnDestroy {
+    private readonly context;
+    private readonly document;
+    private readonly window;
+    private readonly elementRef;
+    private readonly viewContainerRef;
+    private readonly renderer;
+    private readonly zone;
+    private readonly destroyRef;
+    /**
+     * Used to keep the viewport rendered and available in the DOM, even when closed.
+     * Useful for animations.
+     * @default false
+     */
+    readonly forceMount: i0.InputSignalWithTransform<boolean, unknown>;
+    private readonly _contentNodes;
+    private readonly _activeContentNode;
+    private readonly _leavingContentNode;
+    private readonly _viewportSize;
+    readonly activeContentValue: i0.Signal<string | null>;
+    readonly isOpen: i0.Signal<boolean>;
+    readonly dataState: i0.Signal<"open" | "closed">;
+    readonly viewportSize: i0.Signal<{
+        width: number;
+        height: number;
+    } | null>;
+    private readonly _resizeObserver;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onKeydown(event: KeyboardEvent): void;
+    onPointerEnter(): void;
+    onPointerLeave(): void;
+    private setupViewportEffect;
+    private getOrCreateContentNode;
+    private addNodeToDOM;
+    private removeNodeFromDOM;
+    private setNodeState;
+    private applyA11yAttributes;
+    private startLeaveTransition;
+    /**
+     * Cleanup function called after leave animation finishes
+     * @param node The node that is leaving
+     */
+    private cleanupAfterLeave;
+    /**
+     * Cancels an ongoing leave transition (e.g., if user hovers back)
+     * @param node The node that is leaving
+     */
+    private cancelLeaveTransition;
+    /**
+     * Force completes a leave transition (e.g., if another leave starts)
+     * @param node The node that is leaving
+     */
+    private forceCompleteLeaveTransition;
+    private updateSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuViewportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxNavigationMenuViewportDirective, "[rdxNavigationMenuViewport]", never, { "forceMount": { "alias": "forceMount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxNavigationMenuFocusProxyComponent {
+    triggerElement: HTMLElement | null;
+    contentElement: HTMLElement | null;
+    proxyFocus: EventEmitter<"start" | "end">;
+    onFocus(event: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuFocusProxyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxNavigationMenuFocusProxyComponent, "rdx-navigation-menu-focus-proxy", never, { "triggerElement": { "alias": "triggerElement"; "required": false; }; "contentElement": { "alias": "contentElement"; "required": false; }; }, { "proxyFocus": "proxyFocus"; }, never, never, true, never>;
+}
+declare class RdxNavigationMenuAriaOwnsComponent {
+    contentId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuAriaOwnsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RdxNavigationMenuAriaOwnsComponent, "rdx-navigation-menu-aria-owns", never, { "contentId": { "alias": "contentId"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxNavigationMenuModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxNavigationMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxNavigationMenuModule, never, [typeof i1.RdxNavigationMenuDirective, typeof i2.RdxNavigationMenuSubDirective, typeof i3.RdxNavigationMenuListDirective, typeof i4.RdxNavigationMenuItemDirective, typeof i5.RdxNavigationMenuTriggerDirective, typeof i6.RdxNavigationMenuLinkDirective, typeof i7.RdxNavigationMenuIndicatorDirective, typeof i8.RdxNavigationMenuContentDirective, typeof i9.RdxNavigationMenuViewportDirective, typeof i10.RdxNavigationMenuFocusProxyComponent, typeof i10.RdxNavigationMenuAriaOwnsComponent], [typeof i1.RdxNavigationMenuDirective, typeof i2.RdxNavigationMenuSubDirective, typeof i3.RdxNavigationMenuListDirective, typeof i4.RdxNavigationMenuItemDirective, typeof i5.RdxNavigationMenuTriggerDirective, typeof i6.RdxNavigationMenuLinkDirective, typeof i7.RdxNavigationMenuIndicatorDirective, typeof i8.RdxNavigationMenuContentDirective, typeof i9.RdxNavigationMenuViewportDirective, typeof i10.RdxNavigationMenuFocusProxyComponent, typeof i10.RdxNavigationMenuAriaOwnsComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxNavigationMenuModule, never, [typeof RdxNavigationMenuDirective, typeof RdxNavigationMenuSubDirective, typeof RdxNavigationMenuListDirective, typeof RdxNavigationMenuItemDirective, typeof RdxNavigationMenuTriggerDirective, typeof RdxNavigationMenuLinkDirective, typeof RdxNavigationMenuIndicatorDirective, typeof RdxNavigationMenuContentDirective, typeof RdxNavigationMenuViewportDirective, typeof RdxNavigationMenuFocusProxyComponent, typeof RdxNavigationMenuAriaOwnsComponent], [typeof RdxNavigationMenuDirective, typeof RdxNavigationMenuSubDirective, typeof RdxNavigationMenuListDirective, typeof RdxNavigationMenuItemDirective, typeof RdxNavigationMenuTriggerDirective, typeof RdxNavigationMenuLinkDirective, typeof RdxNavigationMenuIndicatorDirective, typeof RdxNavigationMenuContentDirective, typeof RdxNavigationMenuViewportDirective, typeof RdxNavigationMenuFocusProxyComponent, typeof RdxNavigationMenuAriaOwnsComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxNavigationMenuModule>;
 }
+
+export { RDX_NAVIGATION_MENU_TOKEN, RdxNavigationMenuAction, RdxNavigationMenuAnimationStatus, RdxNavigationMenuAriaOwnsComponent, RdxNavigationMenuContentDirective, RdxNavigationMenuDirective, RdxNavigationMenuFocusProxyComponent, RdxNavigationMenuFocusableOption, RdxNavigationMenuIndicatorDirective, RdxNavigationMenuItemDirective, RdxNavigationMenuLinkDirective, RdxNavigationMenuListDirective, RdxNavigationMenuModule, RdxNavigationMenuSubDirective, RdxNavigationMenuTriggerDirective, RdxNavigationMenuViewportDirective, injectNavigationMenu, isRootNavigationMenu, provideNavigationMenuContext };
+export type { NavigationMenuContext };

package/number-field/index.d.ts

@@ -1,17 +1,203 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./src/number-field-root.directive";
-import * as i2 from "./src/number-field-input.directive";
-import * as i3 from "./src/number-field-increment.directive";
-import * as i4 from "./src/number-field-decrement.directive";
-export * from './src/number-field-context.token';
-export * from './src/number-field-decrement.directive';
-export * from './src/number-field-increment.directive';
-export * from './src/number-field-input.directive';
-export * from './src/number-field-root.directive';
-export * from './src/types';
-export * from './src/utils';
-export declare class RdxNumberFieldModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxNumberFieldModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxNumberFieldModule, never, [typeof i1.RdxNumberFieldRootDirective, typeof i2.RdxNumberFieldInputDirective, typeof i3.RdxNumberFieldIncrementDirective, typeof i4.RdxNumberFieldDecrementDirective], [typeof i1.RdxNumberFieldRootDirective, typeof i2.RdxNumberFieldInputDirective, typeof i3.RdxNumberFieldIncrementDirective, typeof i4.RdxNumberFieldDecrementDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxNumberFieldModule>;
+import * as _angular_core from '@angular/core';
+import { ModelSignal, InputSignal, Signal, InputSignalWithTransform, InjectionToken, OnInit } from '@angular/core';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { NumberFormatter, NumberParser } from '@internationalized/number';
+
+type InputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+
+interface NumberFieldContextToken {
+    value: ModelSignal<number | undefined>;
+    locale: InputSignal<string>;
+    inputMode: Signal<InputMode>;
+    textValue: Signal<any>;
+    readonly: InputSignalWithTransform<boolean, BooleanInput>;
+    max: InputSignalWithTransform<number | undefined, NumberInput>;
+    min: InputSignalWithTransform<number | undefined, NumberInput>;
+    onInputElement: (el: HTMLInputElement) => void;
+    disabled: InputSignalWithTransform<boolean, BooleanInput>;
+    disableWheelChange: InputSignalWithTransform<boolean, BooleanInput>;
+    handleIncrease: (multiplier?: number) => void;
+    handleDecrease: (multiplier?: number) => void;
+    applyInputValue: (val: string) => void;
+    validate: (val: string) => boolean;
+    setInputValue: (val: string) => void;
+    isIncreaseDisabled: Signal<boolean>;
+    isDecreaseDisabled: Signal<boolean>;
+    handleMinMaxValue: (type: 'min' | 'max') => void;
 }
+declare const NUMBER_FIELD_ROOT_CONTEXT: InjectionToken<NumberFieldContextToken>;
+declare function injectNumberFieldRootContext(): NumberFieldContextToken;
+
+declare class RdxNumberFieldRootDirective implements OnInit, NumberFieldContextToken {
+    readonly value: _angular_core.ModelSignal<number | undefined>;
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly step: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly stepSnapping: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly disableWheelChange: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly formatOptions: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    /**
+     * When <code>true</code>, the Number Field is read-only.
+     */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @ignore
+     */
+    readonly inputEl: _angular_core.WritableSignal<HTMLInputElement | undefined>;
+    /**
+     * @ignore
+     */
+    readonly isDecreaseDisabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly isIncreaseDisabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly inputMode: _angular_core.Signal<InputMode>;
+    /**
+     * Replace negative textValue formatted using currencySign: 'accounting'
+     * with a textValue that can be announced using a minus sign.
+     * @ignore
+     */
+    readonly textValue: _angular_core.Signal<any>;
+    /**
+     * @ignore
+     */
+    readonly onInputElement: (el: HTMLInputElement) => void;
+    /**
+     * @ignore
+     */
+    numberParser: any;
+    /**
+     * @ignore
+     */
+    numberFormatter: any;
+    /**
+     * @ignore
+     */
+    textValueFormatter: any;
+    /**
+     * @ignore
+     */
+    clampInputValue(val: number): number;
+    ngOnInit(): void;
+    /**
+     * @ignore
+     */
+    handleMinMaxValue(type: 'min' | 'max'): void;
+    /**
+     * @ignore
+     */
+    handleDecrease(multiplier?: number): void;
+    /**
+     * @ignore
+     */
+    handleIncrease(multiplier?: number): void;
+    /**
+     * @ignore
+     */
+    applyInputValue(val: string): void;
+    /**
+     * @ignore
+     */
+    setInputValue(val: string): void;
+    /**
+     * @ignore
+     */
+    validate(val: string): any;
+    private handleChangingValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldRootDirective, "[rdxNumberFieldRoot]", ["rdxNumberFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "stepSnapping": { "alias": "stepSnapping"; "required": false; "isSignal": true; }; "disableWheelChange": { "alias": "disableWheelChange"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class RdxNumberFieldInputDirective implements OnInit {
+    private readonly elementRef;
+    protected readonly rootContext: NumberFieldContextToken;
+    readonly inputValue: _angular_core.WritableSignal<any>;
+    constructor();
+    ngOnInit(): void;
+    onBeforeInput(event: InputEvent): void;
+    onWheelEvent(event: WheelEvent): void;
+    onKeydownPageUp(event: KeyboardEvent): void;
+    onKeydownPageDown(event: KeyboardEvent): void;
+    onKeydownHome(event: KeyboardEvent): void;
+    onKeydownEnd(event: KeyboardEvent): void;
+    onInput(event: InputEvent): void;
+    onChange(): void;
+    onKeydownEnter(event: KeyboardEvent): void;
+    onKeydownUp(event: KeyboardEvent): void;
+    onKeydownDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldInputDirective, "input[rdxNumberFieldInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxNumberFieldIncrementDirective implements OnInit {
+    private readonly elementRef;
+    private readonly pressedHold;
+    protected readonly rootContext: NumberFieldContextToken;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @ignore
+     */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly useHold: {
+        isPressed: _angular_core.Signal<boolean>;
+        onTrigger: (fn: () => void) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldIncrementDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldIncrementDirective, "button[rdxNumberFieldIncrement]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxNumberFieldDecrementDirective implements OnInit {
+    private readonly elementRef;
+    private readonly pressedHold;
+    protected readonly rootContext: NumberFieldContextToken;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * @ignore
+     */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    readonly useHold: {
+        isPressed: _angular_core.Signal<boolean>;
+        onTrigger: (fn: () => void) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldDecrementDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxNumberFieldDecrementDirective, "button[rdxNumberFieldDecrement]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class PressedHoldService {
+    private readonly destroyRef;
+    create(options: {
+        target?: Signal<HTMLElement | undefined>;
+        disabled: Signal<boolean>;
+    }): {
+        isPressed: Signal<boolean>;
+        onTrigger: (fn: () => void) => void;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PressedHoldService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PressedHoldService>;
+}
+declare function useNumberFormatter(locale: Signal<string>, options?: Signal<Intl.NumberFormatOptions | undefined>): Signal<NumberFormatter>;
+declare function useNumberParser(locale: Signal<string>, options?: Signal<Intl.NumberFormatOptions | undefined>): Signal<NumberParser>;
+declare function handleDecimalOperation(operator: '-' | '+', value1: number, value2: number): number;
+
+declare class RdxNumberFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNumberFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxNumberFieldModule, never, [typeof RdxNumberFieldRootDirective, typeof RdxNumberFieldInputDirective, typeof RdxNumberFieldIncrementDirective, typeof RdxNumberFieldDecrementDirective], [typeof RdxNumberFieldRootDirective, typeof RdxNumberFieldInputDirective, typeof RdxNumberFieldIncrementDirective, typeof RdxNumberFieldDecrementDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxNumberFieldModule>;
+}
+
+export { NUMBER_FIELD_ROOT_CONTEXT, PressedHoldService, RdxNumberFieldDecrementDirective, RdxNumberFieldIncrementDirective, RdxNumberFieldInputDirective, RdxNumberFieldModule, RdxNumberFieldRootDirective, handleDecimalOperation, injectNumberFieldRootContext, useNumberFormatter, useNumberParser };
+export type { InputMode, NumberFieldContextToken };