@radix-ng/primitives 1.0.6 → 1.0.8

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

@@ -1,12 +1,16 @@
-import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { RdxValidationMode } from '@radix-ng/primitives/core';
 
 /** A normalized external-error map: each field name maps to its message(s) in display order. */
 type RdxFormErrors = Record<string, string | string[]>;
-/** Payload of {@link RdxFormRoot.onFormSubmit}. */
+/** Payload of {@link RdxFormRoot.onFormSubmit}. Mirrors Base UI's `(values, eventDetails)` shape. */
 interface RdxFormSubmitEvent {
     /** The form's values serialized from `FormData` (repeated names collapse into arrays). */
     values: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /** Why the submit happened (Base UI `SubmitEventDetails.reason`). Always `'none'` for a user submit. */
+    reason: 'none';
     /** The original native submit event (already `preventDefault`-ed). */
     event: SubmitEvent;
 }
@@ -17,8 +21,12 @@ interface RdxFormSubmitEvent {
 interface RdxFormFieldRegistration {
     /** The field's `name` (key external errors match against), or `undefined`. */
     name: () => string | undefined;
-    /** The field's merged invalid state (includes external errors). */
+    /** The field's **actual** invalid state (ungated, includes external errors) — drives the submit guard
+     * and `anyInvalid`. */
     invalid: () => boolean;
+    /** The field's **displayed** tri-state validity, gated by its `validationMode` — drives the form's
+     * presentation `data-invalid` so it stays neutral on load while its fields are. `null` = neutral. */
+    displayValid?: () => boolean | null;
     /** Whether the field is dirty. */
     dirty: () => boolean;
     /** Whether the field is touched. */
@@ -29,41 +37,66 @@ interface RdxFormFieldRegistration {
     resetState: () => void;
 }
 /**
- * External owner of form-level state (e.g. a future Signal Forms `[rdxSignalForm]` adapter). Mirrors
- * Field's `RdxFieldState` seam one level up. Each member is optional: a provided accessor wins over the
- * built-in registry/`errors`-input behavior; absent accessors leave the built-in behavior untouched.
- * Kept as framework-free `() =>` accessors (no `@angular/forms/signals` dependency). See ADR 0004.
+ * External owner of form-level state (e.g. the Signal Forms `[rdxSignalForm]` adapter). Mirrors Field's
+ * `RdxFieldState` seam one level up. Each member is optional. The aggregate accessors (`dirty`/`touched`/
+ * `submitting`) take over the corresponding form-level state; `invalid` is **merged** with the field
+ * registry (so a real registered-field error still counts); the per-name accessors route a field's client
+ * state by `name`. Kept as framework-free `() =>` accessors (no `@angular/forms/signals` dependency). See
+ * ADR 0004.
  */
 interface RdxFormState {
     invalid?: () => boolean;
     dirty?: () => boolean;
     touched?: () => boolean;
     submitting?: () => boolean;
-    /** Per-name external error source; while provided, the `errors` input + clear-on-edit are inert. */
+    /**
+     * Per-name **client** validation errors (e.g. `rdxSignalForm`'s Signal Forms name-routing). Surfaced
+     * through the Form's `clientErrorsFor` channel and gated by `validationMode` like any client validity.
+     * Independent of the Form's `errors` input (server errors), which stays eager.
+     */
     errorsFor?: (name: string) => string[];
+    /**
+     * Per-name `touched` / `dirty` for a name-routed field. Lets a `rdxFieldRoot` that has only a bare
+     * `[formField]` control (no `rdxSignalField` / `rdxFieldControl`) still reveal its error on blur under
+     * `validationMode="onBlur"`/`"onChange"` — the field reads its interaction state from here.
+     */
+    touchedFor?: (name: string) => boolean;
+    dirtyFor?: (name: string) => boolean;
 }
-declare const formRootContext: () => {
-    errorsFor: (name: string | undefined) => string[];
-    notifyEdited: (name: string | undefined) => void;
-    register: (field: RdxFormFieldRegistration) => () => void;
-    setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
-    hasStateProvider: _angular_core.Signal<boolean>;
-};
-type RdxFormRootContext = ReturnType<typeof formRootContext>;
-declare const injectFormRootContext: _radix_ng_primitives_core.InjectContext<{
-    errorsFor: (name: string | undefined) => string[];
-    notifyEdited: (name: string | undefined) => void;
-    register: (field: RdxFormFieldRegistration) => () => void;
-    setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
-    hasStateProvider: _angular_core.Signal<boolean>;
-}>;
-declare const provideFormRootContext: (useFactory: () => {
-    errorsFor: (name: string | undefined) => string[];
+interface RdxFormRootContext {
+    /**
+     * **Client** validation errors routed by a form-level provider (e.g. `rdxSignalForm`'s Signal Forms
+     * name-routing). These are gated by `validationMode` like any client validity — adding `rdxSignalForm`
+     * must not change error-display timing.
+     */
+    clientErrorsFor: (name: string | undefined) => string[];
+    /** **Server/external** errors from the Form's `errors` input. Shown eagerly (not gated). */
+    externalErrorsFor: (name: string | undefined) => string[];
+    /** Per-name `touched` / `dirty` from a form-level provider (`rdxSignalForm`); `false` when none. */
+    touchedFor: (name: string | undefined) => boolean;
+    dirtyFor: (name: string | undefined) => boolean;
     notifyEdited: (name: string | undefined) => void;
+    /**
+     * Whether a submit has been attempted (set before the validity check on submit, cleared on reset).
+     * A presentation-timing seam: an adapter can reveal a field's error after a submit attempt without the
+     * field having been touched, so the consumer never hand-rolls "mark touched on submit". Base UI's
+     * submit-attempt state, kept at the form level.
+     */
+    submitAttempted: Signal<boolean>;
+    /** The form's default validation-display mode; a `rdxFieldRoot` may override it per field. */
+    validationMode: Signal<RdxValidationMode>;
+    /** Registers a field; returns its unregister callback. */
     register: (field: RdxFormFieldRegistration) => () => void;
     setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
-    hasStateProvider: _angular_core.Signal<boolean>;
-}) => _angular_core.Provider;
+    /**
+     * Identity-checked teardown: roll the slot back to `previous` only if `provider` is still active,
+     * so an old adapter's destroy can't clobber a newer one (create-before-destroy on a view swap).
+     */
+    clearStateProvider: (provider: RdxFormState | null, previous: RdxFormState | null) => void;
+    hasStateProvider: Signal<boolean>;
+}
+declare const injectFormRootContext: _radix_ng_primitives_core.InjectContext<RdxFormRootContext>;
+declare const provideFormRootContext: (useFactory: () => RdxFormRootContext) => _angular_core.Provider;
 /**
  * The top of the forms layer cake: a single directive on the native `<form>` element that aggregates
  * field state, maps external (server) errors onto fields by `name`, intercepts submit (values-as-object,
@@ -76,6 +109,15 @@ declare class RdxFormRoot {
     private readonly form;
     /** External/server validation errors keyed by `Field.Root` `name`. */
     readonly errors: _angular_core.InputSignal<RdxFormErrors | null | undefined>;
+    /**
+     * When fields reveal their validity (error styling + message). The control/adapter always reports the
+     * actual state; this decides *when* the Field surfaces it. A `rdxFieldRoot` can override it per field.
+     * Server errors (`errors` above) always show regardless. Defaults to `'onBlur'`.
+     *
+     * @group Props
+     * @defaultValue 'onBlur'
+     */
+    readonly validationMode: _angular_core.InputSignal<RdxValidationMode>;
     /** Emits the remaining error map after a field's external error is cleared by a user edit (or reset). */
     readonly onClearErrors: _angular_core.OutputEmitterRef<RdxFormErrors>;
     /** Emits the serialized form values when a valid form is submitted. */
@@ -83,7 +125,7 @@ declare class RdxFormRoot {
     private readonly fields;
     private readonly stateProvider;
     /** Whether an external adapter currently owns form-level state. */
-    readonly hasStateProvider: _angular_core.Signal<boolean>;
+    readonly hasStateProvider: Signal<boolean>;
     /**
      * Names whose external error has been cleared by a user edit. Reset to empty whenever a new `errors`
      * object reference is assigned — the server just spoke, so everything it said is live again.
@@ -91,26 +133,69 @@ declare class RdxFormRoot {
     private readonly clearedNames;
     /** The `errors` input minus cleared names, normalized to `string[]`. */
     private readonly effectiveErrors;
-    readonly anyInvalid: _angular_core.Signal<boolean>;
-    readonly anyDirty: _angular_core.Signal<boolean>;
-    readonly anyTouched: _angular_core.Signal<boolean>;
-    readonly submitting: _angular_core.Signal<boolean>;
-    /** Resolve a boolean aggregate: a registered provider's accessor wins, else OR over the registry. */
+    /** **Actual** aggregate invalidity (eager) — drives the submit guard / focus-first-invalid and is the
+     * value to read in app logic. Merges a form-level provider with the field registry. */
+    readonly anyInvalid: Signal<boolean>;
+    readonly anyDirty: Signal<boolean>;
+    readonly anyTouched: Signal<boolean>;
+    readonly submitting: Signal<boolean>;
+    /**
+     * **Displayed** aggregate invalidity — the source for the host `data-invalid` (a presentation
+     * attribute). A field counts only once its own `validationMode` reveals it (`displayValid() === false`),
+     * so the form stays **neutral on load** while its fields are, instead of leaking the gated state.
+     * Distinct from {@link anyInvalid} (actual, eager).
+     *
+     * When **any** display-aware field is registered, those fields are the *authoritative* displayed
+     * source and win outright — a form-level provider's aggregate `invalid()` is **not** added on top
+     * (it would contradict a field that overrode its own `validationMode` to stay neutral; and the
+     * fields already reflect that provider's per-name state). The provider fallback applies only when no
+     * display-aware field carries the state, and then conservatively — under `validationMode="always"`
+     * or after a submit attempt, never from `anyTouched`.
+     */
+    readonly anyDisplayedInvalid: Signal<boolean>;
+    /**
+     * Whether a submit has been attempted on this form, exposed to fields via the context. Set true at the
+     * very start of {@link onSubmit} (before the validity check, so a field whose `validationMode` defers
+     * display, e.g. `onBlur`, reveals its error in time to block the submit) and cleared on native reset.
+     */
+    readonly submitAttempted: _angular_core.WritableSignal<boolean>;
+    /**
+     * Resolve a boolean aggregate. For `dirty` / `touched` a registered provider's accessor wins, else OR
+     * over the registry. For **`invalid`** the two are **merged** (`provider || registry`): a registered
+     * field's actual invalidity — e.g. a server `[errors]` entry — must still count (and block submit) even
+     * when a form-level provider (`rdxSignalForm`) reports the client model valid.
+     */
     private aggregate;
-    /** Resolves the external messages for a field name (provider source wins over the `errors` input). */
-    errorsFor(name: string | undefined): string[];
-    /** Clears a field's external error after a user edit, emitting the remaining map. */
+    /** Client validation errors from a form-level provider (`rdxSignalForm`); `[]` when none. Gated. */
+    clientErrorsFor(name: string | undefined): string[];
+    /** Per-name `touched` from a form-level provider (`rdxSignalForm`); `false` when none. */
+    touchedFor(name: string | undefined): boolean;
+    /** Per-name `dirty` from a form-level provider (`rdxSignalForm`); `false` when none. */
+    dirtyFor(name: string | undefined): boolean;
+    /**
+     * Server/external errors from the `errors` input (eager). A separate channel from {@link clientErrorsFor}:
+     * the `errors` input always applies, even alongside a form-level client provider (`rdxSignalForm`), so
+     * adding `rdxSignalForm` never disables your server errors.
+     */
+    externalErrorsFor(name: string | undefined): string[];
+    /** Clears a field's server error (the `errors` input) after a user edit, emitting the remaining map.
+     * Client provider errors (`rdxSignalForm`) are not affected — Signal Forms re-validates them itself. */
     notifyEdited(name: string | undefined): void;
     register(field: RdxFormFieldRegistration): () => void;
     /** Register (or clear with `null`) an external owner of form-level state; returns the previous one. */
     setStateProvider(provider: RdxFormState | null): RdxFormState | null;
+    /**
+     * Identity-checked teardown — roll back to `previous` only if `provider` is still active, so an
+     * old adapter's destroy can't clobber a newer one (create-before-destroy on a view swap).
+     */
+    clearStateProvider(provider: RdxFormState | null, previous: RdxFormState | null): void;
     onSubmit(event: SubmitEvent): void;
     onReset(): void;
     private readonly resetTimers;
     constructor();
     private remainingErrors;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFormRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFormRoot, "form[rdxFormRoot]", ["rdxFormRoot"], { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "onClearErrors": "onClearErrors"; "onFormSubmit": "onFormSubmit"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFormRoot, "form[rdxFormRoot]", ["rdxFormRoot"], { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "validationMode": { "alias": "validationMode"; "required": false; "isSignal": true; }; }, { "onClearErrors": "onClearErrors"; "onFormSubmit": "onFormSubmit"; }, never, never, true, never>;
 }
 
 declare const _importsForm: (typeof RdxFormRoot)[];

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

@@ -133,7 +133,14 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
      * @group Emits
      */
     readonly touch: _angular_core.OutputEmitterRef<void>;
-    protected readonly invalidState: _angular_core.Signal<boolean>;
+    /** The input's own binary invalidity (its `invalid` input or a non-empty `errors` list). */
+    private readonly ownInvalid;
+    /**
+     * Tri-state *displayed* validity: inside a `rdxFieldRoot` the field's gated `validState` is the single
+     * source (so a field whose `validationMode` defers display (e.g. `onBlur`) keeps the input neutral until revealed), otherwise
+     * the input's own binary invalidity. `true` valid / `false` invalid / `null` neutral.
+     */
+    protected readonly displayValid: _angular_core.Signal<boolean | null>;
     protected readonly disabledState: _angular_core.Signal<boolean>;
     protected readonly requiredState: _angular_core.Signal<boolean>;
     protected readonly filledState: _angular_core.Signal<boolean>;

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

@@ -6,13 +6,14 @@ import * as _angular_core from '@angular/core';
 declare class RdxLabelDirective {
     private readonly elementRef;
     /**
-     * @default 'rdx-label-{idIterator}'
+     * The label id. Defaults to a stable generated id.
+     * @group Props
      */
     readonly id: _angular_core.InputSignal<string>;
     /**
      * The id of the element the label is associated with.
      * @group Props
-     * @defaultValue false
+     * @default undefined
      */
     readonly htmlFor: _angular_core.InputSignal<string | undefined>;
     /**

package/types/radix-ng-primitives-number-field.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { RdxFormValueControl, RdxControlValueAccessor, NumberInput, BooleanInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
+import { RdxFormUiControlBase, RdxFormValueControl, RdxControlValueAccessor, NumberInput, BooleanInput, RdxCancelableChangeEventDetails, RdxFormUiTouchTarget } from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_number_field from '@radix-ng/primitives/number-field';
 import { NumberFormatter, NumberParser } from '@internationalized/number';
 import * as i1 from '@radix-ng/primitives/portal';
@@ -47,7 +47,7 @@ interface RdxNumberFieldValueChangeEvent {
  *
  * @see https://base-ui.com/react/components/number-field
  */
-declare class RdxNumberFieldRoot implements RdxFormValueControl<number | null> {
+declare class RdxNumberFieldRoot extends RdxFormUiControlBase implements RdxFormValueControl<number | null> {
     /** @ignore */
     protected readonly cva: RdxControlValueAccessor<number | null>;
     /** The id of the input element. */
@@ -138,6 +138,12 @@ declare class RdxNumberFieldRoot implements RdxFormValueControl<number | null> {
     hasPendingCommit: boolean;
     /** @ignore */
     readonly isDisabled: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly invalidState: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly touchedState: _angular_core.Signal<boolean>;
+    /** @ignore */
+    readonly dirtyState: _angular_core.Signal<boolean>;
     private readonly formatter;
     private readonly parser;
     /** @ignore The current numeric value (`null` when empty). */
@@ -170,8 +176,13 @@ declare class RdxNumberFieldRoot implements RdxFormValueControl<number | null> {
     registerInput(el: HTMLInputElement): void;
     /** @ignore Sets the displayed text without changing the numeric value. */
     setInputValue(text: string): void;
-    /** @ignore */
+    /**
+     * @ignore Mark the field touched — CVA for Reactive forms, plus the `touched` model + `touch`
+     * output for Signal Forms.
+     */
     markAsTouched(): void;
+    /** @ignore Bridge the CVA into `markAsTouched` (dual). */
+    protected formUiTouchTarget(): RdxFormUiTouchTarget;
     /**
      * @ignore
      * Validates and applies a candidate value, emitting `onValueChange` when it changes.
@@ -333,7 +344,7 @@ declare abstract class RdxNumberFieldButton {
     /** @ignore Disabled for display/focus purposes (own state, root disabled, or bound reached). */
     readonly buttonDisabled: _angular_core.Signal<boolean>;
     /** @ignore Disabled for interaction purposes (also blocked while read-only). */
-    private readonly interactionDisabled;
+    readonly interactionDisabled: _angular_core.Signal<boolean>;
     private get direction();
     private get pressReason();
     /** @ignore */

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

@@ -1,4 +1,5 @@
-import * as _angular_core from '@angular/core';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_progress from '@radix-ng/primitives/progress';
 
@@ -10,46 +11,23 @@ interface ProgressProps {
     max?: number;
     valueLabel?: ProgressValueFormatter;
 }
-declare const progressRootContext: () => {
-    labelId: _angular_core.InputSignal<string>;
-    valueId: _angular_core.InputSignal<string>;
-    minState: _angular_core.Signal<number>;
-    maxState: _angular_core.Signal<number>;
-    valueState: _angular_core.Signal<number | null>;
-    percentageState: _angular_core.Signal<number | null>;
-    valueLabelState: _angular_core.Signal<string | undefined>;
-    progressState: _angular_core.Signal<ProgressState>;
-    completeState: _angular_core.Signal<boolean>;
-    progressingState: _angular_core.Signal<boolean>;
-    indeterminateState: _angular_core.Signal<boolean>;
-};
-type RdxProgressRootContext = ReturnType<typeof progressRootContext>;
-declare const injectProgressRootContext: _radix_ng_primitives_core.InjectContext<{
-    labelId: _angular_core.InputSignal<string>;
-    valueId: _angular_core.InputSignal<string>;
-    minState: _angular_core.Signal<number>;
-    maxState: _angular_core.Signal<number>;
-    valueState: _angular_core.Signal<number | null>;
-    percentageState: _angular_core.Signal<number | null>;
-    valueLabelState: _angular_core.Signal<string | undefined>;
-    progressState: _angular_core.Signal<ProgressState>;
-    completeState: _angular_core.Signal<boolean>;
-    progressingState: _angular_core.Signal<boolean>;
-    indeterminateState: _angular_core.Signal<boolean>;
-}>;
-declare const provideProgressRootContext: (useFactory: () => {
-    labelId: _angular_core.InputSignal<string>;
-    valueId: _angular_core.InputSignal<string>;
-    minState: _angular_core.Signal<number>;
-    maxState: _angular_core.Signal<number>;
-    valueState: _angular_core.Signal<number | null>;
-    percentageState: _angular_core.Signal<number | null>;
-    valueLabelState: _angular_core.Signal<string | undefined>;
-    progressState: _angular_core.Signal<ProgressState>;
-    completeState: _angular_core.Signal<boolean>;
-    progressingState: _angular_core.Signal<boolean>;
-    indeterminateState: _angular_core.Signal<boolean>;
-}) => _angular_core.Provider;
+interface RdxProgressRootContext {
+    labelId: Signal<string>;
+    valueId: Signal<string>;
+    minState: Signal<number>;
+    maxState: Signal<number>;
+    valueState: Signal<number | null>;
+    percentageState: Signal<number | null>;
+    valueLabelState: Signal<string | undefined>;
+    progressState: Signal<ProgressState>;
+    completeState: Signal<boolean>;
+    progressingState: Signal<boolean>;
+    indeterminateState: Signal<boolean>;
+    /** A Label part registers its presence; returns its unregister callback. */
+    registerLabel: () => () => void;
+}
+declare const injectProgressRootContext: _radix_ng_primitives_core.InjectContext<RdxProgressRootContext>;
+declare const provideProgressRootContext: (useFactory: () => RdxProgressRootContext) => i0.Provider;
 /**
  * Provides progress state and accessibility attributes.
  *
@@ -62,43 +40,50 @@ declare class RdxProgressRootDirective {
      * @group Props
      * @defaultValue null
      */
-    readonly value: _angular_core.InputSignalWithTransform<number | null, number | null>;
+    readonly value: i0.InputSignalWithTransform<number | null, number | null>;
     /**
      * Minimum progress value.
      *
      * @group Props
      * @defaultValue 0
      */
-    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly min: i0.InputSignalWithTransform<number, unknown>;
     /**
      * Maximum progress value.
      *
      * @group Props
      * @defaultValue 100
      */
-    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: i0.InputSignalWithTransform<number, unknown>;
     /**
      * Formats the current value for assistive technologies and `rdxProgressValue`.
      *
      * @group Props
      */
-    readonly valueLabel: _angular_core.InputSignal<ProgressValueFormatter>;
-    readonly labelId: _angular_core.InputSignal<string>;
-    readonly valueId: _angular_core.InputSignal<string>;
-    readonly minState: _angular_core.Signal<number>;
-    readonly maxState: _angular_core.Signal<number>;
-    readonly valueState: _angular_core.Signal<number | null>;
-    readonly percentageState: _angular_core.Signal<number | null>;
-    readonly valueLabelState: _angular_core.Signal<string | undefined>;
-    readonly progressState: _angular_core.Signal<ProgressState>;
-    readonly completeState: _angular_core.Signal<boolean>;
-    readonly progressingState: _angular_core.Signal<boolean>;
-    readonly indeterminateState: _angular_core.Signal<boolean>;
+    readonly valueLabel: i0.InputSignal<ProgressValueFormatter>;
+    readonly labelId: i0.InputSignal<string>;
+    readonly valueId: i0.InputSignal<string>;
+    readonly minState: Signal<number>;
+    readonly maxState: Signal<number>;
+    readonly valueState: Signal<number | null>;
+    readonly percentageState: Signal<number | null>;
+    readonly valueLabelState: Signal<string | undefined>;
+    /** `aria-valuetext`: the formatted label, or an explicit "indeterminate progress" (Base UI parity). */
+    readonly ariaValueText: Signal<string | undefined>;
+    readonly progressState: Signal<ProgressState>;
+    readonly completeState: Signal<boolean>;
+    readonly progressingState: Signal<boolean>;
+    readonly indeterminateState: Signal<boolean>;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
+    private readonly labelCount;
+    /** Whether at least one `rdxProgressLabel` is currently mounted. */
+    readonly hasLabel: Signal<boolean>;
+    /** @ignore Called by `rdxProgressLabel` on mount; returns its unregister callback. */
+    registerLabel(): () => void;
     private valueTransform;
     private defaultValueLabel;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxProgressRootDirective, "[rdxProgressRoot]", ["rdxProgressRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "valueLabel": { "alias": "valueLabel"; "required": false; "isSignal": true; }; "labelId": { "alias": "labelId"; "required": false; "isSignal": true; }; "valueId": { "alias": "valueId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressRootDirective, "[rdxProgressRoot]", ["rdxProgressRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "valueLabel": { "alias": "valueLabel"; "required": false; "isSignal": true; }; "labelId": { "alias": "labelId"; "required": false; "isSignal": true; }; "valueId": { "alias": "valueId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -107,22 +92,11 @@ declare class RdxProgressRootDirective {
  * @group Components
  */
 declare class RdxProgressLabelDirective {
-    protected readonly progress: {
-        labelId: _angular_core.InputSignal<string>;
-        valueId: _angular_core.InputSignal<string>;
-        minState: _angular_core.Signal<number>;
-        maxState: _angular_core.Signal<number>;
-        valueState: _angular_core.Signal<number | null>;
-        percentageState: _angular_core.Signal<number | null>;
-        valueLabelState: _angular_core.Signal<string | undefined>;
-        progressState: _angular_core.Signal<_radix_ng_primitives_progress.ProgressState>;
-        completeState: _angular_core.Signal<boolean>;
-        progressingState: _angular_core.Signal<boolean>;
-        indeterminateState: _angular_core.Signal<boolean>;
-    };
+    protected readonly progress: _radix_ng_primitives_progress.RdxProgressRootContext;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressLabelDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxProgressLabelDirective, "[rdxProgressLabel]", ["rdxProgressLabel"], {}, {}, never, never, true, never>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressLabelDirective, "[rdxProgressLabel]", ["rdxProgressLabel"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -131,22 +105,10 @@ declare class RdxProgressLabelDirective {
  * @group Components
  */
 declare class RdxProgressValueDirective {
-    protected readonly progress: {
-        labelId: _angular_core.InputSignal<string>;
-        valueId: _angular_core.InputSignal<string>;
-        minState: _angular_core.Signal<number>;
-        maxState: _angular_core.Signal<number>;
-        valueState: _angular_core.Signal<number | null>;
-        percentageState: _angular_core.Signal<number | null>;
-        valueLabelState: _angular_core.Signal<string | undefined>;
-        progressState: _angular_core.Signal<_radix_ng_primitives_progress.ProgressState>;
-        completeState: _angular_core.Signal<boolean>;
-        progressingState: _angular_core.Signal<boolean>;
-        indeterminateState: _angular_core.Signal<boolean>;
-    };
+    protected readonly progress: _radix_ng_primitives_progress.RdxProgressRootContext;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressValueDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxProgressValueDirective, "[rdxProgressValue]", ["rdxProgressValue"], {}, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressValueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressValueDirective, "[rdxProgressValue]", ["rdxProgressValue"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -155,22 +117,10 @@ declare class RdxProgressValueDirective {
  * @group Components
  */
 declare class RdxProgressTrackDirective {
-    protected readonly progress: {
-        labelId: _angular_core.InputSignal<string>;
-        valueId: _angular_core.InputSignal<string>;
-        minState: _angular_core.Signal<number>;
-        maxState: _angular_core.Signal<number>;
-        valueState: _angular_core.Signal<number | null>;
-        percentageState: _angular_core.Signal<number | null>;
-        valueLabelState: _angular_core.Signal<string | undefined>;
-        progressState: _angular_core.Signal<_radix_ng_primitives_progress.ProgressState>;
-        completeState: _angular_core.Signal<boolean>;
-        progressingState: _angular_core.Signal<boolean>;
-        indeterminateState: _angular_core.Signal<boolean>;
-    };
+    protected readonly progress: _radix_ng_primitives_progress.RdxProgressRootContext;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressTrackDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxProgressTrackDirective, "[rdxProgressTrack]", ["rdxProgressTrack"], {}, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressTrackDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressTrackDirective, "[rdxProgressTrack]", ["rdxProgressTrack"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -179,28 +129,16 @@ declare class RdxProgressTrackDirective {
  * @group Components
  */
 declare class RdxProgressIndicatorDirective {
-    protected readonly progress: {
-        labelId: _angular_core.InputSignal<string>;
-        valueId: _angular_core.InputSignal<string>;
-        minState: _angular_core.Signal<number>;
-        maxState: _angular_core.Signal<number>;
-        valueState: _angular_core.Signal<number | null>;
-        percentageState: _angular_core.Signal<number | null>;
-        valueLabelState: _angular_core.Signal<string | undefined>;
-        progressState: _angular_core.Signal<_radix_ng_primitives_progress.ProgressState>;
-        completeState: _angular_core.Signal<boolean>;
-        progressingState: _angular_core.Signal<boolean>;
-        indeterminateState: _angular_core.Signal<boolean>;
-    };
+    protected readonly progress: _radix_ng_primitives_progress.RdxProgressRootContext;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressIndicatorDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxProgressIndicatorDirective, "[rdxProgressIndicator]", ["rdxProgressIndicator"], {}, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxProgressIndicatorDirective, "[rdxProgressIndicator]", ["rdxProgressIndicator"], {}, {}, never, never, true, never>;
 }
 
 declare class RdxProgressModule {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxProgressModule, never>;
-    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxProgressModule, never, [typeof RdxProgressRootDirective, typeof RdxProgressLabelDirective, typeof RdxProgressValueDirective, typeof RdxProgressTrackDirective, typeof RdxProgressIndicatorDirective], [typeof RdxProgressRootDirective, typeof RdxProgressLabelDirective, typeof RdxProgressValueDirective, typeof RdxProgressTrackDirective, typeof RdxProgressIndicatorDirective]>;
-    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxProgressModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxProgressModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RdxProgressModule, never, [typeof RdxProgressRootDirective, typeof RdxProgressLabelDirective, typeof RdxProgressValueDirective, typeof RdxProgressTrackDirective, typeof RdxProgressIndicatorDirective], [typeof RdxProgressRootDirective, typeof RdxProgressLabelDirective, typeof RdxProgressValueDirective, typeof RdxProgressTrackDirective, typeof RdxProgressIndicatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RdxProgressModule>;
 }
 
 export { RdxProgressIndicatorDirective, RdxProgressLabelDirective, RdxProgressModule, RdxProgressRootDirective, RdxProgressTrackDirective, RdxProgressValueDirective, injectProgressRootContext, provideProgressRootContext };

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

@@ -1,7 +1,7 @@
 import * as _angular_core 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 { RdxFormUiControlBase, RdxFormValueControl, BooleanInput, RdxCancelableChangeEventDetails, RdxFormUiTouchTarget } from '@radix-ng/primitives/core';
 import { ControlValueAccessor } from '@angular/forms';
 import * as i1 from '@radix-ng/primitives/composite';
 import * as _radix_ng_primitives_radio from '@radix-ng/primitives/radio';
@@ -26,7 +26,7 @@ interface RadioRootContext {
 }
 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> {
+declare class RdxRadioGroupDirective extends RdxFormUiControlBase implements ControlValueAccessor, RdxFormValueControl<string | null> {
     private readonly elementRef;
     private readonly compositeRoot;
     /**
@@ -51,6 +51,9 @@ declare class RdxRadioGroupDirective implements ControlValueAccessor, RdxFormVal
     readonly onValueChange: _angular_core.OutputEmitterRef<RdxRadioValueChangeEvent>;
     private readonly disable;
     readonly disabledState: Signal<boolean>;
+    readonly invalidState: Signal<boolean>;
+    readonly touchedState: Signal<boolean>;
+    readonly dirtyState: Signal<boolean>;
     private readonly arrowNavigation;
     private readonly itemMetadata;
     private readonly disabledIndices;
@@ -71,6 +74,8 @@ declare class RdxRadioGroupDirective implements ControlValueAccessor, RdxFormVal
      * @ignore
      */
     select(value: string | null, event?: Event, reason?: RdxRadioValueChangeReason): void;
+    /** @ignore Bridge the CVA `onTouched` so `markAsTouched()` also notifies Reactive/template forms. */
+    protected formUiTouchTarget(): RdxFormUiTouchTarget;
     /**
      * Update the value of the radio group.
      * @param value The new value of the radio group.
@@ -93,7 +98,6 @@ declare class RdxRadioGroupDirective implements ControlValueAccessor, RdxFormVal
     setDisabledState(isDisabled: boolean): void;
     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.