@radix-ng/primitives 0.42.0 → 0.44.0

package/tooltip2/index.d.ts

@@ -0,0 +1,325 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, TemplateRef, InjectionToken, Provider } from '@angular/core';
+import * as i1 from '@radix-ng/primitives/presence';
+import * as _angular_cdk_coercion from '@angular/cdk/coercion';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i1$1 from '@radix-ng/primitives/popper';
+import * as _radix_ng_primitives_tooltip2 from '@radix-ng/primitives/tooltip2';
+import * as i1$2 from '@radix-ng/primitives/dismissable-layer';
+import * as i1$3 from '@radix-ng/primitives/portal';
+
+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: {}; }]>;
+}
+
+type TimeoutController = {
+    start: () => void;
+    stop: () => void;
+    isPending: () => boolean;
+};
+
+declare class RdxTooltipTrigger {
+    protected readonly rootContext: {
+        isOpen: _angular_core.ModelSignal<boolean>;
+        state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+        contentId: string;
+        trigger: _angular_core.Signal<RdxTooltipTrigger>;
+        isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+        isPointerInTransit: _angular_core.Signal<boolean>;
+        isControlledState: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        open(): void;
+        close(): void;
+        onTriggerEnter(): void;
+        onTriggerLeave(): void;
+    };
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly userOnPointerDown: _angular_core.InputSignal<((event: PointerEvent) => void | boolean | Promise<void | boolean> | undefined) | undefined>;
+    protected readonly isPointerDown: _angular_core.WritableSignal<boolean>;
+    private readonly hasPointerMoveOpened;
+    protected handleFocus(event: FocusEvent): 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, { "userOnPointerDown": { "alias": "rdxOnPointerDown"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
+}
+
+declare const context: () => {
+    isOpen: _angular_core.ModelSignal<boolean>;
+    state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+    contentId: string;
+    trigger: _angular_core.Signal<RdxTooltipTrigger>;
+    isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    isPointerInTransit: _angular_core.Signal<boolean>;
+    isControlledState: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    open(): void;
+    close(): void;
+    onTriggerEnter(): void;
+    onTriggerLeave(): void;
+};
+type RdxTooltipContext = ReturnType<typeof context>;
+declare const injectRdxTooltipContext: (optional?: boolean) => {
+    isOpen: _angular_core.ModelSignal<boolean>;
+    state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+    contentId: string;
+    trigger: _angular_core.Signal<RdxTooltipTrigger>;
+    isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    isPointerInTransit: _angular_core.Signal<boolean>;
+    isControlledState: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    open(): void;
+    close(): void;
+    onTriggerEnter(): void;
+    onTriggerLeave(): void;
+} | null;
+declare const provideRdxTooltipContext: (useFactory: () => {
+    isOpen: _angular_core.ModelSignal<boolean>;
+    state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+    contentId: string;
+    trigger: _angular_core.Signal<RdxTooltipTrigger>;
+    isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    isPointerInTransit: _angular_core.Signal<boolean>;
+    isControlledState: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    open(): void;
+    close(): void;
+    onTriggerEnter(): void;
+    onTriggerLeave(): void;
+}) => _angular_core.Provider;
+declare class RdxTooltip {
+    private readonly defaultConfig;
+    private readonly destroyRef;
+    /**
+     * Whether the tooltip is currently open.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * The duration from when the pointer enters the trigger until the tooltip gets opened.
+     */
+    readonly delayDuration: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * How much time a user has to enter another trigger without incurring a delay again.
+     * @defaultValue 300
+     */
+    readonly skipDelayDuration: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
+     */
+    readonly disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * When `true`, disable tooltip
+     * @defaultValue false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * How long to wait before closing the tooltip. Specified in milliseconds.
+     */
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /**
+     * When `true`, clicking on trigger will not close the content.
+     * @defaultValue false
+     */
+    readonly disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Prevent the tooltip from opening if the focus did not come from
+     * the keyboard by matching against the `:focus-visible` selector.
+     * This is useful if you want to avoid opening it when switching
+     * browser tabs or closing a dialog.
+     * @defaultValue false
+     */
+    readonly ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * To render a controlled tooltip
+     */
+    readonly isControlledState: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly isPointerInTransit: _angular_core.WritableSignal<boolean>;
+    readonly isOpenDelayed: _angular_core.WritableSignal<boolean>;
+    private readonly wasOpenDelayed;
+    readonly state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+    readonly trigger: _angular_core.Signal<RdxTooltipTrigger>;
+    readonly timerProvider: TimeoutController;
+    private readonly timer;
+    readonly startTimer: () => void;
+    readonly clearTimer: () => void;
+    constructor();
+    handleOpen(): void;
+    handleClose(): void;
+    handleDelayedOpen(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltip, "[rdxTooltip]", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "delayDuration": { "alias": "delayDuration"; "required": false; "isSignal": true; }; "skipDelayDuration": { "alias": "skipDelayDuration"; "required": false; "isSignal": true; }; "disableHoverableContent": { "alias": "disableHoverableContent"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disableClosingTrigger": { "alias": "disableClosingTrigger"; "required": false; "isSignal": true; }; "ignoreNonKeyboardFocus": { "alias": "ignoreNonKeyboardFocus"; "required": false; "isSignal": true; }; "isControlledState": { "alias": "isControlledState"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, ["trigger"], never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxTooltipArrow {
+    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: {}; }]>;
+}
+
+declare class RdxTooltipContent {
+    protected rootContext: {
+        isOpen: _angular_core.ModelSignal<boolean>;
+        state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+        contentId: string;
+        trigger: _angular_core.Signal<_radix_ng_primitives_tooltip2.RdxTooltipTrigger>;
+        isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+        isPointerInTransit: _angular_core.Signal<boolean>;
+        isControlledState: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        open(): void;
+        close(): void;
+        onTriggerEnter(): void;
+        onTriggerLeave(): void;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipContent, "[rdxTooltipContent]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxPopperContent; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxTooltipContentWrapper {
+    protected readonly rootContext: {
+        isOpen: _angular_core.ModelSignal<boolean>;
+        state: _angular_core.Signal<"closed" | "delayed-open" | "instant-open">;
+        contentId: string;
+        trigger: _angular_core.Signal<_radix_ng_primitives_tooltip2.RdxTooltipTrigger>;
+        isDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+        ignoreNonKeyboardFocus: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableClosingTrigger: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        disableHoverableContent: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+        isPointerInTransit: _angular_core.Signal<boolean>;
+        isControlledState: _angular_core.InputSignalWithTransform<boolean, _angular_cdk_coercion.BooleanInput>;
+        open(): void;
+        close(): void;
+        onTriggerEnter(): void;
+        onTriggerLeave(): void;
+    };
+    private readonly destroyRef;
+    private readonly dismissableLayer;
+    private readonly elementRef;
+    /**
+     * The preferred side of the anchor to render against when open.
+     * Will be reversed when collisions occur and avoidCollisions is enabled.
+     */
+    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    /**
+     * The distance in pixels from the anchor.
+     */
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * The preferred alignment against the anchor. May change when collisions occur.
+     */
+    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, unknown>;
+    /**
+     * The padding between the arrow and the edges of the content.
+     * If your content has border-radius, this will prevent it from overflowing the corners.
+     */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
+     */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The element used as the collision boundary.
+     * By default this is the viewport, though you can provide additional element(s) to be included in this check.
+     */
+    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
+    /**
+     * The distance in pixels from the boundary edges where collision detection should occur.
+     * Accepts a number (same for all sides), or a partial padding object, for example: `{ top: 20, left: 20 }`.
+     */
+    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
+    /**
+     * The sticky behavior on the `align` axis.
+     * - `partial` will keep the content in the boundary as long as the trigger is at least partially in the boundary
+     * - `always` will keep the content in the boundary regardless.
+     */
+    readonly sticky: _angular_core.InputSignal<"partial" | "always">;
+    /**
+     * Whether to hide the content when the trigger becomes fully occluded.
+     */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * 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<RdxTooltipContentWrapper, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipContentWrapper, "[rdxTooltipContentWrapper]", never, { "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; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; }, never, never, true, [{ directive: typeof i1$2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxPopperContentWrapper; inputs: { "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+}
+
+declare class RdxTooltipPortal {
+    readonly container: _angular_core.InputSignal<ElementRef<HTMLElement> | TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxTooltipPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxTooltipPortal, "[rdxTooltipPortal]", never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$3.RdxPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+type RdxTooltipConfig = {
+    /**
+     * The duration from when the pointer enters the trigger until the tooltip gets opened.
+     * @defaultValue 700
+     */
+    delayDuration?: number;
+    /**
+     * How much time a user has to enter another trigger without incurring a delay again.
+     * @defaultValue 300
+     */
+    skipDelayDuration?: number;
+    /**
+     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
+     * @defaultValue false
+     */
+    disableHoverableContent?: boolean;
+    /**
+     * When `true`, clicking on trigger will not close the content.
+     * @defaultValue false
+     */
+    disableClosingTrigger?: boolean;
+    /**
+     * How long to wait before closing the tooltip. Specified in milliseconds.
+     */
+    closeDelay?: number;
+};
+declare const defaultTooltipConfig: RdxTooltipConfig;
+declare const RdxTooltipDefaultsToken: InjectionToken<RdxTooltipConfig>;
+declare function provideRdxTooltipConfig(config: Partial<RdxTooltipConfig>): Provider[];
+declare function injectRdxTooltipConfig(): RdxTooltipConfig;
+
+declare const tooltipImports: (typeof RdxTooltipPortalPresence)[];
+
+export { RdxTooltip, RdxTooltipArrow, RdxTooltipContent, RdxTooltipContentWrapper, RdxTooltipDefaultsToken, RdxTooltipPortal, RdxTooltipPortalPresence, RdxTooltipTrigger, defaultTooltipConfig, injectRdxTooltipConfig, injectRdxTooltipContext, provideRdxTooltipConfig, provideRdxTooltipContext, tooltipImports };
+export type { RdxTooltipConfig, RdxTooltipContext };

package/visually-hidden/index.d.ts

@@ -1,3 +1,65 @@
-export * from './src/visually-hidden-input-bubble.directive';
-export * from './src/visually-hidden-input.directive';
-export * from './src/visually-hidden.directive';
+import * as _angular_core from '@angular/core';
+
+type VisuallyHidden = 'focusable' | 'fully-hidden';
+/**
+ *
+ * <span rdxVisuallyHidden [feature]="'fully-hidden'">
+ *   <ng-content />
+ * </span>
+ *
+ * <button (click)="directiveInstance.setFeature('focusable')">Make Focusable</button>
+ * <button (click)="directiveInstance.setFeature('fully-hidden')">Hide</button>
+ */
+declare class RdxVisuallyHiddenDirective {
+    readonly feature: _angular_core.InputSignal<VisuallyHidden>;
+    protected readonly computedFeature: _angular_core.WritableSignal<VisuallyHidden>;
+    setFeature(feature: VisuallyHidden): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxVisuallyHiddenDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxVisuallyHiddenDirective, "[rdxVisuallyHidden]", never, { "feature": { "alias": "feature"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ *
+ */
+declare class RdxVisuallyHiddenInputBubbleDirective<T> {
+    private readonly elementRef;
+    private readonly visuallyHidden;
+    readonly feature: _angular_core.InputSignal<VisuallyHidden>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.InputSignal<string | T | null | undefined>;
+    readonly checked: _angular_core.InputSignal<boolean | undefined>;
+    readonly required: _angular_core.InputSignal<boolean | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean | undefined>;
+    protected readonly computedFeature: _angular_core.WritableSignal<VisuallyHidden>;
+    protected readonly computedValue: _angular_core.WritableSignal<string | T | null | undefined>;
+    readonly valueState: _angular_core.Signal<string | boolean | T | null | undefined>;
+    constructor();
+    setValue(value: string): void;
+    setFeature(feature: VisuallyHidden): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxVisuallyHiddenInputBubbleDirective<any>, never>;
+    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: {}; }]>;
+}
+
+export { RdxVisuallyHiddenDirective, RdxVisuallyHiddenInputBubbleDirective, RdxVisuallyHiddenInputDirective };
+export type { VisuallyHidden };

package/accordion/src/accordion-content-presence.directive.d.ts

@@ -1,6 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@radix-ng/primitives/collapsible";
-export declare class RdxAccordionContentPresenceDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentPresenceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentPresenceDirective, "ng-template[rdxAccordionContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentPresenceDirective; inputs: {}; outputs: {}; }]>;
-}

package/accordion/src/accordion-content.directive.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@radix-ng/primitives/collapsible";
-export declare class RdxAccordionContentDirective {
-    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
-    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentDirective; inputs: {}; outputs: {}; }]>;
-}

package/accordion/src/accordion-header.directive.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class RdxAccordionHeaderDirective {
-    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
-    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
-}

package/accordion/src/accordion-item.directive.d.ts

@@ -1,43 +0,0 @@
-import { BooleanInput } from '@angular/cdk/coercion';
-import { ElementRef, Signal } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "@radix-ng/primitives/collapsible";
-export type RdxAccordionItemState = 'open' | 'closed';
-export type AccordionItemContext = {
-    open: Signal<boolean>;
-    disabled: Signal<boolean>;
-    triggerId: string;
-    dataState: Signal<RdxAccordionItemState>;
-    dataDisabled: Signal<boolean>;
-    currentElement: ElementRef<HTMLElement>;
-    value: Signal<string | undefined>;
-    updateOpen: () => void;
-};
-export declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null, provideAccordionItemContext: (useFactory: () => AccordionItemContext) => import("@angular/core").Provider;
-/**
- * @group Components
- */
-export declare class RdxAccordionItemDirective {
-    readonly elementRef: ElementRef<HTMLElement>;
-    private readonly collapsibleContext;
-    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
-    /**
-     * A string value for the accordion item. All items within an accordion should use a unique value.
-     * @group Props
-     */
-    readonly value: import("@angular/core").InputSignal<string | undefined>;
-    /**
-     * Whether or not an accordion item is disabled from user interaction.
-     * When `true`, prevents the user from interacting with the item.
-     * @group Props
-     */
-    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    readonly isDisabled: Signal<boolean>;
-    readonly open: Signal<any>;
-    readonly dataState: Signal<RdxAccordionItemState>;
-    constructor();
-    updateOpen: () => void;
-    handleArrowKey(event: KeyboardEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionItemDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionItemDirective, "[rdxAccordionItem]", ["rdxAccordionItem"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleRootDirective; inputs: { "disabled": "disabled"; "open": "open"; }; outputs: {}; }]>;
-}

package/accordion/src/accordion-root.directive.d.ts

@@ -1,83 +0,0 @@
-import { Direction } from '@angular/cdk/bidi';
-import { BooleanInput } from '@angular/cdk/coercion';
-import { ElementRef, InputSignal, InputSignalWithTransform, ModelSignal, Signal } from '@angular/core';
-import { DataOrientation } from '@radix-ng/primitives/core';
-import * as i0 from "@angular/core";
-type AcceptableValue = string | Record<string, any> | null;
-export type AccordionRootContext = {
-    disabled: InputSignalWithTransform<boolean, BooleanInput>;
-    direction: InputSignal<Direction>;
-    orientation: InputSignal<DataOrientation>;
-    value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
-    collapsible: Signal<boolean>;
-    isSingle: Signal<boolean>;
-    elementRef: ElementRef<HTMLElement>;
-    changeModelValue: (value: string) => void;
-};
-export declare const injectAccordionRootContext: (optional?: boolean) => AccordionRootContext | null, provideAccordionRootContext: (useFactory: () => AccordionRootContext) => import("@angular/core").Provider;
-/**
- * @group Components
- */
-export declare class RdxAccordionRootDirective {
-    readonly elementRef: ElementRef<HTMLElement>;
-    readonly id: InputSignal<string>;
-    /**
-     * The reading direction of the accordion when applicable. If omitted, assumes LTR (left-to-right) reading mode.
-     *
-     * @group Props
-     */
-    readonly dir: InputSignal<Direction>;
-    /** Whether the Accordion is disabled.
-     * @defaultValue false
-     * @group Props
-     */
-    readonly disabled: InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The orientation of the accordion.
-     *
-     * @defaultValue 'vertical'
-     * @group Props
-     */
-    readonly orientation: InputSignal<DataOrientation>;
-    /**
-     * The default active value of the item(s).
-     *
-     * Use when you do not need to control the state of the item(s).
-     * @group Props
-     */
-    readonly defaultValue: InputSignal<string | string[] | undefined>;
-    /**
-     * The controlled value of the item to expand.
-     *
-     * @group Props
-     */
-    readonly value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
-    /**
-     * When type is "single", allows closing content when clicking trigger for an open item.
-     * When type is "multiple", this prop has no effect.
-     *
-     * @defaultValue false
-     * @group Props
-     */
-    readonly collapsible: InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * Determines whether a "single" or "multiple" items can be selected at a time.
-     *
-     * @defaultValue 'single'
-     * @group Props
-     */
-    readonly type: InputSignal<"multiple" | "single">;
-    /**
-     * Event handler called when the expanded state of an item changes and type is "multiple".
-     * @group Emits
-     */
-    readonly onValueChange: import("@angular/core").OutputEmitterRef<void>;
-    readonly isSingle: Signal<boolean>;
-    constructor();
-    changeModelValue: (newValue: string) => void;
-    private isValueEqualOrExist;
-    private isEqual;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", ["rdxAccordionRoot"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
-}
-export {};

package/accordion/src/accordion-trigger.directive.d.ts

@@ -1,10 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@radix-ng/primitives/collapsible";
-export declare class RdxAccordionTriggerDirective {
-    protected readonly rootContext: import("./accordion-root.directive").AccordionRootContext;
-    protected readonly itemContext: import("./accordion-item.directive").AccordionItemContext;
-    constructor();
-    changeItem(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleTriggerDirective; inputs: {}; outputs: {}; }]>;
-}

package/alert-dialog/src/alert-dialog-cancel.directive.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class RdxAlertDialogCancelDirective {
-    private readonly alertDialogService;
-    onClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogCancelDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogCancelDirective, "[rdxAlertDialogCancel]", never, {}, {}, never, never, true, never>;
-}

package/alert-dialog/src/alert-dialog-content.directive.d.ts

@@ -1,9 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/cdk/a11y";
-export declare class RdxAlertDialogContentDirective {
-    private readonly renderer;
-    private readonly elementRef;
-    set maxWidth(value: string);
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogContentDirective, "[rdxAlertDialogContent]", never, { "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, [{ directive: typeof i1.CdkTrapFocus; inputs: {}; outputs: {}; }]>;
-}

package/alert-dialog/src/alert-dialog-root.directive.d.ts

@@ -1,9 +0,0 @@
-import { TemplateRef } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class RdxAlertDialogRootDirective {
-    private readonly viewContainerRef;
-    private readonly alertDialogService;
-    set content(template: TemplateRef<any>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogRootDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogRootDirective, "[rdxAlertDialogRoot]", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
-}

package/alert-dialog/src/alert-dialog-title.directive.d.ts

@@ -1,5 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class RdxAlertDialogTitleDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTitleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTitleDirective, "[rdxAlertDialogTitle]", never, {}, {}, never, never, true, never>;
-}

package/alert-dialog/src/alert-dialog-trigger.directive.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class RdxAlertDialogTriggerDirective {
-    private readonly alertDialogService;
-    handleClick(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTriggerDirective, "[rdxAlertDialogTrigger]", never, {}, {}, never, never, true, never>;
-}

package/alert-dialog/src/alert-dialog.service.d.ts

@@ -1,14 +0,0 @@
-import { Overlay } from '@angular/cdk/overlay';
-import { TemplateRef, ViewContainerRef } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class RdxAlertDialogService {
-    private overlay;
-    private overlayRef;
-    private dialogContent;
-    constructor(overlay: Overlay);
-    setDialogContent(viewContainerRef: ViewContainerRef, template: TemplateRef<any>): void;
-    open(): void;
-    close(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RdxAlertDialogService>;
-}