@radix-ng/primitives 1.0.6 → 1.0.8

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Type, Provider, InputSignal, WritableSignal, ModelSignal, Signal, InjectionToken, InputSignalWithTransform, OutputRef, Injector, ElementRef, EffectRef, EffectCleanupRegisterFn, CreateEffectOptions } from '@angular/core';
+import { Type, Provider, InputSignal, WritableSignal, ModelSignal, Signal, InjectionToken, InputSignalWithTransform, OutputRef, OutputEmitterRef, Injector, ElementRef, EffectRef, EffectCleanupRegisterFn, CreateEffectOptions } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { DateValue, Time, CalendarDateTime, ZonedDateTime } from '@internationalized/date';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
@@ -859,6 +859,209 @@ interface RdxFormCheckboxControl extends RdxFormUiControl {
     readonly value?: undefined;
 }
 
+/**
+ * Optional form-control UI state derived from a control's `invalid`/`errors`/`touched`/`dirty`
+ * inputs (the optional members of Signal Forms' `FormUiControl`), plus the two mutators every
+ * control needs.
+ *
+ * @see createFormUiState
+ */
+interface RdxFormUiState {
+    /** Invalid when the `invalid` input is set or the `errors` list is non-empty. */
+    readonly invalidState: Signal<boolean>;
+    /** Whether the control has been touched (reflects the `touched` model). */
+    readonly touchedState: Signal<boolean>;
+    /** Whether the value changed from its initial value — external `dirty` OR internal tracking. */
+    readonly dirtyState: Signal<boolean>;
+    /** Mark the control touched: bridges the CVA (if any) + sets the `touched` model + emits `touch`. */
+    markAsTouched(): void;
+    /** Flag the control dirty after a value change (feeds {@link dirtyState}). */
+    markDirty(): void;
+}
+/** Minimal `ControlValueAccessor` surface the form-UI state bridges for the dual (Reactive/template) path. */
+interface RdxFormUiTouchTarget {
+    markAsTouched(): void;
+}
+/** Inputs a control passes to {@link createFormUiState} — its own `FormUiControl` signals. */
+interface RdxFormUiStateOptions {
+    readonly invalid: Signal<boolean>;
+    readonly errors: Signal<readonly RdxValidationError[]>;
+    readonly touched: ModelSignal<boolean>;
+    readonly touch: OutputEmitterRef<void>;
+    readonly dirty: Signal<boolean>;
+    /**
+     * The control's `ControlValueAccessor`, if it has one (dual controls — switch, number-field, …).
+     * Omit or pass `null` for Signal-Forms-only controls without a CVA (e.g. select).
+     */
+    readonly cva?: RdxFormUiTouchTarget | null;
+}
+/**
+ * Builds the shared form-UI state and its mutators from a control's input signals, removing the
+ * per-control copy-paste of the `invalidState`/`touchedState`/`dirtyState` computeds and the
+ * `markAsTouched`/`markDirty` logic.
+ *
+ * **Why the inputs stay on the control (not in here):** Angular's compiler only discovers
+ * `input()`/`model()` declared as field initializers, and Signal Forms binds form-written state
+ * (`errors`/`disabled`/`touched`) onto the single directive that carries the `value`/`checked`
+ * model — so the inputs must co-locate with `value` on the control directive. This helper takes
+ * those signals and centralizes only the derivation.
+ *
+ * Safe to call from a field initializer: `signal()`/`computed()` need no injection context.
+ */
+declare function createFormUiState(options: RdxFormUiStateOptions): RdxFormUiState;
+/**
+ * The subset of a compound primitive's context that surfaces the shared form-UI state to its child
+ * parts (so a trigger/button/input can reflect `data-invalid`/`data-touched`/`data-dirty` and call
+ * `markAsTouched()`). Compound-control context interfaces should `extends` this.
+ */
+interface RdxFormUiStateContext {
+    invalidState: Signal<boolean>;
+    touchedState: Signal<boolean>;
+    dirtyState: Signal<boolean>;
+    markAsTouched: () => void;
+}
+/** Spread helper to wire {@link RdxFormUiStateContext} fields from an {@link RdxFormUiState} into a context factory. */
+declare function formUiStateContext(state: RdxFormUiState): RdxFormUiStateContext;
+/** DI token holding the control's {@link RdxFormUiState}, read by {@link RdxFormUiStateHost}. */
+declare const RDX_FORM_UI_STATE: InjectionToken<RdxFormUiState>;
+/**
+ * Tri-state *displayed* validity (`true` valid / `false` invalid / `null` neutral) an enclosing `Field`
+ * exposes so a control can reflect the field's single, gated display-state instead of its own eager
+ * invalid. A control inside a `rdxFieldRoot` reads this for its `data-valid` / `data-invalid` /
+ * `aria-invalid`; standalone (token absent) it falls back to its own binary invalidity. This keeps the
+ * field root, the control, and any trigger/group part on one display-state (Base UI's `valid: boolean |
+ * null`). `Field` provides it (`useFactory` over the root's `validState`).
+ */
+declare const RDX_FIELD_VALIDITY: InjectionToken<Signal<boolean | null>>;
+/**
+ * Tri-state display validity: when inside a `Field` the field's gated `validState` is the **single
+ * source** (the control reflects it, including its `validationMode` neutral state); standalone, the
+ * control's own binary invalidity.
+ *
+ * **Contract:** inside a `Field` a control's own `invalid` / `errors` inputs are **not** displayed — the
+ * Field owns displayed validity. Drive validity through the Field instead: bind `rdxSignalField`
+ * (Signal Forms), or set `[invalid]` on `rdxFieldRoot`. The control's own `invalid`/`errors` are for
+ * standalone use.
+ */
+declare function resolveDisplayValid(fieldValidity: Signal<boolean | null> | null, ownInvalid: Signal<boolean>): boolean | null;
+/**
+ * Provide a control's {@link RdxFormUiState} on its host element so {@link RdxFormUiStateHost} can
+ * reflect it. Pair with `hostDirectives: [RdxFormUiStateHost]`:
+ *
+ * ```ts
+ * providers: [provideFormUiState(() => inject(MyControl).formUi)],
+ * hostDirectives: [RdxFormUiStateHost]
+ * ```
+ */
+declare function provideFormUiState(state: () => RdxFormUiState): Provider;
+/**
+ * Host directive that reflects a control's {@link RdxFormUiState} as the standard validation
+ * `data-*`/`aria-invalid` attributes and marks the control touched on focus-out — the binding block
+ * that was otherwise copy-pasted into every form control's `host`.
+ *
+ * Compose it via `hostDirectives` on a control (or group root) whose host element is the one that
+ * should carry the attributes, and provide the state with {@link provideFormUiState}. It reads the
+ * state from DI, so the control does not need to expose `invalidState`/`touchedState`/`dirtyState`
+ * or a `markAsTouched` method just for the host bindings.
+ *
+ * Note: the `focusout` listener marks touched for controls whose touched-trigger is blur/focus-out
+ * (text inputs, groups). Controls that latch touched on interaction instead (e.g. checkbox) still do
+ * so themselves; the extra focus-out call only ever sets `touched` to `true`, so it is harmless.
+ *
+ * Not for compound controls that surface state on a child part via context (e.g. select reflects on
+ * its trigger) — those keep their own child-part bindings.
+ */
+declare class RdxFormUiStateHost {
+    /** @ignore The injected state the host bindings read. */
+    protected readonly formUi: RdxFormUiState;
+    private readonly fieldValidity;
+    /** @ignore Tri-state display validity (enclosing Field's gated state, else own invalidity). */
+    protected readonly displayValid: Signal<boolean | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFormUiStateHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFormUiStateHost, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Abstract base that declares the optional `FormUiControl` state inputs
+ * (`invalid`/`errors`/`touched`/`dirty` + the `touch` output) once and builds the control's
+ * {@link RdxFormUiState} from them, so a control directive can inherit the whole surface with a
+ * single `extends` instead of re-declaring it.
+ *
+ * The declarations must live on a decorated **directive class** (Angular only discovers
+ * `input()`/`model()`/`output()` as field initializers, and Signal Forms binds form-written state
+ * onto the single directive carrying the `value`/`checked` model) — inheritance keeps them on that
+ * directive, which a host directive could not. The control still declares its own `value`/`checked`
+ * model (the type-parametric part) and, for `data-*` reflection, either composes
+ * {@link RdxFormUiStateHost} or binds the attributes itself.
+ *
+ * Dual controls override {@link formUiTouchTarget} to bridge their `ControlValueAccessor` into
+ * `markAsTouched`.
+ */
+declare abstract class RdxFormUiControlBase {
+    /** Whether the control is invalid. A non-empty {@link errors} list also marks it invalid. */
+    readonly invalid: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether the control has been touched. A `model()` so Signal Forms can write it; set on blur/focus-out. */
+    readonly touched: ModelSignal<boolean>;
+    /** Whether the value changed from its initial value. Merged with internal tracking. */
+    readonly dirty: i0.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Validation errors for the control. A non-empty list marks it invalid. */
+    readonly errors: i0.InputSignal<readonly RdxValidationError[]>;
+    /** Emits when the control is touched, notifying Signal Forms (stable Angular 22 contract). */
+    readonly touch: OutputEmitterRef<void>;
+    /** The shared form-UI state derived from the inputs above. Call `formUi.markDirty()` on value change. */
+    readonly formUi: RdxFormUiState;
+    /** The enclosing Field's tri-state display validity, if any. `protected` so a control whose own
+     * invalidity is richer than `formUi.invalidState` (e.g. date/time-field add a parse check) can build
+     * its own `displayValid` from it. */
+    protected readonly fieldValidity: Signal<boolean | null> | null;
+    /**
+     * Tri-state *displayed* validity for controls that bind their own host attributes (radio, switch,
+     * number-field): the enclosing Field's gated state when inside a `rdxFieldRoot`, else this control's
+     * own binary invalidity (`formUi.invalidState`). Bind `data-valid`/`data-invalid`/`aria-invalid` to
+     * this so a neutral field shows neither. Controls whose `invalidState` is richer than
+     * `formUi.invalidState` override this with `resolveDisplayValid(this.fieldValidity, this.invalidState)`.
+     */
+    readonly displayValid: Signal<boolean | null>;
+    /**
+     * Override to bridge the control's `ControlValueAccessor` into `markAsTouched` (dual controls —
+     * return `injectControlValueAccessor()` or a `{ markAsTouched }` adapter). Default: no CVA
+     * (Signal-Forms-only controls such as select).
+     */
+    protected formUiTouchTarget(): RdxFormUiTouchTarget | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFormUiControlBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFormUiControlBase, never, never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * When a `Field` reveals its validity (the `data-valid` / `data-invalid` styling and the error message)
+ * — the form-system-agnostic equivalent of Base UI's `validationMode` and Angular Material's
+ * `ErrorStateMatcher`. The control/adapter always reports the **actual** state (`invalid` / `errors` /
+ * `touched` / `dirty`); the Field decides **when** to surface it from this mode.
+ *
+ * - `'always'` — reflect validity immediately (an empty required field shows its error on first render).
+ * - `'onChange'` — reveal once the user has changed the value (dirty), or the form submitted. A blur
+ *   alone does not reveal — that is `'onBlur'`'s behavior.
+ * - `'onBlur'` — reveal once the field has been touched (blurred), or the form submitted (the default).
+ * - `'onSubmit'` — reveal only after a submit has been attempted.
+ *
+ * Server/external errors are **not** gated by this mode — they surface immediately (they were set
+ * explicitly, e.g. from a submit response).
+ */
+type RdxValidationMode = 'always' | 'onChange' | 'onBlur' | 'onSubmit';
+/** The default validation-display mode when neither `rdxFieldRoot` nor `rdxFormRoot` sets one. */
+declare const RDX_DEFAULT_VALIDATION_MODE: RdxValidationMode;
+/** The field interaction state {@link isValidationRevealed} reads to decide whether to reveal validity. */
+interface RdxValidationInteraction {
+    touched: boolean;
+    dirty: boolean;
+    submitAttempted: boolean;
+}
+/**
+ * Whether a Field should reveal its (client-side) validity given the {@link RdxValidationMode} and the
+ * field's interaction state. `false` means stay neutral (neither `data-valid` nor `data-invalid`, error
+ * hidden); `true` means reflect the actual validity.
+ */
+declare function isValidationRevealed(mode: RdxValidationMode, interaction: RdxValidationInteraction): boolean;
+
 interface RdxCancelableChangeEventDetails<Reason extends string = string> {
     reason: Reason;
     event: Event;
@@ -1850,5 +2053,5 @@ declare enum RdxPositionAlign {
     End = "end"
 }
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, DOCS_BASE_URL, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_FLOATING_REGISTRATION, RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_TREE, RDX_INTERNAL_BACKDROP_ATTR, RDX_SCROLL_LOCKED_ATTR, RdxControlValueAccessor, RdxFloatingNode, RdxFloatingNodeRegistration, RdxFloatingRegistrationContext, RdxFloatingRootContext, RdxFloatingTree, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, RdxTriggerRegistry, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createCancelableChangeEventDetails, createContent, createContext, createFloatingEvents, createFloatingRootContext, createFormatter, createMonth, createMonths, docsUrl, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectFloatingRootContext, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideFloatingRegistration, provideFloatingRootContext, provideFloatingTree, provideToken, provideValueAccessor, rdxCheckLabelElement, rdxCheckTriggerElement, rdxDevError, rdxDevWarning, resetRdxDevWarnings, resizeEffect, resolveFloatingTree, roundToStepPrecision, segmentBuilders, setupInternalBackdrop, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useAnchoredScrollLock, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
-export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, FilterPredicates, Formatter, Granularity, HourCycle, InjectContext, ItemValueComparator, ListHighlight, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxAnchoredScrollLockOptions, RdxCancelableChangeEventDetails, RdxCancelableChangeEventTransaction, RdxFloatingEventMap, RdxFloatingEvents, RdxFloatingLifecycle, RdxFloatingNodeInit, RdxFloatingParentOverride, RdxFloatingRegistrationReader, RdxFloatingRegistrationStatus, RdxFloatingRootContextEventMap, RdxFloatingRootContextInit, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormValueControl, RdxInternalBackdropOptions, RdxPointerDragHandlers, RdxScrollLockOptions, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps, UseFilterOptions, UseListHighlightOptions };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, DOCS_BASE_URL, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_DEFAULT_VALIDATION_MODE, RDX_FIELD_VALIDITY, RDX_FLOATING_REGISTRATION, RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_TREE, RDX_FORM_UI_STATE, RDX_INTERNAL_BACKDROP_ATTR, RDX_SCROLL_LOCKED_ATTR, RdxControlValueAccessor, RdxFloatingNode, RdxFloatingNodeRegistration, RdxFloatingRegistrationContext, RdxFloatingRootContext, RdxFloatingTree, RdxFormUiControlBase, RdxFormUiStateHost, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, RdxTriggerRegistry, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createCancelableChangeEventDetails, createContent, createContext, createFloatingEvents, createFloatingRootContext, createFormUiState, createFormatter, createMonth, createMonths, docsUrl, elementSize, formUiStateContext, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectFloatingRootContext, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isValidationRevealed, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideFloatingRegistration, provideFloatingRootContext, provideFloatingTree, provideFormUiState, provideToken, provideValueAccessor, rdxCheckLabelElement, rdxCheckTriggerElement, rdxDevError, rdxDevWarning, resetRdxDevWarnings, resizeEffect, resolveDisplayValid, resolveFloatingTree, roundToStepPrecision, segmentBuilders, setupInternalBackdrop, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useAnchoredScrollLock, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
+export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, FilterPredicates, Formatter, Granularity, HourCycle, InjectContext, ItemValueComparator, ListHighlight, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxAnchoredScrollLockOptions, RdxCancelableChangeEventDetails, RdxCancelableChangeEventTransaction, RdxFloatingEventMap, RdxFloatingEvents, RdxFloatingLifecycle, RdxFloatingNodeInit, RdxFloatingParentOverride, RdxFloatingRegistrationReader, RdxFloatingRegistrationStatus, RdxFloatingRootContextEventMap, RdxFloatingRootContextInit, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormUiState, RdxFormUiStateContext, RdxFormUiStateOptions, RdxFormUiTouchTarget, RdxFormValueControl, RdxInternalBackdropOptions, RdxPointerDragHandlers, RdxScrollLockOptions, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, RdxValidationInteraction, RdxValidationMode, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps, UseFilterOptions, UseListHighlightOptions };

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

@@ -1,10 +1,10 @@
 import * as _angular_core from '@angular/core';
 import { Signal, InjectionToken, InputSignal, ModelSignal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { DateMatcher, HourCycle, Granularity, Direction, BooleanInput, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
+import { RdxFormUiControlBase, RdxFormValueControl, DateMatcher, HourCycle, Granularity, Direction, BooleanInput, DateStep, Formatter, SegmentValueObj, SegmentPart } from '@radix-ng/primitives/core';
 import { DateValue } from '@internationalized/date';
 
-declare class RdxDateFieldRootDirective {
+declare class RdxDateFieldRootDirective extends RdxFormUiControlBase implements RdxFormValueControl<DateValue | undefined> {
     /**
      * The controlled value of the date field.
      */
@@ -96,6 +96,25 @@ declare class RdxDateFieldRootDirective {
      * @ignore
      */
     readonly isInvalid: Signal<boolean>;
+    /**
+     * @ignore Effective invalid: the built-in range/availability check OR the form-driven
+     * `invalid` / `errors` (Signal Forms). Reflected on the root and segments.
+     */
+    readonly invalidState: Signal<boolean>;
+    /**
+     * @ignore Tri-state display validity: the enclosing Field's gated state when inside a `rdxFieldRoot`,
+     * else the date-field's own (parse + form) invalidity. Overrides the base (whose default uses only
+     * `formUi.invalidState`) so the standalone path keeps the built-in range/availability check.
+     */
+    readonly displayValid: Signal<boolean | null>;
+    /** @ignore */
+    readonly touchedState: Signal<boolean>;
+    /** @ignore */
+    readonly dirtyState: Signal<boolean>;
+    /** @ignore Whether the user has focused a segment — gates dirty tracking so a form/initial seed of `value` doesn't mark dirty. */
+    private readonly userInteracted;
+    /** @ignore Mark the field touched (model + `touch` output) for Signal Forms. Called on segment blur. */
+    markAsTouched(): void;
     /**
      * @ignore
      */
@@ -168,6 +187,8 @@ declare class RdxDateFieldInputDirective {
      * @ignore
      */
     readonly isInvalid: _angular_core.Signal<boolean>;
+    /** @ignore Tri-state display validity from the root (gated by an enclosing Field). */
+    readonly displayValid: _angular_core.Signal<boolean | null>;
     /**
      * @ignore
      */
@@ -211,6 +232,10 @@ interface DateFieldContextToken {
     disabled: InputSignal<boolean>;
     readonly: InputSignal<boolean>;
     isInvalid: Signal<boolean>;
+    /** Effective invalid: the built-in range/availability check OR the form-driven invalid state. */
+    invalidState: Signal<boolean>;
+    /** Tri-state displayed validity (`true`/`false`/`null`): the field's gated state inside a Field, else own. */
+    displayValid: Signal<boolean | null>;
     placeholder: ModelSignal<DateValue>;
     hourCycle: InputSignal<HourCycle>;
     step$: Signal<DateStep>;

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { BooleanInput, NumberInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
+import { RdxFormUiControlBase, RdxFormValueControl, BooleanInput, NumberInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dismissable-layer';
 import * as _radix_ng_primitives_editable from '@radix-ng/primitives/editable';
 
@@ -15,6 +15,11 @@ interface RdxEditableValueChangeEvent {
 }
 type EditableRootContext = {
     disabled: Signal<boolean>;
+    invalidState: Signal<boolean>;
+    /** Tri-state displayed validity (`true`/`false`/`null`): the field's gated state inside a Field, else own. */
+    displayValid: Signal<boolean | null>;
+    touchedState: Signal<boolean>;
+    dirtyState: Signal<boolean>;
     value: Signal<string | undefined>;
     inputValue: WritableSignal<string | undefined>;
     placeholder: Signal<{
@@ -43,10 +48,16 @@ declare const provideEditableRootContext: (useFactory: () => EditableRootContext
 /**
  * @group Components
  */
-declare class RdxEditableRoot {
+declare class RdxEditableRoot extends RdxFormUiControlBase implements RdxFormValueControl<string | undefined> {
     private readonly focusOutside;
     private readonly pointerDownOutside;
     readonly value: _angular_core.ModelSignal<string | undefined>;
+    /** @ignore */
+    readonly invalidState: Signal<boolean>;
+    /** @ignore */
+    readonly touchedState: Signal<boolean>;
+    /** @ignore */
+    readonly dirtyState: Signal<boolean>;
     /** Uncontrolled initial value. */
     readonly defaultValue: _angular_core.InputSignal<string | undefined>;
     readonly placeholder: _angular_core.InputSignal<string>;
@@ -80,6 +91,8 @@ declare class RdxEditableRoot {
     private suppressFocusActivation;
     constructor();
     canActivateOnFocus(): boolean;
+    /** @ignore Mark the field touched (model + `touch` output) for Signal Forms. Called on leaving edit mode. */
+    markAsTouched(): void;
     handleDismiss(): void;
     submit(event?: Event): void;
     cancel(): void;