@radix-ng/primitives 1.0.3 → 1.0.5

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

@@ -1,83 +1,33 @@
 import * as i0 from '@angular/core';
-import { Signal, WritableSignal, ElementRef, InputSignalWithTransform, InputSignal, ModelSignal } from '@angular/core';
+import { InputSignalWithTransform, InputSignal, ModelSignal, Signal, WritableSignal, ElementRef } from '@angular/core';
 import * as _radix_ng_primitives_accordion from '@radix-ng/primitives/accordion';
-import * as i1 from '@radix-ng/primitives/collapsible';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { BooleanInput, DataOrientation, AcceptableValue } from '@radix-ng/primitives/core';
-import * as i2 from '@radix-ng/primitives/composite';
-
-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: {}; }]>;
-}
+import { BooleanInput, DataOrientation, AcceptableValue, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/composite';
+import * as i1$1 from '@radix-ng/primitives/collapsible';
 
 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: _radix_ng_primitives_core.InjectContext<AccordionItemContext>;
-declare const provideAccordionItemContext: (useFactory: () => AccordionItemContext) => i0.Provider;
-/**
- * @group Components
- */
-declare class RdxAccordionItemDirective {
-    readonly elementRef: ElementRef<HTMLElement>;
-    private readonly collapsibleContext;
-    private readonly listItem;
-    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;
-    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: {}; }, { directive: typeof i2.RdxCompositeListItem; inputs: {}; outputs: {}; }]>;
+/** The reason an accordion value change was requested. */
+type RdxAccordionValueChangeReason = 'trigger-press' | 'none';
+type RdxAccordionValueChangeEventDetails = RdxCancelableChangeEventDetails<RdxAccordionValueChangeReason>;
+/** Payload of {@link RdxAccordionRootDirective.onValueChange}, mirroring Base UI's `(value, eventDetails)`. */
+interface RdxAccordionValueChangeEvent {
+    value: AcceptableValue | AcceptableValue[] | undefined;
+    eventDetails: RdxAccordionValueChangeEventDetails;
 }
-
 type AccordionRootContext = {
     disabled: InputSignalWithTransform<boolean, BooleanInput>;
     orientation: InputSignal<DataOrientation>;
     value: ModelSignal<AcceptableValue | AcceptableValue[] | undefined>;
-    collapsible: Signal<boolean>;
     isSingle: Signal<boolean>;
     keepMounted: InputSignalWithTransform<boolean, BooleanInput>;
-    changeModelValue: (value: string) => void;
+    hiddenUntilFound: InputSignalWithTransform<boolean, BooleanInput>;
+    changeModelValue: (value: string, event?: Event) => void;
 };
 declare const injectAccordionRootContext: _radix_ng_primitives_core.InjectContext<AccordionRootContext>;
 declare const provideAccordionRootContext: (useFactory: () => AccordionRootContext) => i0.Provider;
