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

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

@@ -1,11 +1,73 @@
 import * as i0 from '@angular/core';
-import { InputSignalWithTransform, InputSignal, ModelSignal, Signal, ElementRef } from '@angular/core';
-import { Direction } from '@angular/cdk/bidi';
-import { BooleanInput } from '@angular/cdk/coercion';
-import { DataOrientation } from '@radix-ng/primitives/core';
+import { Signal, WritableSignal, ElementRef, InputSignalWithTransform, InputSignal, ModelSignal } from '@angular/core';
+import * as _radix_ng_primitives_accordion from '@radix-ng/primitives/accordion';
 import * as i1 from '@radix-ng/primitives/collapsible';
+import { BooleanInput, Direction, DataOrientation, AcceptableValue } from '@radix-ng/primitives/core';
+
+declare class RdxAccordionContentDirective {
+    protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
+    protected readonly itemContext: _radix_ng_primitives_accordion.AccordionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsiblePanelDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxAccordionHeaderDirective {
+    protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
+    protected readonly itemContext: _radix_ng_primitives_accordion.AccordionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
+}
+
+type RdxAccordionItemState = 'open' | 'closed';
+type AccordionItemContext = {
+    open: Signal<boolean>;
+    disabled: Signal<boolean>;
+    triggerId: WritableSignal<string>;
+    dataState: Signal<RdxAccordionItemState>;
+    dataDisabled: Signal<boolean>;
+    currentElement: ElementRef<HTMLElement>;
+    value: Signal<string | undefined>;
+    updateOpen: () => void;
+    index: Signal<number>;
+};
+declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null;
+declare const provideAccordionItemContext: (useFactory: () => AccordionItemContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxAccordionItemDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly collapsibleContext;
+    protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
+    /**
+     * A string value for the accordion item. All items within an accordion should use a unique value.
+     * @group Props
+     */
+    readonly value: i0.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: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event handler called when the panel open state changes.
+     * @group Emits
+     */
+    readonly onOpenChange: i0.OutputEmitterRef<boolean>;
+    readonly isDisabled: Signal<boolean>;
+    readonly open: Signal<boolean>;
+    readonly dataState: Signal<RdxAccordionItemState>;
+    /** Set by the trigger; links the content's `aria-labelledby` to the trigger `id`. */
+    readonly triggerId: WritableSignal<string>;
+    readonly index: Signal<number>;
+    constructor();
+    updateOpen: () => void;
+    handleArrowKey(event: Event): 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; }; }, { "onOpenChange": "onOpenChange"; }, never, never, true, [{ directive: typeof i1.RdxCollapsibleRootDirective; inputs: { "disabled": "disabled"; "open": "open"; }; outputs: {}; }]>;
+}
 
-type AcceptableValue = string | Record<string, any> | null;
 type AccordionRootContext = {
     disabled: InputSignalWithTransform<boolean, BooleanInput>;
     direction: InputSignal<Direction>;
@@ -13,6 +75,8 @@ type AccordionRootContext = {
     value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
     collapsible: Signal<boolean>;
     isSingle: Signal<boolean>;
+    loopFocus: InputSignalWithTransform<boolean, BooleanInput>;
+    keepMounted: InputSignalWithTransform<boolean, BooleanInput>;
     elementRef: ElementRef<HTMLElement>;
     changeModelValue: (value: string) => void;
 };
@@ -71,86 +135,57 @@ declare class RdxAccordionRootDirective {
      */
     readonly type: InputSignal<"multiple" | "single">;
     /**
-     * Event handler called when the expanded state of an item changes and type is "multiple".
-     * @group Emits
+     * Allow multiple panels to be open simultaneously.
+     * Takes precedence over `type` when `true`.
+     *
+     * @defaultValue false
+     * @group Props
      */
-    readonly onValueChange: i0.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>;
-}
-
-type RdxAccordionItemState = 'open' | 'closed';
-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;
-};
-declare const injectAccordionItemContext: (optional?: boolean) => AccordionItemContext | null;
-declare const provideAccordionItemContext: (useFactory: () => AccordionItemContext) => i0.Provider;
-/**
- * @group Components
- */
-declare class RdxAccordionItemDirective {
-    readonly elementRef: ElementRef<HTMLElement>;
-    private readonly collapsibleContext;
-    protected readonly rootContext: AccordionRootContext;
+    readonly multiple: InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * A string value for the accordion item. All items within an accordion should use a unique value.
+     * Whether keyboard focus wraps from the last item to the first and vice versa.
+     *
+     * @defaultValue true
      * @group Props
      */
-    readonly value: i0.InputSignal<string | undefined>;
+    readonly loopFocus: InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Whether or not an accordion item is disabled from user interaction.
-     * When `true`, prevents the user from interacting with the item.
+     * Whether to keep the content of collapsed items mounted in the DOM.
+     * When `true`, closed panels keep their element in the DOM instead of
+     * receiving a `hidden` attribute. Applies to the always-mounted
+     * `rdxAccordionContent`; the `rdxAccordionContentPresence` variant always
+     * unmounts.
+     *
+     * @defaultValue false
      * @group Props
      */
-    readonly disabled: i0.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly isDisabled: Signal<boolean>;
-    readonly open: Signal<any>;
-    readonly dataState: Signal<RdxAccordionItemState>;
+    readonly keepMounted: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event handler called when the expanded state of an item changes.
+     * @group Emits
+     */
+    readonly onValueChange: i0.OutputEmitterRef<AcceptableValue | AcceptableValue[] | undefined>;
+    readonly isSingle: Signal<boolean>;
     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: {}; }]>;
