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

package/types/radix-ng-primitives-context-menu.d.ts

@@ -1,9 +1,10 @@
 import * as i0 from '@angular/core';
 import { Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/menu';
 import { RdxMenuRoot, RdxMenuAutoFocusInput } from '@radix-ng/primitives/menu';
 import * as _radix_ng_primitives_context_menu from '@radix-ng/primitives/context-menu';
-import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
 
 interface RdxContextMenuRootContext {
     /** Whether the context menu is currently open. */
@@ -15,7 +16,7 @@ interface RdxContextMenuRootContext {
     /** Close the menu. */
     close: () => void;
 }
-declare const injectRdxContextMenuRootContext: (optional?: boolean) => RdxContextMenuRootContext | null;
+declare const injectRdxContextMenuRootContext: _radix_ng_primitives_core.InjectContext<RdxContextMenuRootContext>;
 declare const provideRdxContextMenuRootContext: (useFactory: () => RdxContextMenuRootContext) => i0.Provider;
 /**
  * Groups all parts of a context menu. Composes the Menu primitive but, instead of anchoring the

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

@@ -151,6 +151,17 @@ declare function roundToStepPrecision(value: number, step: number): number;
  */
 declare function snapValueToStep(value: number, min: number | undefined, max: number | undefined, step: number): number;
 
+/**
+ * Retrieves the context value from Angular's dependency injection.
+ * Overloaded so the non-optional call returns a non-nullable `T` (no `!` needed),
+ * while the optional call may return `null`.
+ */
+interface InjectContext<T> {
+    (): T;
+    (optional: false): T;
+    (optional: true): T | null;
+    (optional?: boolean): T | null;
+}
 /**
  * Creates a context with injector and provider functions for a given type
  * @template T The type of the context value
@@ -159,7 +170,7 @@ declare function snapValueToStep(value: number, min: number | undefined, max: nu
  *   - injectContext: Function to retrieve the context value
  *   - provideContext: Function to create a provider for the context
  */
-declare function createContext<T>(description: string): readonly [injectContext: (optional?: boolean) => T | null, provideContext: (useFactory: () => T) => Provider];
+declare function createContext<T>(description: string): readonly [injectContext: InjectContext<T>, provideContext: (useFactory: () => T) => Provider];
 
 declare const DATE_SEGMENT_PARTS: readonly ["day", "month", "year"];
 declare const TIME_SEGMENT_PARTS: readonly ["hour", "minute", "second", "dayPeriod"];
@@ -882,6 +893,34 @@ declare function useGraceArea(triggerEl: Signal<HTMLElement | null | undefined>,
     onPointerExit: (callback: (value: void) => void) => () => void;
 };
 
+interface RdxPointerDragHandlers {
+    /** Whether a press may begin a drag (e.g. enabled, not on an opt-out element, at a scroll edge). */
+    canStart: (event: PointerEvent) => boolean;
+    /** A drag actually began (the pointer moved past the start threshold). */
+    onStart: (event: PointerEvent) => void;
+    /** Pointer moved during a drag. Return `false` to end the gesture early (treated as not committed). */
+    onMove: (event: PointerEvent) => void | boolean;
+    /** The drag ended. `committed` is true only for a normal `pointerup`, false for cancel/lost-capture/early-stop. */
+    onEnd: (event: PointerEvent, committed: boolean) => void;
+}
+/**
+ * Shared pointer-drag lifecycle for gesture primitives (drawer swipe, toast swipe, etc.).
+ *
+ * A press only becomes a drag once the pointer moves past {@link DRAG_THRESHOLD}; until then it is a
+ * plain tap, so clicks on buttons inside the element keep working (the gesture never captures the
+ * pointer for a tap). Once dragging, the pointer is captured so a drag that leaves the element still
+ * completes, and `lostpointercapture` / `pointercancel` count as a non-committed end — a swallowed
+ * `pointerup` (native context menu, OS gesture, tab switch) can never wedge the gesture. Only the
+ * primary pointer is tracked, so a second finger can't start a parallel gesture. No-op outside the
+ * browser, keeping SSR safe.
+ *
+ * `onEnd` is NOT called if the host is destroyed mid-drag — callers that pair `onStart`/`onEnd`
+ * (e.g. to pause/resume timers) should balance that case in their own `DestroyRef` cleanup.
+ *
+ * Must be called from an injection context (a directive/component constructor).
+ */
+declare function usePointerDrag(handlers: RdxPointerDragHandlers): void;
+
 /**
  * Lifecycle phase of an open/close transition.
  *
@@ -969,5 +1008,5 @@ declare enum RdxPositionAlign {
     End = "end"
 }
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RdxControlValueAccessor, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, useGraceArea, useScrollLock, useTransitionStatus, watch };
-export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, Formatter, Granularity, HourCycle, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormValueControl, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RdxControlValueAccessor, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, useGraceArea, usePointerDrag, useScrollLock, useTransitionStatus, watch };
+export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, Formatter, Granularity, HourCycle, InjectContext, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormValueControl, RdxPointerDragHandlers, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps };

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

@@ -1,28 +1,21 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, InputSignal, WritableSignal } from '@angular/core';
-import { NumberInput } from '@radix-ng/primitives/core';
+import { InputSignal, Signal } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_cropper from '@radix-ng/primitives/cropper';
 
-interface CropperContextToken {
-    image: InputSignal<string>;
-    getImageProps: () => {
-        [key: string]: any;
-    };
-    getImageWrapperStyle: () => Record<string, string>;
-    getCropAreaStyle: () => Record<string, string>;
-    descriptionId: WritableSignal<string>;
-}
-declare const CROPPER_ROOT_CONTEXT: InjectionToken<CropperContextToken>;
-declare function injectCropperRootContext(): CropperContextToken;
-
+/** A crop rectangle in the source image's natural-pixel coordinate space. */
 type Area = {
     x: number;
     y: number;
     width: number;
     height: number;
 };
-declare class RdxCropperRootDirective implements CropperContextToken {
+
+declare class RdxCropperRootDirective {
     private readonly elementRef;
+    private readonly injector;
+    private readonly isBrowser;
     private readonly CROPPER_DESC_WARN_MESSAGE;
     readonly image: _angular_core.InputSignal<string>;
     readonly cropPadding: _angular_core.InputSignalWithTransform<number, unknown>;
@@ -30,29 +23,55 @@ declare class RdxCropperRootDirective implements CropperContextToken {
     readonly minZoom: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly maxZoom: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly zoomSensitivity: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Pan distance (px) per arrow-key press. */
     readonly keyboardStep: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Zoom delta per `+` / `-` / `PageUp` / `PageDown` press. */
+    readonly zoomKeyboardStep: _angular_core.InputSignalWithTransform<number, unknown>;
     readonly zoom: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
+    /** Accessible name for the cropper widget. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Disables all interaction (drag, wheel/pinch zoom, keyboard); exposed as `data-disabled`. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly onCropChange: _angular_core.OutputEmitterRef<Area | null>;
     readonly onZoomChange: _angular_core.OutputEmitterRef<number>;
     private readonly imgWidth;
     private readonly imgHeight;
+    /** Raw content-box size (px) of the root, fed by the ResizeObserver / initial measure. */
+    private readonly containerSize;
+    /**
+     * Crop-area size derived from the container minus padding, fitted to `aspectRatio`. A `computed`
+     * (not a written signal) so it stays reactive to `aspectRatio` / `cropPadding` changes, not only
+     * to container resizes — previously these inputs were read inside the ResizeObserver closure and
+     * never recomputed until the next resize.
+     */
+    private readonly cropAreaSize;
     private readonly cropAreaWidth;
     private readonly cropAreaHeight;
     private readonly imageWrapperWidth;
     private readonly imageWrapperHeight;
-    private readonly offsetX;
-    private readonly offsetY;
+    /** Raw (unclamped) pan-offset intent (px) written by gestures; clamping lives in `clampedOffset`. */
+    private readonly offset;
     private readonly internalZoom;
-    private readonly isDragging;
-    readonly descriptionId: _angular_core.WritableSignal<string>;
+    protected readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly descriptionId: string;
     private readonly isZoomControlled;
     protected readonly effectiveZoom: _angular_core.Signal<number>;
-    protected readonly zoomValueText: _angular_core.Signal<string>;
+    /**
+     * The applied pan offset (px): the raw intent clamped to keep the image covering the crop window
+     * at the current geometry/zoom. Derived (not an effect) so it self-corrects when the container
+     * resizes or the zoom/aspect-ratio changes — no write-back, no `untracked` re-entrancy. This is the
+     * value the view renders and the crop math reads.
+     */
+    private readonly clampedOffset;
+    /**
+     * Crop rectangle derived from the rendered pan/zoom — the single source of truth for emission.
+     * `onCropChange` fires from one effect watching this, so interactions/handlers never emit directly
+     * (which previously double-emitted). Value equality keeps it from notifying on equal results.
+     */
+    private readonly cropData;
     private readonly dragStartPoint;
     private readonly dragStartOffset;
-    private readonly latestRestrictedOffset;
     private readonly latestZoom;
-    private readonly isInitialSetupDone;
     private readonly initialPinchDistance;
     private readonly initialPinchZoom;
     private readonly isPinching;
@@ -62,75 +81,89 @@ declare class RdxCropperRootDirective implements CropperContextToken {
     private initializeContainerDimensions;
     private setupImageLoadEffect;
     private setupDimensionsEffects;
+    /** Current rendered geometry the crop math operates on, read from the state signals. */
+    private geometry;
     private restrictOffset;
-    private calculateCropData;
-    private setupCropCalculationEffect;
     private setupAccessibilityWarningEffect;
+    /**
+     * Single attachment point for every interaction listener. Re-runs on `disabled()`, so a disabled
+     * cropper has NO interaction listeners bound at all — there is no per-handler `disabled` check to
+     * forget, and a new gesture path can't accidentally bypass the gate. Uses `{ passive: false }` so
+     * the handlers can `preventDefault()` (wheel/touch scrolling, arrow-key page scroll).
+     */
     private setupEventListenersEffect;
-    private handleInteractionEnd;
+    private onMouseDown;
     /**
-     * @ignore
+     * Zoom toward an anchor point (coordinates relative to the root's center). `fromZoom`/`fromOffset`
+     * are the zoom/offset the anchor is measured against — the live state for wheel/keyboard, the
+     * gesture-start baseline for pinch. Emits the zoom request via {@link updateZoom}, then re-anchors
+     * the pan offset **only when the zoom is uncontrolled**: in controlled mode the rendered zoom does
+     * not change until the parent writes `zoom` back, so writing an offset for a not-yet-applied zoom
+     * would pan the image without rescaling it (`clampedOffset` re-derives once the new zoom applies).
      */
-    onMouseDown(e: MouseEvent): void;
+    private zoomToPoint;
     private handleWheel;
     private getPinchDistance;
     private getPinchCenter;
     private handleTouchStart;
     private handleTouchMove;
     private handleTouchEnd;
+    private onKeyDown;
+    /** Zoom by `delta` keeping the crop center fixed (the keyboard counterpart of wheel/pinch zoom). */
+    private zoomFromCenter;
     /**
-     * @ignore
+     * Inline style for the image wrapper: measured size, centered in the root, then translated and
+     * scaled by the current pan offset and zoom. A `computed` (not a method) so the `[style]` binding
+     * only re-applies when an input actually changes — a per-change-detection method call would
+     * allocate a new object every tick and force a constant re-bind.
      */
-    onKeyDown(e: KeyboardEvent): void;
-    /**
-     * @ignore
-     */
-    onKeyUp(e: KeyboardEvent): void;
-    /**
-     * @ignore
-     */
-    getImageProps(): {
-        [key: string]: any;
-    };
-    /**
-     * @ignore
-     */
-    getImageWrapperStyle(): Record<string, string>;
-    /**
-     * @ignore
-     */
-    getCropAreaStyle(): Record<string, string>;
+    readonly imageWrapperStyle: _angular_core.Signal<Record<string, string>>;
+    /** Inline style for the crop-area overlay (its measured width/height). */
+    readonly cropAreaStyle: _angular_core.Signal<Record<string, string>>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperRootDirective, "[rdxCropperRoot]", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "cropPadding": { "alias": "cropPadding"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "zoomSensitivity": { "alias": "zoomSensitivity"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, { "onCropChange": "onCropChange"; "onZoomChange": "onZoomChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperRootDirective, "[rdxCropperRoot]", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "cropPadding": { "alias": "cropPadding"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "zoomSensitivity": { "alias": "zoomSensitivity"; "required": false; "isSignal": true; }; "keyboardStep": { "alias": "keyboardStep"; "required": false; "isSignal": true; }; "zoomKeyboardStep": { "alias": "zoomKeyboardStep"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "onCropChange": "onCropChange"; "onZoomChange": "onZoomChange"; }, never, never, true, never>;
 }
 
 declare class RdxCropperImageComponent {
-    protected readonly rootContext: _radix_ng_primitives_cropper.CropperContextToken;
+    protected readonly rootContext: _radix_ng_primitives_cropper.CropperRootContext;
     readonly imgClass: _angular_core.InputSignal<string | undefined>;
     readonly imgStyles: _angular_core.InputSignal<string | undefined>;
-    protected readonly imgClasses: _angular_core.Signal<string | undefined>;
-    protected readonly imgStyless: _angular_core.Signal<string | undefined>;
+    /**
+     * `alt` text for the rendered image. Defaults to `''` (decorative — screen readers skip it, since
+     * the cropper widget describes itself via the root's label/description). Set a non-empty value to
+     * give the image a meaningful accessible name.
+     */
+    readonly imgAlt: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperImageComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxCropperImageComponent, "[rdxCropperImage]", never, { "imgClass": { "alias": "imgClass"; "required": false; "isSignal": true; }; "imgStyles": { "alias": "imgStyles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RdxCropperImageComponent, "[rdxCropperImage]", never, { "imgClass": { "alias": "imgClass"; "required": false; "isSignal": true; }; "imgStyles": { "alias": "imgStyles"; "required": false; "isSignal": true; }; "imgAlt": { "alias": "imgAlt"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class RdxCropperCropAreaDirective {
-    readonly rootContext: _radix_ng_primitives_cropper.CropperContextToken;
+    readonly rootContext: _radix_ng_primitives_cropper.CropperRootContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperCropAreaDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperCropAreaDirective, "[rdxCropperCropArea]", never, {}, {}, never, never, true, never>;
 }
 
 declare class RdxCropperDescriptionDirective {
-    readonly rootContext: _radix_ng_primitives_cropper.CropperContextToken;
+    readonly rootContext: _radix_ng_primitives_cropper.CropperRootContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperDescriptionDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxCropperDescriptionDirective, "[rdxCropperDescription]", never, {}, {}, never, never, true, never>;
 }
 
+interface CropperRootContext {
+    image: InputSignal<string>;
+    imageWrapperStyle: Signal<Record<string, string>>;
+    cropAreaStyle: Signal<Record<string, string>>;
+    descriptionId: string;
+}
+declare const injectCropperRootContext: _radix_ng_primitives_core.InjectContext<CropperRootContext>;
+declare const provideCropperRootContext: (useFactory: () => CropperRootContext) => _angular_core.Provider;
+
 declare class RdxCropperModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxCropperModule, never>;
     static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxCropperModule, never, [typeof RdxCropperRootDirective, typeof RdxCropperImageComponent, typeof RdxCropperCropAreaDirective, typeof RdxCropperDescriptionDirective], [typeof RdxCropperRootDirective, typeof RdxCropperImageComponent, typeof RdxCropperCropAreaDirective, typeof RdxCropperDescriptionDirective]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxCropperModule>;
 }
 
-export { CROPPER_ROOT_CONTEXT, RdxCropperCropAreaDirective, RdxCropperDescriptionDirective, RdxCropperImageComponent, RdxCropperModule, RdxCropperRootDirective, injectCropperRootContext };
-export type { Area, CropperContextToken };
+export { RdxCropperCropAreaDirective, RdxCropperDescriptionDirective, RdxCropperImageComponent, RdxCropperModule, RdxCropperRootDirective, injectCropperRootContext, provideCropperRootContext };
+export type { Area, CropperRootContext };

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

@@ -6,11 +6,11 @@ import { DateValue } from '@internationalized/date';
 
 declare class RdxDateFieldRootDirective {
     /**
-     * The controlled checked state of the calendar.
+     * The controlled value of the date field.
      */
     readonly value: _angular_core.ModelSignal<DateValue | undefined>;
     /**
-     * A callback fired when the date field's value is invalid.
+     * A matcher that marks specific dates as unavailable; a matched value makes the field invalid.
      */
     readonly isDateUnavailable: _angular_core.InputSignal<DateMatcher | undefined>;
     /**
@@ -178,14 +178,20 @@ declare class RdxDateFieldInputDirective {
     private readonly fieldData;
     private readonly attributes;
     /**
+     * Attribute keys applied imperatively on the previous effect run, so keys that
+     * disappear from `attributes()` are removed instead of lingering as stale state.
      * @ignore
      */
-    handleSegmentClick: (e: Event) => void;
+    private appliedAttrs;
+    constructor();
     /**
      * @ignore
      */
-    handleSegmentKeydown: (e: Event) => void;
-    constructor();
+    handleSegmentClick(event: Event): void;
+    /**
+     * @ignore
+     */
+    handleSegmentKeydown(event: Event): void;
     /**
      * @ignore
      */

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

@@ -1,6 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/presence';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { RdxTransitionStatus, BooleanInput } from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_dialog from '@radix-ng/primitives/dialog';
 import * as i1$1 from '@radix-ng/primitives/portal';
@@ -93,7 +94,7 @@ interface RdxDialogRootContext {
     close: (reason?: RdxDialogOpenChangeReason, event?: Event) => void;
     toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
 }
-declare const injectRdxDialogRootContext: (optional?: boolean) => RdxDialogRootContext | null;
+declare const injectRdxDialogRootContext: _radix_ng_primitives_core.InjectContext<RdxDialogRootContext>;
 declare const provideRdxDialogRootContext: (useFactory: () => RdxDialogRootContext) => _angular_core.Provider;
 /**
  * Groups all parts of the dialog.

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

@@ -1,6 +1,8 @@
 import * as i0 from '@angular/core';
 import { Signal, Provider } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
+export { RdxPointerDragHandlers, usePointerDrag } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dialog';
 import { RdxDialogHandle } from '@radix-ng/primitives/dialog';
 import * as _radix_ng_primitives_drawer from '@radix-ng/primitives/drawer';
@@ -183,7 +185,7 @@ interface RdxDrawerRootContext {
     /** Reports the popup's measured size (px) so the provider can expose it. */
     reportPopupHeight: (height: number) => void;
 }
-declare const injectRdxDrawerRootContext: (optional?: boolean) => RdxDrawerRootContext | null;
+declare const injectRdxDrawerRootContext: _radix_ng_primitives_core.InjectContext<RdxDrawerRootContext>;
 declare const provideRdxDrawerRootContext: (useFactory: () => RdxDrawerRootContext) => i0.Provider;
 /**
  * Groups all parts of the drawer.
@@ -413,30 +415,6 @@ declare const RdxDrawerHandle: typeof RdxDialogHandle;
 type RdxDrawerHandle<Payload = unknown> = RdxDialogHandle<Payload>;
 declare function createRdxDrawerHandle<Payload = unknown>(): RdxDrawerHandle<Payload>;
 
-interface RdxPointerDragHandlers {
-    /** Whether a press may begin a drag (e.g. enabled, not on an opt-out element, at a scroll edge). */
-    canStart: (event: PointerEvent) => boolean;
-    /** A drag actually began (the pointer moved past the start threshold). */
-    onStart: (event: PointerEvent) => void;
-    /** Pointer moved during a drag. Return `false` to end the gesture early (treated as not committed). */
-    onMove: (event: PointerEvent) => void | boolean;
-    /** The drag ended. `committed` is true only for a normal `pointerup`, false for cancel/lost-capture/early-stop. */
-    onEnd: (event: PointerEvent, committed: boolean) => void;
-}
-/**
- * Shared pointer-drag lifecycle for the drawer gestures (popup swipe and swipe-area open).
- *
- * A press only becomes a drag once the pointer moves past {@link DRAG_THRESHOLD}; until then it is a
- * plain tap, so clicks on buttons inside the drawer keep working (the gesture never captures the
- * pointer for a tap). Once dragging, the pointer is captured so a drag that leaves the element still
- * completes, and `lostpointercapture` / `pointercancel` count as a non-committed end — a swallowed
- * `pointerup` (native context menu, OS gesture, tab switch) can never wedge the gesture. No-op
- * outside the browser, keeping SSR safe.
- *
- * Must be called from an injection context (a directive/component constructor).
- */
-declare function usePointerDrag(handlers: RdxPointerDragHandlers): void;
-
 declare const drawerImports: (typeof RdxDrawerProviderDirective)[];
 declare class RdxDrawerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerModule, never>;
@@ -444,5 +422,5 @@ declare class RdxDrawerModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxDrawerModule>;
 }
 
-export { RdxDrawerBackdrop, RdxDrawerClose, RdxDrawerContent, RdxDrawerDescription, RdxDrawerHandle, RdxDrawerIndent, RdxDrawerIndentBackground, RdxDrawerModule, RdxDrawerPopup, RdxDrawerPortal, RdxDrawerPortalPresence, RdxDrawerProvider, RdxDrawerProviderDirective, RdxDrawerRoot, RdxDrawerSwipeArea, RdxDrawerTitle, RdxDrawerTrigger, RdxDrawerViewport, buildSnapEntries, createRdxDrawerHandle, dismissUnitVector, drawerImports, injectRdxDrawerRootContext, provideRdxDrawerProvider, provideRdxDrawerRootContext, resolveSnapTarget, snapPointReveal, useDrawerSwipe, usePointerDrag };
-export type { RdxDrawerRegistration, RdxDrawerRelease, RdxDrawerRootContext, RdxDrawerSnapEntry, RdxDrawerSnapPoint, RdxDrawerSnapResolveOptions, RdxDrawerSnapTarget, RdxDrawerSwipeConfig, RdxDrawerSwipeDirection, RdxPointerDragHandlers };
+export { RdxDrawerBackdrop, RdxDrawerClose, RdxDrawerContent, RdxDrawerDescription, RdxDrawerHandle, RdxDrawerIndent, RdxDrawerIndentBackground, RdxDrawerModule, RdxDrawerPopup, RdxDrawerPortal, RdxDrawerPortalPresence, RdxDrawerProvider, RdxDrawerProviderDirective, RdxDrawerRoot, RdxDrawerSwipeArea, RdxDrawerTitle, RdxDrawerTrigger, RdxDrawerViewport, buildSnapEntries, createRdxDrawerHandle, dismissUnitVector, drawerImports, injectRdxDrawerRootContext, provideRdxDrawerProvider, provideRdxDrawerRootContext, resolveSnapTarget, snapPointReveal, useDrawerSwipe };
+export type { RdxDrawerRegistration, RdxDrawerRelease, RdxDrawerRootContext, RdxDrawerSnapEntry, RdxDrawerSnapPoint, RdxDrawerSnapResolveOptions, RdxDrawerSnapTarget, RdxDrawerSwipeConfig, RdxDrawerSwipeDirection };

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

@@ -1,70 +1,147 @@
 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 } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dismissable-layer';
-import { RdxPointerDownOutside } from '@radix-ng/primitives/dismissable-layer';
+import * as _radix_ng_primitives_editable from '@radix-ng/primitives/editable';
 
+type EditableActivationMode = 'focus' | 'dblclick' | 'none';
+type EditableSubmitMode = 'blur' | 'enter' | 'none' | 'both';
 type EditableRootContext = {
     disabled: Signal<boolean>;
-    value: Signal<string | null | undefined>;
+    value: Signal<string | undefined>;
     inputValue: WritableSignal<string | undefined>;
     placeholder: Signal<{
         edit: string;
         preview: string;
     }>;
     isEditing: Signal<boolean>;
-    submitMode: Signal<SubmitMode>;
-    activationMode: Signal<ActivationMode>;
+    submitMode: Signal<EditableSubmitMode>;
+    activationMode: Signal<EditableActivationMode>;
     edit: () => void;
     cancel: () => void;
     submit: () => void;
     maxLength: Signal<number | undefined>;
+    required: Signal<boolean>;
     startWithEditMode: Signal<boolean>;
     isEmpty: Signal<boolean>;
     readonly: Signal<boolean>;
     selectOnFocus: Signal<boolean>;
     autoResize: Signal<boolean>;
     inputRef: WritableSignal<HTMLInputElement | undefined>;
+    previewRef: WritableSignal<HTMLElement | undefined>;
+    canActivateOnFocus: () => boolean;
 };
-declare const injectEditableRootContext: (optional?: boolean) => EditableRootContext | null;
+declare const injectEditableRootContext: _radix_ng_primitives_core.InjectContext<EditableRootContext>;
 declare const provideEditableRootContext: (useFactory: () => EditableRootContext) => _angular_core.Provider;
-type ActivationMode = 'focus' | 'dblclick' | 'none';
-type SubmitMode = 'blur' | 'enter' | 'none' | 'both';
 /**
  * @group Components
  */
 declare class RdxEditableRoot {
     private readonly focusOutside;
-    readonly pointerDownOutside: RdxPointerDownOutside;
+    private readonly pointerDownOutside;
     readonly value: _angular_core.ModelSignal<string | undefined>;
+    /** Uncontrolled initial value. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
     readonly placeholder: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly selectOnFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly submitMode: _angular_core.InputSignal<SubmitMode>;
+    readonly submitMode: _angular_core.InputSignal<EditableSubmitMode>;
     readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     /**
      * Whether to start with the edit mode active
      */
     readonly startWithEditMode: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly activationMode: _angular_core.InputSignal<ActivationMode>;
+    readonly activationMode: _angular_core.InputSignal<EditableActivationMode>;
     readonly autoResize: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emitted when the value is committed (on submit). */
+    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
     readonly isEmpty: Signal<boolean>;
-    readonly $placeholder: Signal<string | {
+    readonly $placeholder: Signal<{
         edit: string;
         preview: string;
     }>;
+    /** Seeded from `startWithEditMode`; flipped imperatively by edit/submit/cancel. */
     readonly isEditing: WritableSignal<boolean>;
+    /** Working copy of the value while editing; reseeded whenever the committed value changes. */
     readonly inputValue: WritableSignal<string | undefined>;
     readonly inputRef: WritableSignal<HTMLInputElement | undefined>;
+    readonly previewRef: WritableSignal<HTMLElement | undefined>;
+    private restoreFocusOnExit;
+    /** True while focus is being restored programmatically, to avoid re-entering edit mode. */
+    private suppressFocusActivation;
     constructor();
+    canActivateOnFocus(): boolean;
     handleDismiss(): void;
     submit(): void;
     cancel(): void;
     edit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableRoot, "[rdxEditableRoot]", ["rdxEditableRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "startWithEditMode": { "alias": "startWithEditMode"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof i1.RdxPointerDownOutside; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableRoot, "[rdxEditableRoot]", ["rdxEditableRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "startWithEditMode": { "alias": "startWithEditMode"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof i1.RdxPointerDownOutside; inputs: {}; outputs: {}; }]>;
 }
 
-export { RdxEditableRoot, injectEditableRootContext, provideEditableRootContext };
+declare class RdxEditableArea {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableArea, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableArea, "[rdxEditableArea]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxEditablePreview {
+    private readonly elementRef;
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    readonly placeholder: _angular_core.Signal<string>;
+    constructor();
+    handleFocus(): void;
+    handleDoubleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditablePreview, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditablePreview, "span[rdxEditablePreview]", ["rdxEditablePreview"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxEditableInput {
+    private readonly inputRef;
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the input. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    handleInput(event: Event): void;
+    handleSubmitKeyDown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableInput, "input[rdxEditableInput]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableEditTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableEditTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableEditTrigger, "button[rdxEditableEditTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableSubmitTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableSubmitTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableSubmitTrigger, "button[rdxEditableSubmitTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableCancelTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableCancelTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableCancelTrigger, "button[rdxEditableCancelTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxEditableModule, never, [typeof RdxEditableRoot, typeof RdxEditableArea, typeof RdxEditablePreview, typeof RdxEditableInput, typeof RdxEditableEditTrigger, typeof RdxEditableSubmitTrigger, typeof RdxEditableCancelTrigger], [typeof RdxEditableRoot, typeof RdxEditableArea, typeof RdxEditablePreview, typeof RdxEditableInput, typeof RdxEditableEditTrigger, typeof RdxEditableSubmitTrigger, typeof RdxEditableCancelTrigger]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxEditableModule>;
+}
+
+export { RdxEditableArea, RdxEditableCancelTrigger, RdxEditableEditTrigger, RdxEditableInput, RdxEditableModule, RdxEditablePreview, RdxEditableRoot, RdxEditableSubmitTrigger, injectEditableRootContext, provideEditableRootContext };
+export type { EditableActivationMode, EditableRootContext, EditableSubmitMode };

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

@@ -1,5 +1,6 @@
 import * as _radix_ng_primitives_field from '@radix-ng/primitives/field';
 import * as _angular_core from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
 
 /**
@@ -225,7 +226,7 @@ declare const fieldRootContext: () => {
     hasStateProvider: _angular_core.Signal<boolean>;
 };
 type RdxFieldRootContext = ReturnType<typeof fieldRootContext>;
-declare const injectFieldRootContext: (optional?: boolean) => {
+declare const injectFieldRootContext: _radix_ng_primitives_core.InjectContext<{
     controlId: _angular_core.WritableSignal<string>;
     descriptionIds: _angular_core.WritableSignal<string[]>;
     errorIds: _angular_core.WritableSignal<string[]>;
@@ -253,7 +254,7 @@ declare const injectFieldRootContext: (optional?: boolean) => {
      */
     setStateProvider: (provider: RdxFieldState | null) => RdxFieldState | null;
     hasStateProvider: _angular_core.Signal<boolean>;
-} | null;
+}>;
 declare const provideFieldRootContext: (useFactory: () => {
     controlId: _angular_core.WritableSignal<string>;
     descriptionIds: _angular_core.WritableSignal<string[]>;