@@ -85,7 +35,6 @@ declare const provideAccordionRootContext: (useFactory: () => AccordionRootConte
  * @group Components
  */
 declare class RdxAccordionRootDirective {
-    readonly id: InputSignal<string>;
     /** Whether the Accordion is disabled.
      * @defaultValue false
      * @group Props
@@ -116,23 +65,8 @@ declare class RdxAccordionRootDirective {
      */
     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">;
-    /**
-     * Allow multiple panels to be open simultaneously.
-     * Takes precedence over `type` when `true`.
+     * Allow multiple panels to be open simultaneously. In single mode an open item can always be
+     * closed by clicking its trigger again (Base UI parity — there is no separate `collapsible`).
      *
      * @defaultValue false
      * @group Props
@@ -156,33 +90,102 @@ declare class RdxAccordionRootDirective {
      */
     readonly keepMounted: InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Event handler called when the expanded state of an item changes.
+     * Allow collapsed panels to remain mounted (but hidden) so the browser's in-page search
+     * can find and reveal them. Mirrors Base UI's `hiddenUntilFound`.
+     *
+     * @defaultValue false
+     * @group Props
+     */
+    readonly hiddenUntilFound: InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Event handler called when the expanded value changes. Emits the next value plus a cancelable
+     * `eventDetails` (Base UI parity); call `eventDetails.cancel()` to reject the change.
      * @group Emits
      */
-    readonly onValueChange: i0.OutputEmitterRef<AcceptableValue | AcceptableValue[] | undefined>;
+    readonly onValueChange: i0.OutputEmitterRef<RdxAccordionValueChangeEvent>;
     readonly isSingle: Signal<boolean>;
     constructor();
-    changeModelValue: (newValue: string) => void;
+    changeModelValue: (newValue: string, event?: Event) => 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; }; "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, [{ directive: typeof i2.RdxCompositeList; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionRootDirective, "[rdxAccordionRoot]", ["rdxAccordionRoot"], { "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; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; "hiddenUntilFound": { "alias": "hiddenUntilFound"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxCompositeList; inputs: {}; outputs: {}; }]>;
+}
+
+/** Payload of {@link RdxAccordionItemDirective.onOpenChange}, mirroring Base UI's `(open, eventDetails)`. */
+interface RdxAccordionItemOpenChangeEvent {
+    open: boolean;
+    eventDetails: RdxAccordionValueChangeEventDetails;
+}
+type AccordionItemContext = {
+    open: Signal<boolean>;
+    disabled: Signal<boolean>;
+    triggerId: WritableSignal<string>;
+    dataDisabled: Signal<boolean>;
+    currentElement: ElementRef<HTMLElement>;
+    value: Signal<string | undefined>;
+    updateOpen: () => void;
+    index: Signal<number>;
+};
+declare const injectAccordionItemContext: _radix_ng_primitives_core.InjectContext<AccordionItemContext>;
+declare const provideAccordionItemContext: (useFactory: () => AccordionItemContext) => i0.Provider;
+/**
+ * @group Components
+ */
+declare class RdxAccordionItemDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    private readonly collapsibleContext;
+    private readonly listItem;
+    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. Emits `{ open, eventDetails }`
+     * (Base UI parity).
+     * @group Emits
+     */
+    readonly onOpenChange: i0.OutputEmitterRef<RdxAccordionItemOpenChangeEvent>;
+    readonly isDisabled: Signal<boolean>;
+    readonly open: Signal<boolean>;
+    /** 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;
+    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$1.RdxCollapsibleRootDirective; inputs: { "disabled": "disabled"; "open": "open"; }; outputs: {}; }, { directive: typeof i1.RdxCompositeListItem; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxAccordionPanelDirective {
+    protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
+    protected readonly itemContext: _radix_ng_primitives_accordion.AccordionItemContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionPanelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionPanelDirective, "[rdxAccordionPanel]", never, {}, {}, never, never, true, [{ directive: typeof i1$1.RdxCollapsiblePanelDirective; inputs: {}; outputs: {}; }]>;
 }
 
 declare class RdxAccordionTriggerDirective {
     protected readonly rootContext: _radix_ng_primitives_accordion.AccordionRootContext;
     protected readonly itemContext: _radix_ng_primitives_accordion.AccordionItemContext;
     constructor();
-    changeItem(): void;
+    changeItem(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionTriggerDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RdxAccordionTriggerDirective, "[rdxAccordionTrigger]", never, {}, {}, never, never, true, never>;
 }
 
 declare class RdxAccordionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxAccordionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof RdxAccordionContentDirective, typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective], [typeof RdxAccordionContentDirective, typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxAccordionModule, never, [typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionPanelDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective], [typeof RdxAccordionHeaderDirective, typeof RdxAccordionItemDirective, typeof RdxAccordionPanelDirective, typeof RdxAccordionRootDirective, typeof RdxAccordionTriggerDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxAccordionModule>;
 }
 
-export { RdxAccordionContentDirective, RdxAccordionHeaderDirective, RdxAccordionItemDirective, RdxAccordionModule, RdxAccordionRootDirective, RdxAccordionTriggerDirective, injectAccordionItemContext, injectAccordionRootContext, provideAccordionItemContext, provideAccordionRootContext };
-export type { AccordionItemContext, AccordionRootContext, RdxAccordionItemState };
+export { RdxAccordionHeaderDirective, RdxAccordionItemDirective, RdxAccordionModule, RdxAccordionPanelDirective, RdxAccordionRootDirective, RdxAccordionTriggerDirective, injectAccordionItemContext, injectAccordionRootContext, provideAccordionItemContext, provideAccordionRootContext };
+export type { AccordionItemContext, AccordionRootContext, RdxAccordionItemOpenChangeEvent, RdxAccordionValueChangeEvent, RdxAccordionValueChangeEventDetails, RdxAccordionValueChangeReason };

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

@@ -157,12 +157,11 @@ declare class RdxCheckboxRootDirective implements RdxFormCheckboxControl {
      */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
