@radix-ng/primitives 0.50.0 → 1.0.0-beta.0

package/types/radix-ng-primitives-toolbar.d.ts

@@ -0,0 +1,180 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/separator';
+import { DataOrientation, BooleanInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/roving-focus';
+import { Direction } from '@radix-ng/primitives/roving-focus';
+import * as _radix_ng_primitives_toolbar from '@radix-ng/primitives/toolbar';
+
+/**
+ * A separator between toolbar items or groups.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarSeparator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarSeparator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarSeparator, "[rdxToolbarSeparator]", ["rdxToolbarSeparator"], {}, {}, never, never, true, [{ directive: typeof i1.RdxSeparatorRootDirective; inputs: { "orientation": "orientation"; }; outputs: {}; }]>;
+}
+
+/**
+ * A container for grouping a set of controls, such as buttons, toggle groups or menus.
+ * Owns roving keyboard focus over its items.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarRoot {
+    /**
+     * The orientation of the toolbar.
+     *
+     * @default 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<DataOrientation>;
+    /** Text direction for arrow-key navigation. */
+    readonly dir: _angular_core.InputSignal<Direction>;
+    /**
+     * Whether keyboard navigation should loop from the last item back to the first.
+     *
+     * @default true
+     */
+    readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the whole toolbar is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    private readonly rovingFocusGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarRoot, "[rdxToolbarRoot]", ["rdxToolbarRoot"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusGroupDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A button within a toolbar.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarButton {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    private readonly groupContext;
+    private readonly rovingItem;
+    /**
+     * Whether the button is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the button stays focusable while disabled (so it remains discoverable for keyboard
+     * and screen-reader users).
+     *
+     * @default true
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the host is a native `<button>`. When `false`, adds `role="button"`.
+     *
+     * @default true
+     */
+    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore Effective disabled state, combining the button, group and toolbar. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    /** @ignore */
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarButton, "[rdxToolbarButton]", ["rdxToolbarButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A link within a toolbar.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarLink {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    /** @ignore Space activates a link, matching native button behavior in a toolbar. */
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarLink, "[rdxToolbarLink]", ["rdxToolbarLink"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A native input within a toolbar. Participates in the toolbar's roving focus while keeping native
+ * text-editing: the arrow keys move the caret within the text and only move focus to the
+ * neighbouring toolbar item once the caret is at the corresponding edge (Base UI "composite" input).
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarInput {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    private readonly groupContext;
+    private readonly rovingItem;
+    private readonly elementRef;
+    private readonly isBrowser;
+    /** The initial value of the uncontrolled input. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the input is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the input stays focusable while disabled.
+     *
+     * @default true
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private appliedDefault;
+    constructor();
+    private handleCaretKeydown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarInput, "input[rdxToolbarInput]", ["rdxToolbarInput"], { "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxRovingFocusItemDirective; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Groups several toolbar items together. Disabling the group disables all of its items.
+ *
+ * @see https://base-ui.com/react/components/toolbar
+ */
+declare class RdxToolbarGroup {
+    protected readonly rootContext: _radix_ng_primitives_toolbar.RdxToolbarRootContext;
+    /**
+     * Whether the group is disabled.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** @ignore Effective disabled state, combining the group and the toolbar. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxToolbarGroup, "[rdxToolbarGroup]", ["rdxToolbarGroup"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface RdxToolbarRootContext {
+    /** The orientation of the toolbar. */
+    readonly orientation: Signal<DataOrientation>;
+    /** Whether the whole toolbar is disabled. */
+    readonly disabled: Signal<boolean>;
+}
+declare const injectToolbarRootContext: (optional?: boolean) => RdxToolbarRootContext | null;
+declare const provideToolbarRootContext: (useFactory: () => RdxToolbarRootContext) => _angular_core.Provider;
+interface RdxToolbarGroupContext {
+    /** Whether the group (and therefore its items) is disabled. */
+    readonly disabled: Signal<boolean>;
+}
+declare const injectToolbarGroupContext: (optional?: boolean) => RdxToolbarGroupContext | null;
+declare const provideToolbarGroupContext: (useFactory: () => RdxToolbarGroupContext) => _angular_core.Provider;
+
+declare const toolbarImports: (typeof RdxToolbarSeparator)[];
+declare class RdxToolbarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxToolbarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxToolbarModule, never, [typeof RdxToolbarRoot, typeof RdxToolbarButton, typeof RdxToolbarLink, typeof RdxToolbarInput, typeof RdxToolbarGroup, typeof RdxToolbarSeparator], [typeof RdxToolbarRoot, typeof RdxToolbarButton, typeof RdxToolbarLink, typeof RdxToolbarInput, typeof RdxToolbarGroup, typeof RdxToolbarSeparator]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxToolbarModule>;
+}
+
+export { RdxToolbarButton, RdxToolbarGroup, RdxToolbarInput, RdxToolbarLink, RdxToolbarModule, RdxToolbarRoot, RdxToolbarSeparator, injectToolbarGroupContext, injectToolbarRootContext, provideToolbarGroupContext, provideToolbarRootContext, toolbarImports };
+export type { RdxToolbarGroupContext, RdxToolbarRootContext };

package/types/radix-ng-primitives-tooltip.d.ts

@@ -0,0 +1,395 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_tooltip from '@radix-ng/primitives/tooltip';
+import * as i1$2 from '@radix-ng/primitives/portal';
+import { RdxPortalContainer } from '@radix-ng/primitives/portal';
+import * as i1$3 from '@radix-ng/primitives/dismissable-layer';
+
+declare class RdxTooltipPortalPresence {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPortalPresence, "ng-template[rdxTooltipPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxPresenceDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxTooltipHandle<Payload = unknown> {
+    private readonly rootContext;
+    private readonly triggers;
+    private readonly rootTriggerCleanups;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    open(triggerId: string): void;
+    close(): void;
+    registerRoot(rootContext: RdxTooltipContext): () => void;
+    registerTrigger(id: string, trigger: HTMLElement, payload: () => Payload | undefined): () => void;
+    context(): RdxTooltipContext | undefined;
+}
+declare function createRdxTooltipHandle<Payload = unknown>(): RdxTooltipHandle<Payload>;
+
+type RdxTrackCursorAxis = 'none' | 'x' | 'y' | 'both';
+type RdxTooltipConfig = {
+    /**
+     * How long to wait before opening the tooltip. Specified in milliseconds.
+     * @defaultValue 600
+     */
+    delay?: number;
+    /**
+     * How long to wait before closing the tooltip. Specified in milliseconds.
+     * @defaultValue 0
+     */
+    closeDelay?: number;
+    /**
+     * Another tooltip within the same provider opens instantly when this window
+     * has not yet elapsed since the previous one closed. Specified in milliseconds.
+     * @defaultValue 400
+     */
+    timeout?: number;
+    /**
+     * When `true`, the tooltip closes as the pointer leaves the trigger instead of
+     * staying open while the pointer moves over the popup.
+     * @defaultValue false
+     */
+    disableHoverablePopup?: boolean;
+};
+declare const defaultTooltipConfig: Required<RdxTooltipConfig>;
+declare const RdxTooltipDefaultsToken: InjectionToken<RdxTooltipConfig>;
+declare function provideRdxTooltipConfig(config: Partial<RdxTooltipConfig>): Provider[];
+declare function injectRdxTooltipConfig(): Required<RdxTooltipConfig>;
+
+interface RdxTooltipContext {
+    contentId: string;
+    isOpen: Signal<boolean>;
+    /** Whether the tooltip opened/closed without waiting for the delay. */
+    instant: Signal<boolean>;
+    disabled: Signal<boolean>;
+    disableHoverablePopup: Signal<boolean>;
+    trackCursorAxis: Signal<RdxTrackCursorAxis>;
+    /** The active trigger element. */
+    trigger: Signal<HTMLElement | undefined>;
+    triggers: Signal<HTMLElement[]>;
+    payload: Signal<unknown>;
+    open: (trigger?: HTMLElement, payload?: unknown) => void;
+    close: () => void;
+    /** Closes after the resolved close delay (used when hover/focus is lost). */
+    closeDelayed: () => void;
+    registerTrigger: (trigger: HTMLElement) => () => void;
+    /** Hover entered a trigger — opens after the resolved delay (or instantly). */
+    onTriggerEnter: (trigger?: HTMLElement, payload?: unknown) => void;
+    /** Hover left a trigger — cancels a pending open and closes when appropriate. */
+    onTriggerLeave: () => void;
+    setCursorPosition: (position: {
+        x: number;
+        y: number;
+    } | undefined) => void;
+    setDelays: (delay: number | undefined, closeDelay: number | undefined) => void;
+}
+declare const injectRdxTooltipContext: (optional?: boolean) => RdxTooltipContext | null;
+declare const provideRdxTooltipContext: (useFactory: () => RdxTooltipContext) => _angular_core.Provider;
+declare class RdxTooltip {
+    private readonly defaultConfig;
+    private readonly provider;
+    private readonly popper;
+    private readonly destroyRef;
+    private hasAppliedDefaultOpen;
+    /**
+     * Whether the tooltip is currently open.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Whether the tooltip is initially open. Uncontrolled.
+     */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * How long to wait before opening the tooltip. Specified in milliseconds.
+     * Falls back to the surrounding provider, then to the global config.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * How long to wait before closing the tooltip. Specified in milliseconds.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * When `true`, the tooltip closes as the pointer leaves the trigger instead of
+     * staying open while the pointer moves over the popup.
+     */
+    readonly disableHoverablePopup: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Determines which axis the tooltip should track the cursor on.
+     */
+    readonly trackCursorAxis: _angular_core.InputSignal<RdxTrackCursorAxis>;
+    /**
+     * When `true`, the tooltip will not open.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Associates this root with detached trigger elements.
+     */
+    readonly handle: _angular_core.InputSignal<RdxTooltipHandle<any> | undefined>;
+    /**
+     * Event handler called when the open state changes.
+     */
+    readonly onOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly contentId: string;
+    readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
+    readonly payload: _angular_core.WritableSignal<unknown>;
+    readonly cursorPosition: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | undefined>;
+    private readonly openedInstant;
+    /** Local instant window used when this tooltip is not inside a provider. */
+    private readonly localInstant;
+    private readonly instantGroup;
+    /** Per-trigger overrides set by the active trigger, taking precedence over the root/provider. */
+    private readonly triggerDelay;
+    private readonly triggerCloseDelay;
+    private readonly resolvedDelay;
+    private readonly resolvedCloseDelay;
+    /** Whether the most recent open happened without the delay. */
+    readonly instant: Signal<boolean>;
+    private readonly virtualAnchor;
+    private readonly openTimer;
+    private readonly closeTimer;
+    constructor();
+    /** Opens immediately, optionally switching the active trigger/payload. */
+    show(trigger?: HTMLElement | undefined, payload?: unknown): void;
+    close(): void;
+    /** Closes after the resolved close delay, e.g. when the pointer or focus leaves. */
+    scheduleClose(): void;
+    /** Hover/focus entered — open after the delay, or instantly within the instant window. */
+    onTriggerEnter(trigger?: HTMLElement | undefined, payload?: unknown): void;
+    onTriggerLeave(): void;
+    registerTrigger(trigger: HTMLElement): () => void;
+    setCursorPosition(position: {
+        x: number;
+        y: number;
+    } | undefined): void;
+    /** Applies per-trigger delay overrides from the trigger that is becoming active. */
+    setDelays(delay: number | undefined, closeDelay: number | undefined): void;
+    private applyOpen;
+    private applyClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltip, "[rdxTooltip]", ["rdxTooltip"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disableHoverablePopup": { "alias": "disableHoverablePopup"; "required": false; "isSignal": true; }; "trackCursorAxis": { "alias": "trackCursorAxis"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxTooltipArrow {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    protected readonly uncentered: _angular_core.Signal<boolean>;
+    protected readonly isVisuallyHidden: boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipArrow, "[rdxTooltipArrow]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperArrow; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * The tooltip popup. Renders the content with `role="tooltip"`.
+ */
+declare class RdxTooltipPopup {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    private readonly wrapper;
+    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPopup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPopup, "[rdxTooltipPopup]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Moves the tooltip to a different part of the DOM.
+ */
+declare class RdxTooltipPortal {
+    readonly container: _angular_core.InputSignal<RdxPortalContainer>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPortal, "[rdxTooltipPortal]", never, { "container": { "alias": "container"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$2.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * Positions the tooltip popup against its trigger (or a custom anchor).
+ */
+declare class RdxTooltipPositioner {
+    protected readonly rootContext: _radix_ng_primitives_tooltip.RdxTooltipContext;
+    protected readonly wrapper: RdxPopperContentWrapper;
+    private readonly destroyRef;
+    private readonly dismissableLayer;
+    private readonly elementRef;
+    /**
+     * An element to position the popup against. Defaults to the trigger.
+     */
+    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
+    /**
+     * The preferred side of the anchor to render against when open.
+     */
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    /**
+     * The distance in pixels from the anchor.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The preferred alignment against the anchor.
+     */
+    readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options.
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * The padding between the arrow and the edges of the content.
+     */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
+     */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The element used as the collision boundary.
+     */
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    /**
+     * The distance in pixels from the boundary edges where collision detection should occur.
+     */
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    /**
+     * The sticky behavior on the `align` axis.
+     */
+    readonly sticky: _angular_core.InputSignal<"partial" | "always">;
+    /**
+     * Whether to hide the content when the trigger becomes fully occluded.
+     */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The CSS position strategy used by Floating UI.
+     */
+    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
+    /**
+     * Whether to update the position of the floating element on every animation frame if required.
+     */
+    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
+    /**
+     * Emits when the element is placed.
+     */
+    readonly placed: _angular_core.OutputRef<void>;
+    /**
+     * Event handler called when the escape key is down. Can be prevented.
+     */
+    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
+    /**
+     * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`. Can be prevented.
+     */
+    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
+    private readonly triggerEl;
+    private readonly containerEl;
+    private readonly graceArea;
+    private readonly afterNextRender;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPositioner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPositioner, "[rdxTooltipPositioner]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; }, never, never, true, [{ directive: typeof i1$3.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+}
+
+type TooltipInstantController = {
+    /** Whether the next tooltip in the group should open without waiting for the delay. */
+    isInstant: Signal<boolean>;
+    /** Call when a tooltip opens — leaves the group in the instant phase. */
+    onOpen: () => void;
+    /** Call when a tooltip closes — keeps the group instant for `timeout` ms, then re-arms the delay. */
+    onClose: () => void;
+};
+
+interface RdxTooltipProviderContext {
+    /** Default open delay for tooltips in this group, in milliseconds. */
+    delay: Signal<number | undefined>;
+    /** Default close delay for tooltips in this group, in milliseconds. */
+    closeDelay: Signal<number | undefined>;
+    /** Whether sibling tooltips should currently open instantly. */
+    isInstant: Signal<boolean>;
+    /** Notifies the group that a tooltip has opened. */
+    onOpen: () => void;
+    /** Notifies the group that a tooltip has closed. */
+    onClose: () => void;
+}
+declare const injectRdxTooltipProviderContext: (optional?: boolean) => RdxTooltipProviderContext | null;
+declare const provideRdxTooltipProviderContext: (useFactory: () => RdxTooltipProviderContext) => _angular_core.Provider;
+/**
+ * Shares delay configuration and an instant-open window across a group of tooltips.
+ * Once one tooltip opens, adjacent ones open instantly until `timeout` ms after the last close.
+ */
+declare class RdxTooltipProvider {
+    private readonly defaultConfig;
+    private readonly destroyRef;
+    /**
+     * How long to wait before opening tooltips in this group. Specified in milliseconds.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * How long to wait before closing tooltips in this group. Specified in milliseconds.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * The window during which an adjacent tooltip opens instantly. Specified in milliseconds.
+     */
+    readonly timeout: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly instant: TooltipInstantController;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipProvider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipProvider, "[rdxTooltipProvider]", ["rdxTooltipProvider"], { "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "timeout": { "alias": "timeout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxTooltipTrigger {
+    private readonly parentRootContext;
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly generatedId;
+    /**
+     * Associates this trigger with a detached tooltip root.
+     */
+    readonly handle: _angular_core.InputSignal<RdxTooltipHandle<any> | undefined>;
+    /**
+     * Data associated with this trigger while it is active.
+     */
+    readonly payload: _angular_core.InputSignal<unknown>;
+    /**
+     * ID used to identify this trigger when opening a detached tooltip imperatively.
+     */
+    readonly id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the tooltip should close when the trigger is clicked.
+     * @defaultValue true
+     */
+    readonly closeOnClick: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether this trigger is disabled. A disabled trigger never opens the tooltip.
+     * @defaultValue false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Overrides the open delay (ms) for this trigger. Falls back to the root/provider/global delay.
+     */
+    readonly delay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Overrides the close delay (ms) for this trigger. Falls back to the root/provider/global delay.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    readonly userOnPointerDown: _angular_core.InputSignal<((event: PointerEvent) => void | boolean | Promise<void | boolean> | undefined) | undefined>;
+    protected readonly triggerId: _angular_core.Signal<string>;
+    protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_tooltip.RdxTooltipContext | null>;
+    /** Disabled if either the root or this trigger is disabled. */
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /** Whether this specific trigger is the active anchor of an open tooltip. */
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    private readonly isPointerDown;
+    private readonly hasPointerMoveOpened;
+    constructor();
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleClick(): void;
+    protected handlePointerMove(event: PointerEvent): void;
+    protected handlePointerLeave(): void;
+    protected handlePointerDown(event: PointerEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipTrigger, "[rdxTooltipTrigger]", never, { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "userOnPointerDown": { "alias": "rdxOnPointerDown"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
+}
+
+declare const tooltipImports: (typeof RdxTooltipPortalPresence)[];
+
+export { RdxTooltip, RdxTooltipArrow, RdxTooltipDefaultsToken, RdxTooltipHandle, RdxTooltipPopup, RdxTooltipPortal, RdxTooltipPortalPresence, RdxTooltipPositioner, RdxTooltipProvider, RdxTooltipTrigger, createRdxTooltipHandle, defaultTooltipConfig, injectRdxTooltipConfig, injectRdxTooltipContext, injectRdxTooltipProviderContext, provideRdxTooltipConfig, provideRdxTooltipContext, provideRdxTooltipProviderContext, tooltipImports };
+export type { RdxTooltipConfig, RdxTooltipContext, RdxTooltipProviderContext, RdxTrackCursorAxis };

package/{visually-hidden/index.d.ts → types/radix-ng-primitives-visually-hidden.d.ts}

@@ -40,25 +40,25 @@ declare class RdxVisuallyHiddenInputBubbleDirective<T> {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxVisuallyHiddenInputBubbleDirective<any>, "input[rdxVisuallyHiddenInputBubble]", never, { "feature": { "alias": "feature"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof RdxVisuallyHiddenDirective; inputs: { "feature": "feature"; }; outputs: {}; }]>;
 }
 
-declare class RdxVisuallyHiddenInputDirective<T> {
-    private readonly elementRef;
-    private readonly injector;
-    readonly name: _angular_core.InputSignal<string | undefined>;
-    readonly value: _angular_core.InputSignal<string | T | undefined>;
-    readonly checked: _angular_core.InputSignal<boolean | undefined>;
-    readonly required: _angular_core.InputSignal<boolean | undefined>;
-    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
-    readonly feature: _angular_core.InputSignal<VisuallyHidden>;
-    readonly parsedValue: _angular_core.Signal<{
-        name: string;
-        value: any;
-    }[] | {
-        name: string | undefined;
-        value: string | (T & number) | (T & boolean);
-    }[]>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxVisuallyHiddenInputDirective<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxVisuallyHiddenInputDirective<any>, "[rdxVisuallyHiddenInput]", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "feature": { "alias": "feature"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof RdxVisuallyHiddenInputBubbleDirective; inputs: { "feature": "feature"; "name": "name"; "value": "value"; "checked": "checked"; "disabled": "disabled"; "required": "required"; }; outputs: {}; }]>;
+/**
+ * Mirrors a control's value into a visually hidden `<input>` so it participates in form
+ * submission while staying out of the visual and (when `fully-hidden`) accessibility tree.
+ *
+ * Apply it to a real `<input>` element. It carries a **single scalar value** — the composed
+ * {@link RdxVisuallyHiddenInputBubbleDirective} owns `name`/`value`/`checked` and keeps the
+ * native value in sync, re-dispatching `input`/`change` events so the value bubbles to the form.
+ *
+ * A single `<input>` can only represent one form field, so object/array values are not
+ * supported here; render one directive per field instead.
+ *
+ * @example
+ * ```html
+ * <input rdxVisuallyHiddenInput [name]="'agree'" [value]="checked() ? 'on' : 'off'" />
+ * ```
+ */
+declare class RdxVisuallyHiddenInputDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxVisuallyHiddenInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxVisuallyHiddenInputDirective, "input[rdxVisuallyHiddenInput]", never, {}, {}, never, never, true, [{ directive: typeof RdxVisuallyHiddenInputBubbleDirective; inputs: { "feature": "feature"; "name": "name"; "value": "value"; "checked": "checked"; "required": "required"; "disabled": "disabled"; }; outputs: {}; }]>;
 }
 
 export { RdxVisuallyHiddenDirective, RdxVisuallyHiddenInputBubbleDirective, RdxVisuallyHiddenInputDirective };