-}
-
-declare class RdxAccordionContentDirective {
-    protected readonly rootContext: AccordionRootContext;
-    protected readonly itemContext: AccordionItemContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionContentDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentDirective, "[rdxAccordionContent]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsibleContentDirective; inputs: {}; outputs: {}; }]>;
-}
-
-declare class RdxAccordionHeaderDirective {
-    protected readonly rootContext: AccordionRootContext;
-    protected readonly itemContext: AccordionItemContext;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionHeaderDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionHeaderDirective, "[rdxAccordionHeader]", never, {}, {}, never, never, true, never>;
+    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; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
 }
 
 declare class RdxAccordionTriggerDirective {
-    protected readonly rootContext: AccordionRootContext;
-    protected readonly itemContext: AccordionItemContext;
+    protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
+    protected readonly itemContext: _radix_ng_primitives_accordion.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: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
 }
 
 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: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionContentPresenceDirective, "ng-template[rdxAccordionContentPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxCollapsiblePanelPresenceDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class RdxAccordionModule {

package/types/radix-ng-primitives-alert-dialog.d.ts

@@ -0,0 +1,114 @@
+import * as i0 from '@angular/core';
+import * as i1 from '@radix-ng/primitives/dialog';
+import { RdxDialogHandle } from '@radix-ng/primitives/dialog';
+
+/**
+ * An overlay displayed beneath the alert dialog popup.
+ */
+declare class RdxAlertDialogBackdrop {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogBackdrop, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogBackdrop, "[rdxAlertDialogBackdrop]", ["rdxAlertDialogBackdrop"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogBackdrop; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Groups all parts of the alert dialog.
+ *
+ * Composes the Dialog primitive and forces alert-dialog semantics: it is always modal, never
+ * dismisses on outside pointer / focus-out interactions (Escape still closes), and renders its
+ * popup with `role="alertdialog"`. Assemble it from the `rdxAlertDialog*` parts (Popup, Backdrop,
+ * Title, Description, Close, Portal, Viewport), which are thin wrappers around the dialog parts.
+ */
+declare class RdxAlertDialogRoot {
+    private readonly dialog;
+    /** Whether the alert dialog is open (read-only mirror of the composed dialog state). */
+    readonly open: i0.ModelSignal<boolean>;
+    /** The active trigger's id. */
+    readonly triggerId: i0.ModelSignal<string | null>;
+    /** Payload of the active trigger. */
+    readonly payload: i0.WritableSignal<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogRoot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogRoot, "[rdxAlertDialogRoot]", ["rdxAlertDialogRoot"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogRoot; inputs: { "open": "open"; "defaultOpen": "defaultOpen"; "triggerId": "triggerId"; "defaultTriggerId": "defaultTriggerId"; "handle": "handle"; }; outputs: { "openChange": "openChange"; "triggerIdChange": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }; }]>;
+}
+
+/**
+ * A button that opens the alert dialog. Behaves exactly like the dialog trigger.
+ */
+declare class RdxAlertDialogTrigger {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTrigger, "button[rdxAlertDialogTrigger]", ["rdxAlertDialogTrigger"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTrigger; inputs: { "handle": "handle"; "payload": "payload"; "id": "id"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+/**
+ * Mounts the portal while the alert dialog is open and waits for CSS exit keyframes before unmounting.
+ */
+declare class RdxAlertDialogPortalPresence {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPortalPresence, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPortalPresence, "ng-template[rdxAlertDialogPortalPresence]", never, {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortalPresence; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Moves the alert dialog to a different part of the DOM. Defaults to `document.body`.
+ */
+declare class RdxAlertDialogPortal {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPortal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPortal, "[rdxAlertDialogPortal]", ["rdxAlertDialogPortal"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPortal; inputs: { "container": "container"; }; outputs: {}; }]>;
+}
+
+/**
+ * A scrollable positioning container for the alert dialog popup.
+ */
+declare class RdxAlertDialogViewport {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogViewport, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogViewport, "[rdxAlertDialogViewport]", ["rdxAlertDialogViewport"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogViewport; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A container for the alert dialog contents. Wraps the dialog popup, which reads alert semantics
+ * (role, modal, dismissal) from the alert root's variant.
+ */
+declare class RdxAlertDialogPopup {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogPopup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogPopup, "[rdxAlertDialogPopup]", ["rdxAlertDialogPopup"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogPopup; inputs: {}; outputs: { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }; }]>;
+}
+
+/**
+ * An accessible title for the alert dialog.
+ */
+declare class RdxAlertDialogTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogTitle, "[rdxAlertDialogTitle]", ["rdxAlertDialogTitle"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogTitle; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * An accessible description for the alert dialog.
+ */
+declare class RdxAlertDialogDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogDescription, "[rdxAlertDialogDescription]", ["rdxAlertDialogDescription"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogDescription; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A button that closes the alert dialog.
+ */
+declare class RdxAlertDialogClose {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogClose, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAlertDialogClose, "button[rdxAlertDialogClose]", ["rdxAlertDialogClose"], {}, {}, never, never, true, [{ directive: typeof i1.RdxDialogClose; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * Connects an alert dialog root with trigger elements rendered elsewhere in the DOM.
+ *
+ * Alert dialogs reuse the dialog handle implementation unchanged.
+ */
+declare const RdxAlertDialogHandle: typeof RdxDialogHandle;
+type RdxAlertDialogHandle<Payload = unknown> = RdxDialogHandle<Payload>;
+declare function createRdxAlertDialogHandle<Payload = unknown>(): RdxAlertDialogHandle<Payload>;
+
+declare const alertDialogImports: (typeof RdxAlertDialogBackdrop)[];
+declare class RdxAlertDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAlertDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAlertDialogModule, never, [typeof RdxAlertDialogRoot, typeof RdxAlertDialogTrigger, typeof RdxAlertDialogPortalPresence, typeof RdxAlertDialogPortal, typeof RdxAlertDialogBackdrop, typeof RdxAlertDialogViewport, typeof RdxAlertDialogPopup, typeof RdxAlertDialogTitle, typeof RdxAlertDialogDescription, typeof RdxAlertDialogClose], [typeof RdxAlertDialogRoot, typeof RdxAlertDialogTrigger, typeof RdxAlertDialogPortalPresence, typeof RdxAlertDialogPortal, typeof RdxAlertDialogBackdrop, typeof RdxAlertDialogViewport, typeof RdxAlertDialogPopup, typeof RdxAlertDialogTitle, typeof RdxAlertDialogDescription, typeof RdxAlertDialogClose]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxAlertDialogModule>;
+}
+
+export { RdxAlertDialogBackdrop, RdxAlertDialogClose, RdxAlertDialogDescription, RdxAlertDialogHandle, RdxAlertDialogModule, RdxAlertDialogPopup, RdxAlertDialogPortal, RdxAlertDialogPortalPresence, RdxAlertDialogRoot, RdxAlertDialogTitle, RdxAlertDialogTrigger, RdxAlertDialogViewport, alertDialogImports, createRdxAlertDialogHandle };

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

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { NumberInput } from '@angular/cdk/coercion';
+import { NumberInput } from '@radix-ng/primitives/core';
 
 declare class RdxArrow {
     readonly width: _angular_core.InputSignalWithTransform<number, NumberInput>;

package/{aspect-ratio/index.d.ts → types/radix-ng-primitives-aspect-ratio.d.ts}

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit } from '@angular/core';
-import { NumberInput } from '@angular/cdk/coercion';
+import { NumberInput } from '@radix-ng/primitives/core';
 
 /**
  * Directive to maintain an aspect ratio for an element.

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { WritableSignal, OnInit, OnDestroy, InjectionToken, Provider } from '@angular/core';
+import { WritableSignal, InjectionToken, Provider } from '@angular/core';
 
 type RdxImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
 type HTMLAttributeReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
@@ -28,7 +28,6 @@ declare class RdxAvatarFallbackDirective {
      */
     readonly delayMs: i0.InputSignal<number>;
     protected readonly canRender: i0.WritableSignal<boolean>;
-    private timeout;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarFallbackDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarFallbackDirective, "span[rdxAvatarFallback]", ["rdxAvatarFallback"], { "delayMs": { "alias": "delayMs"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
@@ -37,7 +36,7 @@ declare class RdxAvatarFallbackDirective {
 /**
  * @group Components
  */
-declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
+declare class RdxAvatarImageDirective {
     private readonly platformId;
     protected readonly rootContext: AvatarContextToken;
     /**
@@ -52,11 +51,8 @@ declare class RdxAvatarImageDirective implements OnInit, OnDestroy {
      * @group Emits
      */
     readonly onLoadingStatusChange: i0.OutputEmitterRef<RdxImageLoadingStatus>;
-    private readonly isMounted;
     private readonly loadingStatus;
     constructor();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarImageDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAvatarImageDirective, "img[rdxAvatarImage]", ["rdxAvatarImage"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; "referrerPolicy": { "alias": "referrerPolicy"; "required": false; "isSignal": true; }; }, { "onLoadingStatusChange": "onLoadingStatusChange"; }, never, never, true, never>;
 }
@@ -74,11 +70,11 @@ declare const RdxAvatarConfigToken: InjectionToken<RdxAvatarConfig>;
 declare function provideRdxAvatarConfig(config: Partial<RdxAvatarConfig>): Provider[];
 declare function injectAvatarConfig(): RdxAvatarConfig;
 
-declare class RdxCheckboxModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxCheckboxModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxCheckboxModule, never, [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective], [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<RdxCheckboxModule>;
+declare class RdxAvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAvatarModule, never, [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective], [typeof RdxAvatarRootDirective, typeof RdxAvatarFallbackDirective, typeof RdxAvatarImageDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxAvatarModule>;
 }
 
-export { RdxAvatarConfigToken, RdxAvatarFallbackDirective, RdxAvatarImageDirective, RdxAvatarRootDirective, RdxCheckboxModule, defaultAvatarConfig, injectAvatarConfig, provideRdxAvatarConfig };
+export { RdxAvatarConfigToken, RdxAvatarFallbackDirective, RdxAvatarImageDirective, RdxAvatarModule, RdxAvatarRootDirective, defaultAvatarConfig, injectAvatarConfig, provideRdxAvatarConfig };
 export type { RdxAvatarConfig, RdxImageLoadingStatus };

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

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+import { BooleanInput } from '@radix-ng/primitives/core';
+
+type RdxButtonType = 'button' | 'submit' | 'reset';
+interface RdxButtonProps {
+    /**
+     * Whether the button is disabled.
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * Whether the button should remain focusable when disabled. When `true`,
+     * the disabled state is expressed with `aria-disabled` (instead of the
+     * native `disabled` attribute) so the control stays in the tab order while
+     * its activation is suppressed.
+     * @defaultValue false
+     */
+    focusableWhenDisabled?: boolean;
+    /**
+     * The `type` attribute applied to native `<button>` hosts.
+     * @defaultValue 'button'
+     */
+    type?: RdxButtonType;
+}
+/**
+ * Headless button behavior, modeled on Base UI's `useButton`.
+ *
+ * Renders accessible button semantics on a native `<button>` or on any other
+ * element (e.g. `<a>`, `<span>`). Carries no styles — state is exposed via
+ * `data-disabled` for consumers to style.
+ *
+ * @group Components
+ */
+declare class RdxButtonDirective {
+    private readonly elementRef;
+    /**
+     * Whether the button is disabled.
+     * @group Props
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Keep the button focusable while disabled (uses `aria-disabled`).
+     * @group Props
+     */
+    readonly focusableWhenDisabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * The `type` attribute applied to native `<button>` hosts.
+     * @group Props
+     */
+    readonly type: _angular_core.InputSignal<RdxButtonType>;
+    /**
+     * @ignore
+     */
+    protected readonly isNativeButton: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     * Express disabled via `aria-disabled` on non-button hosts, or whenever the
+     * control must stay focusable.
+     */
+    protected readonly ariaDisabled: _angular_core.Signal<"true" | undefined>;
+    /**
+     * @ignore
+     */
+    protected readonly tabIndex: _angular_core.Signal<-1 | 0 | undefined>;
+    constructor();
+    private handleClick;
+    private handleKeydown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxButtonDirective, "[rdxButton]", ["rdxButton"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "focusableWhenDisabled": { "alias": "focusableWhenDisabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { RdxButtonDirective };
+export type { RdxButtonProps, RdxButtonType };

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

@@ -1,8 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { AfterViewInit, WritableSignal, InputSignal, ModelSignal, Signal } from '@angular/core';
 import { DateValue } from '@internationalized/date';
-import { DateMatcher, Formatter, Month } from '@radix-ng/primitives/core';
-import { BooleanInput } from '@angular/cdk/coercion';
+import { DateMatcher, Formatter, BooleanInput, Month } from '@radix-ng/primitives/core';
 
 declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
     private readonly rootContext;
@@ -38,7 +37,7 @@ declare class RdxCalendarCellTriggerDirective implements AfterViewInit {
     currentElement: HTMLElement;
     ngAfterViewInit(): void;
     protected onClick(): void;
-    protected onArrowKey(event: KeyboardEvent): void;
+    protected onArrowKey(event: Event): void;
     private shiftFocus;
     /**
      * @ignore