-     * Whether the user should be unable to tick or untick the checkbox.
+     * Whether the user should be unable to tick or untick the checkbox. Bound in templates as
+     * `readOnly` (Base UI spelling); the TS member stays `readonly` to satisfy `RdxFormCheckboxControl`.
      * @group Props
      */
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** Alias matching Base UI's `readOnly` prop spelling. */
-    readonly readOnly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * Whether or not the checkbox is required.
      * @group Props
@@ -215,7 +214,7 @@ declare class RdxCheckboxRootDirective implements RdxFormCheckboxControl {
     private setOptionalAttribute;
     private setBooleanAttribute;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCheckboxRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxRootDirective, "[rdxCheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "submitValue": { "alias": "value"; "required": false; "isSignal": true; }; "uncheckedValue": { "alias": "uncheckedValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "parent": { "alias": "parent"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "indeterminate": "indeterminateChange"; "onCheckedChange": "onCheckedChange"; }, never, never, true, [{ directive: typeof _radix_ng_primitives_core.RdxControlValueAccessor; inputs: { "value": "checked"; "disabled": "disabled"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCheckboxRootDirective, "[rdxCheckboxRoot]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "submitValue": { "alias": "value"; "required": false; "isSignal": true; }; "uncheckedValue": { "alias": "uncheckedValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "parent": { "alias": "parent"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "indeterminate": "indeterminateChange"; "onCheckedChange": "onCheckedChange"; }, never, never, true, [{ directive: typeof _radix_ng_primitives_core.RdxControlValueAccessor; inputs: { "value": "checked"; "disabled": "disabled"; }; outputs: {}; }]>;
 }
 
 type RdxCheckboxGroupValueChangeReason = 'none';

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

@@ -150,6 +150,8 @@ declare class RdxCompositeRoot {
     setHighlightedIndex(index: number, shouldScrollIntoView?: boolean): void;
     relayKeyboardEvent(event: KeyboardEvent): void;
     protected handleKeydown(event: KeyboardEvent): void;
+    /** Select the whole value when focus lands on a native text input item (Base UI parity). */
+    protected handleFocusIn(event: FocusEvent): void;
     private handleCompositeKeydown;
     private getNextIndex;
     private elements;

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

@@ -1,41 +1,48 @@
 import * as _angular_core from '@angular/core';
-import { ModelSignal, InputSignal, InputSignalWithTransform, Signal, InjectionToken } from '@angular/core';
+import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxFormValueControl, BooleanInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import { ControlValueAccessor } from '@angular/forms';
-import { BooleanInput, RdxFormValueControl, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/composite';
-import * as i1$1 from '@radix-ng/primitives/visually-hidden';
+import * as _radix_ng_primitives_radio from '@radix-ng/primitives/radio';
 
 type RdxRadioValueChangeReason = 'none';
-interface RadioGroupProps {
-    value: ModelSignal<string | null>;
-    defaultValue: InputSignal<string | undefined>;
-    name: InputSignal<string | undefined>;
-    form: InputSignal<string | undefined>;
-    disabled: InputSignalWithTransform<boolean, BooleanInput>;
-    readonly: InputSignalWithTransform<boolean, BooleanInput>;
-    required: InputSignalWithTransform<boolean, BooleanInput>;
-    disabledState: Signal<boolean>;
-}
-interface RadioGroupDirective extends RadioGroupProps {
-    select(value: string | null, event?: Event, reason?: RdxRadioValueChangeReason): void;
-    onTouched(): void;
-    setArrowNavigation(value: boolean): void;
-    isArrowNavigation(): boolean;
-}
 
 type RdxRadioValueChangeEventDetails = RdxCancelableChangeEventDetails<RdxRadioValueChangeReason>;
 interface RdxRadioValueChangeEvent {
     value: string;
     eventDetails: RdxRadioValueChangeEventDetails;
 }
-declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirective, ControlValueAccessor, RdxFormValueControl<string | null> {
+interface RadioRootContext {
+    value: Signal<string | null>;
+    disabledState: Signal<boolean>;
+    readonly: Signal<boolean>;
+    required: Signal<boolean>;
+    name: Signal<string | undefined>;
+    form: Signal<string | undefined>;
+    select(value: string | null, event?: Event, reason?: RdxRadioValueChangeReason): void;
+    setArrowNavigation(value: boolean): void;
+    isArrowNavigation(): boolean;
+}
+declare const injectRadioRootContext: _radix_ng_primitives_core.InjectContext<RadioRootContext>;
+declare const provideRadioRootContext: (useFactory: () => RadioRootContext) => _angular_core.Provider;
+declare class RdxRadioGroupDirective implements ControlValueAccessor, RdxFormValueControl<string | null> {
     private readonly elementRef;
     private readonly compositeRoot;
+    /**
+     * The selected value. Deliberately typed as `string` (not Base UI's generic `Value`):
+     * a radio group maps onto native radio inputs whose form value is a string, so values are
+     * the option identifiers. Use the string key of your option as the value.
+     */
     readonly value: _angular_core.ModelSignal<string | null>;
     readonly defaultValue: _angular_core.InputSignal<string | undefined>;
     readonly name: _angular_core.InputSignal<string | undefined>;
     readonly form: _angular_core.InputSignal<string | undefined>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the user should be unable to select a different radio button. Bound in templates as
+     * `readOnly` (Base UI spelling); the TS member stays `readonly` for cross-primitive consistency.
+     */
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
@@ -43,7 +50,7 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
      */
     readonly onValueChange: _angular_core.OutputEmitterRef<RdxRadioValueChangeEvent>;
     private readonly disable;
-    readonly disabledState: _angular_core.Signal<boolean>;
+    readonly disabledState: Signal<boolean>;
     private readonly arrowNavigation;
     private readonly itemMetadata;
     private readonly disabledIndices;
@@ -87,31 +94,85 @@ declare class RdxRadioGroupDirective implements RadioGroupProps, RadioGroupDirec
     setArrowNavigation(value: boolean): void;
     isArrowNavigation(): boolean;
     protected onKeydown(): void;
+    /**
+     * Marks the control touched when focus leaves the whole group (Base UI `RadioGroup` parity and the
+     * ADR 0004 CVA strategy) — moving focus between items stays inside, so `relatedTarget` is checked.
+     */
+    protected onFocusOut(event: FocusEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioGroupDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioGroupDirective, "[rdxRadioRoot]", ["rdxRadioRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxCompositeRoot; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioGroupDirective, "[rdxRadioRoot]", ["rdxRadioRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxCompositeRoot; inputs: {}; outputs: {}; }]>;
+}
+
+declare class RdxRadioIndicatorDirective {
+    protected readonly itemContext: _radix_ng_primitives_radio.RadioItemContext;
+    /** Keep the indicator in the DOM when unchecked so CSS exit animations can play. */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    protected readonly isVisible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioIndicatorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioIndicatorDirective, "[rdxRadioIndicator]", ["rdxRadioIndicator"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The hidden native radio input that mirrors the item state for form submission, native validation,
+ * and `<label>` activation. Place it inside an `rdxRadioItem`.
+ *
+ * @see https://base-ui.com/react/components/radio
+ */
+declare class RdxRadioItemInputDirective {
+    private readonly rootContext;
+    private readonly itemContext;
+    private readonly input;
+    readonly name: _angular_core.Signal<string | undefined>;
+    readonly form: _angular_core.Signal<string | undefined>;
+    readonly value: _angular_core.Signal<string | undefined>;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly required: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Selects this item when the native input is checked — covers `<label>` activation,
+     * where clicking the label toggles the hidden radio input rather than the visible item.
+     * `select()` is a no-op when the value is already current, so the programmatic
+     * `change` dispatched above does not re-trigger selection.
+     * @ignore
+     */
+    protected onInputChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioItemInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemInputDirective, "input[rdxRadioItemInput]", ["rdxRadioItemInput"], {}, {}, never, never, true, never>;
 }
 
-declare const RdxRadioItemToken: InjectionToken<RdxRadioItemDirective>;
-declare function injectRadioItem(): RdxRadioItemDirective;
+interface RadioItemContext {
+    value: Signal<string>;
+    checkedState: Signal<boolean>;
+    disabledState: Signal<boolean>;
+    readonlyState: Signal<boolean>;
+    requiredState: Signal<boolean>;
+}
+declare const injectRadioItemContext: _radix_ng_primitives_core.InjectContext<RadioItemContext>;
+declare const provideRadioItemContext: (useFactory: () => RadioItemContext) => _angular_core.Provider;
 declare class RdxRadioItemDirective {
-    private readonly radioGroup;
-    private readonly elementRef;
-    private readonly renderer;
+    private readonly rootContext;
     private readonly compositeItem;
-    private readonly destroyRef;
-    private readonly inputElement;
-    private previousCheckedState;
+    private readonly elementRef;
     readonly value: _angular_core.InputSignal<string>;
     readonly id: _angular_core.InputSignal<string | undefined>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the user should be unable to select this radio button. Bound in templates as
+     * `readOnly` (Base UI spelling); the TS member stays `readonly` for cross-primitive consistency.
+     */
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly nativeButtonState: _angular_core.Signal<boolean>;
-    readonly disabledState: _angular_core.Signal<boolean>;
-    readonly readonlyState: _angular_core.Signal<boolean>;
-    readonly requiredState: _angular_core.Signal<boolean>;
-    readonly checkedState: _angular_core.Signal<boolean>;
+    /**
+     * Whether the host is a native `<button>`. Detected from the host tag (unlike Base UI's explicit
+     * `nativeButton` prop, the rendered element is statically known in Angular templates), and used to
+     * apply `type="button"` and the native `disabled` attribute.
+     */
+    protected readonly isNativeButton: boolean;
+    readonly disabledState: Signal<boolean>;
+    readonly readonlyState: Signal<boolean>;
+    readonly requiredState: Signal<boolean>;
+    readonly checkedState: Signal<boolean>;
     private readonly ARROW_KEYS;
     constructor();
     /** @ignore */
@@ -123,35 +184,9 @@ declare class RdxRadioItemDirective {
     /** @ignore */
     onFocus(event?: FocusEvent): void;
     private isAllowedArrowKey;
-    private createHiddenInput;
-    private syncHiddenInput;
-    private setOptionalAttribute;
-    private setBooleanAttribute;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioItemDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemDirective, "[rdxRadioItem]", ["rdxRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxCompositeItem; inputs: {}; outputs: {}; }]>;
-}
-
-declare class RdxRadioIndicatorDirective {
-    protected readonly radioGroup: RadioGroupDirective;
-    protected readonly radioItem: RdxRadioItemDirective;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioIndicatorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioIndicatorDirective, "[rdxRadioIndicator]", ["rdxRadioIndicator"], {}, {}, never, never, true, never>;
-}
-
-declare class RdxRadioItemInputDirective {
-    private readonly radioItem;
-    private readonly radioGroup;
-    private readonly input;
-    readonly name: _angular_core.Signal<string | undefined>;
-    readonly form: _angular_core.Signal<string | undefined>;
-    readonly value: _angular_core.Signal<string | undefined>;
-    readonly checked: _angular_core.Signal<boolean>;
-    readonly required: _angular_core.Signal<boolean>;
-    readonly disabled: _angular_core.Signal<boolean>;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxRadioItemInputDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemInputDirective, "input[rdxRadioItemInput]", ["rdxRadioItemInput"], {}, {}, never, never, true, [{ directive: typeof i1$1.RdxVisuallyHiddenDirective; inputs: { "feature": "feature"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxRadioItemDirective, "[rdxRadioItem]", ["rdxRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxCompositeItem; inputs: {}; outputs: {}; }]>;
 }
 
-export { RdxRadioGroupDirective, RdxRadioIndicatorDirective, RdxRadioItemDirective, RdxRadioItemInputDirective, RdxRadioItemToken, injectRadioItem };
-export type { RdxRadioValueChangeEvent, RdxRadioValueChangeEventDetails, RdxRadioValueChangeReason };
+export { RdxRadioGroupDirective, RdxRadioIndicatorDirective, RdxRadioItemDirective, RdxRadioItemInputDirective, injectRadioItemContext, injectRadioRootContext, provideRadioItemContext, provideRadioRootContext };
+export type { RadioItemContext, RadioRootContext, RdxRadioValueChangeEvent, RdxRadioValueChangeEventDetails, RdxRadioValueChangeReason };

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

@@ -15,7 +15,7 @@ declare class RdxSwitchInput {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSwitchInput, "input[rdxSwitchInput]", ["rdxSwitchInput"], {}, {}, never, never, true, never>;
 }
 
-type RdxSwitchCheckedChangeReason = 'trigger-press' | 'none';
+type RdxSwitchCheckedChangeReason = 'none';
 type RdxSwitchCheckedChangeEventDetails = RdxCancelableChangeEventDetails<RdxSwitchCheckedChangeReason>;
 interface RdxSwitchCheckedChangeEvent {
     checked: boolean;
@@ -35,7 +35,7 @@ declare class RdxSwitchRoot implements RdxFormCheckboxControl {
      *
      * @default false
      */
-    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
     /**
      * The controlled checked state. Use with `(onCheckedChange)` or two-way `[(checked)]`.
      */
@@ -79,6 +79,7 @@ declare class RdxSwitchRoot implements RdxFormCheckboxControl {
     readonly checkedState: _angular_core.Signal<boolean>;
     /** @ignore */
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
     /** @ignore Toggles the checked state unless disabled or read-only. */
     toggle(event?: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSwitchRoot, never>;