@radix-ng/primitives 1.0.9 → 1.1.0

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

@@ -1,8 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { ElementRef, Provider, Type, InjectionToken } from '@angular/core';
+import { ElementRef, Signal, Provider, Type, InjectionToken } from '@angular/core';
 import { ReferenceElement, Placement, Middleware, VirtualElement } from '@floating-ui/dom';
+import * as _radix_ng_primitives_popper from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
+import { Direction, NumberInput, BooleanInput } from '@radix-ng/primitives/core';
 
 declare class RdxPopperAnchor {
     readonly elementRef: ElementRef<HTMLElement>;
@@ -25,7 +26,8 @@ declare class RdxPopperContent {
      * simply no-op.
      */
     protected readonly popperContentWrapper: {
-        placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+        placedSide: _angular_core.Signal<_radix_ng_primitives_popper.SideOrLogical | undefined>;
+        physicalPlacedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
         placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
         arrowX: _angular_core.Signal<number | undefined>;
         arrowY: _angular_core.Signal<number | undefined>;
@@ -48,6 +50,63 @@ declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
 declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
 type Side = (typeof SIDE_OPTIONS)[number];
 type Align = (typeof ALIGN_OPTIONS)[number];
+/** Logical (writing-direction-relative) inline sides, resolved to a physical {@link Side} by text direction. */
+type LogicalSide = 'inline-start' | 'inline-end';
+/** A physical {@link Side} or a {@link LogicalSide} — accepted by the positioner's `side` input. */
+type SideOrLogical = Side | LogicalSide;
+/**
+ * Resolve a logical inline side to a physical one for the current text direction; physical sides pass
+ * through unchanged (Base UI `useAnchorPositioning`). `inline-start` is the reading-start edge
+ * (`left` in LTR, `right` in RTL); `inline-end` is the reading-end edge.
+ */
+declare function resolvePhysicalSide(side: SideOrLogical, isRtl: boolean): Side;
+/**
+ * Report a rendered physical side back in the same "kind" the consumer requested (Base UI
+ * `getLogicalSide`): when a logical side was requested, a `left`/`right` rendered side is mapped back
+ * to `inline-start`/`inline-end` for the direction (so a post-collision flip surfaces logically); a
+ * physical request, or a `top`/`bottom` rendered side, passes through unchanged.
+ */
+declare function toLogicalSide(requestedSide: SideOrLogical, renderedSide: Side, isRtl: boolean): SideOrLogical;
+/**
+ * How the popper avoids collisions with the boundary edges (Base UI `collisionAvoidance`).
+ *
+ * - `side` — behavior on the **preferred placement axis** (`top`/`bottom` or `left`/`right`):
+ *   `'flip'` swaps to the opposite side when it doesn't fit, `'shift'` keeps the side and nudges the
+ *   popup within the boundary, `'none'` leaves side-axis overflow uncorrected.
+ * - `align` — behavior on the **alignment axis** (`start`/`center`/`end`): `'flip'` swaps `start`/`end`,
+ *   `'shift'` nudges the popup along the alignment axis, `'none'` leaves it uncorrected.
+ * - `fallbackAxisSide` — when neither preferred side fits, whether to fall back to the perpendicular
+ *   axis and which logical side to prefer (`'start'` / `'end'`), or `'none'` to stay on the axis.
+ *
+ * Any omitted field falls back to the wrapper default (`side: 'flip'`, `align: 'flip'`,
+ * `fallbackAxisSide: 'end'`), matching Base UI.
+ */
+interface RdxCollisionAvoidance {
+    side?: 'flip' | 'shift' | 'none';
+    align?: 'flip' | 'shift' | 'none';
+    fallbackAxisSide?: 'start' | 'end' | 'none';
+}
+/** Fully-resolved {@link RdxCollisionAvoidance} — every field present (no wrapper-default fallback left). */
+type ResolvedCollisionAvoidance = Required<RdxCollisionAvoidance>;
+/**
+ * Function form of `sideOffset` / `alignOffset` (Base UI `OffsetFunction`). Receives the resolved
+ * placement and the measured anchor / positioner dimensions, and returns the offset in pixels — e.g.
+ * `({ anchor }) => anchor.width` to offset by the trigger's own width. `side` is the side the popup is
+ * placed against — reported logically (`inline-start` / `inline-end`) when a logical side was
+ * requested, otherwise physical (Base UI parity).
+ */
+type OffsetFunction = (data: {
+    side: SideOrLogical;
+    align: Align;
+    anchor: {
+        width: number;
+        height: number;
+    };
+    positioner: {
+        width: number;
+        height: number;
+    };
+}) => number;
 declare function isNotNull<T>(value: T | null): value is T;
 declare function transformOrigin(options: {
     arrowWidth: number;
@@ -57,32 +116,35 @@ declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["
 
 type RdxPopperAnchorElement = Element | ElementRef<Element> | VirtualElement | (() => Element | VirtualElement | null) | null | undefined;
 declare const context: () => {
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 };
 type PopperContentWrapperContext = ReturnType<typeof context>;
 declare const injectPopperContentWrapperContext: _radix_ng_primitives_core.InjectContext<{
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 }>;
 declare const providePopperContentWrapperContext: (useFactory: () => {
-    placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
-    placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    arrowX: _angular_core.Signal<number | undefined>;
-    arrowY: _angular_core.Signal<number | undefined>;
-    shouldHideArrow: _angular_core.Signal<boolean>;
-    isPositioned: _angular_core.Signal<boolean>;
-    anchorHidden: _angular_core.Signal<boolean>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    arrowX: Signal<number | undefined>;
+    arrowY: Signal<number | undefined>;
+    shouldHideArrow: Signal<boolean>;
+    isPositioned: Signal<boolean>;
+    anchorHidden: Signal<boolean>;
 }) => Provider;
 declare class RdxPopperContentWrapper {
     private readonly elementRef;
@@ -97,25 +159,60 @@ declare class RdxPopperContentWrapper {
     /**
      * The preferred side of the anchor to render against when open.
      * Will be reversed when collisions occur and avoidCollisions is enabled.
+     *
+     * Accepts the logical `'inline-start'` / `'inline-end'` in addition to the physical sides; those
+     * resolve to `left` / `right` for the text direction (Base UI parity). The placed side reported via
+     * `data-side` / `placedSide()` echoes the requested kind: logical in → logical out (even after a
+     * collision flip), physical in → physical out.
+     */
+    readonly side: _angular_core.InputSignal<SideOrLogical>;
+    /**
+     * Text direction, used only to resolve a logical `side` (`inline-start` / `inline-end`) to a
+     * physical one. Falls back to an enclosing direction provider, then `ltr`.
      */
-    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    private readonly direction;
+    /** The `side` input with any logical inline value resolved to a physical side for the direction. */
+    private readonly resolvedSide;
     /**
-     * Distance between the anchor and the popup in pixels.
+     * Distance between the anchor and the popup in pixels. Also accepts an {@link OffsetFunction} that
+     * reads the anchor / positioner dimensions and the resolved side / align.
      */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | OffsetFunction, string | number | OffsetFunction | null | undefined>;
     /**
      * How to align the popup relative to the specified side. May change when collisions occur.
      */
     readonly align: _angular_core.InputSignal<"start" | "center" | "end">;
-    /** An offset in pixels from the `start` or `end` alignment options. */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options. Also accepts an
+     * {@link OffsetFunction} (same signature as `sideOffset`).
+     */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | OffsetFunction, string | number | OffsetFunction | null | undefined>;
     /**
      * Minimum distance to maintain between the arrow and the edges of the popup.
      * If your content has border-radius, this will prevent it from overflowing the corners.
      */
     readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /** When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges. */
+    /**
+     * When `true`, overrides the `side` and `align` preferences to prevent collisions with boundary edges.
+     *
+     * @deprecated Use {@link collisionAvoidance} for fine-grained control (Base UI parity). Still honored:
+     * `false` disables all avoidance (unless a `collisionAvoidance` object is provided, which wins).
+     */
     readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * How the popup avoids colliding with the boundary edges, per axis (Base UI `collisionAvoidance`).
+     * Overrides the deprecated `avoidCollisions` and any per-primitive preset. An object here **fully
+     * replaces** the preset — omitted fields fall back to `side: 'flip'`, `align: 'flip'`,
+     * `fallbackAxisSide: 'end'`, never to the preset. See {@link RdxCollisionAvoidance}.
+     */
+    readonly collisionAvoidance: _angular_core.InputSignal<RdxCollisionAvoidance | undefined>;
+    /**
+     * Collision avoidance resolved against the deprecated `avoidCollisions` flag, the per-primitive
+     * config preset, and the wrapper defaults. Precedence: an explicit `collisionAvoidance` input →
+     * a legacy `avoidCollisions=false` (disables everything) → the config preset → the Base UI defaults.
+     */
+    private readonly effectiveCollisionAvoidance;
     /**
      * The element used as the collision boundary.
      * By default this is the viewport, though you can provide additional element(s) to be included in this check.
@@ -149,19 +246,19 @@ declare class RdxPopperContentWrapper {
      * Emits when the element is placed.
      */
     readonly placed: _angular_core.OutputEmitterRef<void>;
-    readonly arrow: _angular_core.Signal<any>;
+    readonly arrow: Signal<any>;
     /**
      * When `true`, the content is rendered click/hover-through (`pointer-events: none`). Used for
      * cursor-following content (e.g. a tooltip tracking the pointer) that must never intercept the
      * pointer and steal hover from its trigger.
      */
     readonly nonInteractive: _angular_core.WritableSignal<boolean>;
-    readonly shouldHideArrow: _angular_core.Signal<boolean>;
+    readonly shouldHideArrow: Signal<boolean>;
     /** Whether the arrow could not be centered on the anchor because the popup was shifted. */
-    readonly arrowUncentered: _angular_core.Signal<boolean>;
-    readonly arrowX: _angular_core.Signal<number | undefined>;
-    readonly arrowY: _angular_core.Signal<number | undefined>;
-    readonly anchorHidden: _angular_core.Signal<boolean>;
+    readonly arrowUncentered: Signal<boolean>;
+    readonly arrowX: Signal<number | undefined>;
+    readonly arrowY: Signal<number | undefined>;
+    readonly anchorHidden: Signal<boolean>;
     private readonly desiredPlacement;
     private readonly arrowSize;
     private readonly boundary;
@@ -183,23 +280,32 @@ declare class RdxPopperContentWrapper {
     /**
      * Whether the panel is positioned.
      */
-    readonly isPositioned: _angular_core.Signal<boolean>;
+    readonly isPositioned: Signal<boolean>;
     /**
      * The current placement of the panel.
      */
-    readonly placement: _angular_core.Signal<{
+    readonly placement: Signal<{
         side: Side;
         align: Align;
     } | undefined>;
     /**
-     * The side the panel is currently placed against.
+     * The physical side the panel is currently placed against. Internal geometry (arrow position,
+     * transform origins) must use this — never {@link placedSide}, which can be logical.
      */
-    readonly placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    readonly physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    /**
+     * The side the panel is currently placed against, reported in the kind the consumer requested
+     * (Base UI positioner `side`): when a logical `side` was passed, a placed `left`/`right` maps back
+     * to `inline-start`/`inline-end` for the direction — so a post-collision flip stays logical and
+     * `[data-side="inline-start"]` CSS is direction-agnostic. A physical request is always reported
+     * physically.
+     */
+    readonly placedSide: Signal<SideOrLogical | undefined>;
     /**
      * The current alignment of the panel.
      */
-    readonly placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    protected readonly style: _angular_core.Signal<{
+    readonly placedAlign: Signal<"start" | "center" | "end" | undefined>;
+    protected readonly style: Signal<{
         visibility: string;
         pointerEvents: string;
         position: "fixed" | "absolute";
@@ -218,10 +324,20 @@ declare class RdxPopperContentWrapper {
         '--positioner-height': string;
         '--transform-origin': string;
     }>;
+    /**
+     * Whether the positioner should actively track its anchor (recompute + `autoUpdate`). Defaults to
+     * always-on — the historical behavior, correct for a positioner that unmounts when its layer closes.
+     * A positioner that can stay mounted while closed (`keepMounted`) **overrides** this with its
+     * open/presence signal so a closed, hidden positioner doesn't spin an endless `autoUpdate`
+     * `requestAnimationFrame` loop (only relevant when `updatePositionStrategy: 'always'`). It's a
+     * reassignable field (not `readonly`) because the render effect below reads it lazily, after the
+     * subclass constructor has swapped it in.
+     */
+    protected positioningActive: Signal<boolean>;
     private readonly afterRenderEffect;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionAvoidance": { "alias": "collisionAvoidance"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
 }
 /**
  * Providers a "thin" positioner that `extends RdxPopperContentWrapper` must include. Angular
@@ -280,22 +396,44 @@ declare class RdxPopperArrow {
  * `undefined` falls back to the wrapper's built-in default. Consumer template bindings always win.
  */
 interface RdxPopperContentConfig {
-    side?: Side;
+    side?: SideOrLogical;
     align?: Align;
-    sideOffset?: number;
-    alignOffset?: number;
+    sideOffset?: number | OffsetFunction;
+    alignOffset?: number | OffsetFunction;
     arrowPadding?: number;
+    /**
+     * @deprecated Use {@link collisionAvoidance} instead. Kept for back-compat: `false` disables all
+     * collision avoidance (equivalent to `{ side: 'none', align: 'none', fallbackAxisSide: 'none' }`).
+     */
     avoidCollisions?: boolean;
+    /** Per-primitive collision-avoidance default (Base UI parity). See {@link RdxCollisionAvoidance}. */
+    collisionAvoidance?: RdxCollisionAvoidance;
     collisionPadding?: number | Partial<Record<Side, number>>;
     sticky?: 'partial' | 'always';
     hideWhenDetached?: boolean;
     positionStrategy?: 'fixed' | 'absolute';
     updatePositionStrategy?: 'optimized' | 'always';
 }
+/**
+ * Collision-avoidance preset for dropdown-style popups (Base UI `DROPDOWN_COLLISION_AVOIDANCE`).
+ *
+ * Dropdowns (select / combobox / autocomplete / menu) strictly prefer their top/bottom placement and
+ * cap their height with `var(--available-height)`, so they must **not** fall back to the perpendicular
+ * (left/right) axis. `side`/`align` fall back to the wrapper default (`'flip'`).
+ */
+declare const DROPDOWN_COLLISION_AVOIDANCE: RdxCollisionAvoidance;
+/**
+ * Collision-avoidance preset for regular popups (Base UI `POPUP_COLLISION_AVOIDANCE`).
+ *
+ * Popovers / tooltips / preview cards aren't height-capped and may freely flip to the perpendicular
+ * axis, preferring the logical end side. This equals the wrapper's built-in default; it is exported so
+ * popups can state the intent explicitly.
+ */
+declare const POPUP_COLLISION_AVOIDANCE: RdxCollisionAvoidance;
 declare const RdxPopperContentConfigToken: InjectionToken<RdxPopperContentConfig>;
 declare function provideRdxPopperContentConfig(config: RdxPopperContentConfig): Provider;
 
 declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContentWrapper | typeof RdxPopperContent)[];
 
-export { RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, transformOrigin };
-export type { Align, PopperContentWrapperContext, RdxPopperAnchorElement, RdxPopperContentConfig, Side };
+export { DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE, RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, resolvePhysicalSide, toLogicalSide, transformOrigin };
+export type { Align, LogicalSide, OffsetFunction, PopperContentWrapperContext, RdxCollisionAvoidance, RdxPopperAnchorElement, RdxPopperContentConfig, ResolvedCollisionAvoidance, Side, SideOrLogical };

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

@@ -1,4 +1,4 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { ElementRef } from '@angular/core';
 
 /**
@@ -22,14 +22,14 @@ declare class RdxPortal {
      * Specify a container to portal the content into. Can be an `ElementRef`, a native element, or a
      * CSS selector. Defaults to `document.body` when not set (or when a selector matches nothing).
      */
-    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
     private readonly _computedContainer;
-    readonly computedContainer: i0.Signal<RdxPortalContainer | undefined>;
+    readonly computedContainer: _angular_core.Signal<RdxPortalContainer | undefined>;
     private readonly elementContainer;
     constructor();
     setContainer(container: RdxPortalContainer): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortal, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortal, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortal, "[rdxPortal]", ["rdxPortal"], { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -56,7 +56,17 @@ declare class RdxPortalPresence {
      * Container to portal the content into. Can be an `ElementRef`, a native element, or a CSS
      * selector. Defaults to `document.body` (or when a selector matches nothing).
      */
-    readonly container: i0.InputSignal<RdxPortalContainer | undefined>;
+    readonly container: _angular_core.InputSignal<RdxPortalContainer | undefined>;
+    /**
+     * Keep the portal mounted (in the container) while the layer is closed. When `true` the content
+     * stays in the DOM regardless of the {@link RDX_PRESENCE_CONTEXT} `present` flag — the consumer is
+     * responsible for hiding it while closed (typically via the `data-closed` / `data-open` state on the
+     * positioner). Any `*rdxXxxPortal` wrapper opts in by mapping this input in its `hostDirectives`.
+     */
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The layer's own open/present flag, OR'd with {@link keepMounted} to gate mount/unmount. */
+    private readonly contextPresent;
+    private readonly present;
     private readonly _computedContainer;
     private readonly elementContainer;
     /** The live view's root nodes, exposed as a signal so the relocation effect re-runs on (re)mount. */
@@ -67,8 +77,8 @@ declare class RdxPortalPresence {
     setContainer(container: RdxPortalContainer): void;
     private mountView;
     private destroyView;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPortalPresence, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPortalPresence, never, never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPortalPresence, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPortalPresence, never, never, { "container": { "alias": "container"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { RdxPortal, RdxPortalPresence, resolvePortalContainer };

package/types/radix-ng-primitives-preview-card.d.ts

@@ -268,7 +268,7 @@ declare class RdxPreviewCardPopup {
     private readonly registration;
     private readonly wrapper;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     /**
      * Event handler called when the escape key is down. Can be prevented.
      */
@@ -296,7 +296,7 @@ declare class RdxPreviewCardPopup {
 declare class RdxPreviewCardArrow {
     protected readonly rootContext: _radix_ng_primitives_preview_card.RdxPreviewCardRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPreviewCardArrow, never>;

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

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal, ElementRef, InjectionToken, OutputRef, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { AcceptableValue, RdxCancelableChangeEventDetails, RdxFormUiControlBase, RdxFormValueControl, RdxFloatingRootContext, Direction, ItemValueComparator, RdxTransitionStatus, RdxFormUiStateContext } from '@radix-ng/primitives/core';
+import { AcceptableValue, RdxCancelableChangeEventDetails, RdxFormUiControlBase, RdxFormValueControl, RdxFloatingRootContext, Direction, ItemValueComparator, RdxTransitionStatus, RdxFormUiTouchTarget, RdxFormUiStateContext } from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_select from '@radix-ng/primitives/select';
 import * as i1 from '@radix-ng/primitives/composite';
 import { RdxCompositeItemRegistration } from '@radix-ng/primitives/composite';
@@ -11,6 +11,7 @@ import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as i2 from '@radix-ng/primitives/floating-focus-manager';
 import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as _radix_ng_primitives_types_radix_ng_primitives_core from '@radix-ng/primitives/types/radix-ng-primitives-core';
+import { ControlValueAccessor } from '@angular/forms';
 import * as i1$2 from '@radix-ng/primitives/portal';
 
 declare class RdxSelectGroupLabel {
@@ -365,7 +366,7 @@ interface RdxSelectRootContext extends RdxFormUiStateContext {
 }
 declare const injectSelectRootContext: _radix_ng_primitives_core.InjectContext<RdxSelectRootContext>;
 declare const provideSelectRootContext: (useFactory: () => RdxSelectRootContext) => _angular_core.Provider;
-declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValueControl<AcceptableValue | AcceptableValue[] | undefined> {
+declare class RdxSelectRoot extends RdxFormUiControlBase implements ControlValueAccessor, RdxFormValueControl<AcceptableValue | AcceptableValue[] | undefined> {
     readonly contentId: string;
     readonly open: _angular_core.ModelSignal<boolean>;
     /** Whether the current open was initiated by **touch** (ADR 0016 §3 — gates the anchored scroll lock). */
@@ -385,6 +386,8 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    readonly disabledState: Signal<boolean>;
     /** When `true`, the value cannot be changed by the user (the popup can still be opened to view it). */
     readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marks the control as required — reflected on the trigger as `aria-required` / `data-required`. */
@@ -423,6 +426,18 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     getOption(value: SelectOption['value']): SelectOption | undefined;
     setValue(value: AcceptableValue | undefined, reason?: RdxSelectValueChangeReason, event?: Event): boolean;
     setOpen(open: boolean, reason?: RdxSelectOpenChangeReason, event?: Event): boolean;
+    /** @ignore Bridge the CVA touched callback into the shared Signal Forms UI-state path. */
+    protected formUiTouchTarget(): RdxFormUiTouchTarget;
+    /** @ignore Write a form-owned value without emitting a user change. */
+    writeValue(value: AcceptableValue | AcceptableValue[] | undefined): void;
+    /** @ignore Register the Reactive Forms / ngModel value callback. */
+    registerOnChange(fn: (value: AcceptableValue | AcceptableValue[] | undefined) => void): void;
+    /** @ignore Register the Reactive Forms / ngModel touched callback. */
+    registerOnTouched(fn: () => void): void;
+    /** @ignore Merge form-owned disabled state with the public disabled input. */
+    setDisabledState(isDisabled: boolean): void;
+    private onChange?;
+    private onTouched?;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectRoot, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectRoot, "[rdxSelectRoot]", ["rdxSelectRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToStringLabel": { "alias": "itemToStringLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; "onOpenChange": "onOpenChange"; "onValueChange": "onValueChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
@@ -474,7 +489,6 @@ declare class RdxSelectTrigger {
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly triggerInteraction: i2.RdxTriggerInteraction;
-    protected readonly invalidState: _angular_core.Signal<boolean>;
     /**
      * Tri-state *displayed* validity: when inside a `rdxFieldRoot` the field's gated `validState` is the
      * single source (so the field's `validationMode` keeps the trigger neutral until revealed), otherwise

package/types/radix-ng-primitives-signal-forms.d.ts

@@ -1,5 +1,6 @@
 import * as i0 from '@angular/core';
 import { FieldTree } from '@angular/forms/signals';
+import { BooleanInput } from '@radix-ng/primitives/core';
 
 /**
  * Bridges an Angular **Signal Forms** field into an enclosing `rdxFieldRoot` — with **no duplicate
@@ -16,9 +17,9 @@ import { FieldTree } from '@angular/forms/signals';
  *
  * It owns no model and runs no validation — Signal Forms remains the source of truth. It only registers
  * an {@link RdxFieldState} provider on the ancestor Field context so the field's `invalid` / `disabled` /
- * `required` / `dirty` / `touched` data-attributes and the error *content* (`rdxFieldError.messages()`)
- * read authoritative Signal Forms state. `filled` / `focused` stay on Field's DOM heuristic (partial
- * ownership — the seam supports it).
+ * `required` / `dirty` / `touched` data-attributes, tri-state pending validity, and the error *content*
+ * (`rdxFieldError.messages()`) read authoritative Signal Forms state. `filled` / `focused` stay on
+ * Field's DOM heuristic (partial ownership — the seam supports it).
  *
  * It reports the **actual** Signal Forms state only; the `Field` decides *when* to display it from its
  * `validationMode` (default `'onBlur'` — neutral until the field is touched or the form submitted). So an
@@ -51,9 +52,13 @@ declare class RdxSignalField {
  *
  * Registers an {@link RdxFormState} provider so the Form's aggregate `data-invalid` / `data-dirty` /
  * `data-touched` / `data-submitting` attributes and the submit guard read authoritative Signal Forms
- * state. This adapter owns only client-side state and `name`-routing; server errors stay a separate
- * eager channel applied through `rdxFormRoot[errors]`, and Signal Forms' own `submit()` owns the
- * submit lifecycle.
+ * state. By default this adapter owns only client-side state and `name`-routing; server errors stay a
+ * separate eager channel applied through `rdxFormRoot[errors]`. Add `rdxSignalSubmit` to delegate native
+ * submission to Signal Forms' own `submit()` lifecycle instead of `rdxFormRoot.onFormSubmit`:
+ *
+ * ```html
+ * <form rdxFormRoot [rdxSignalForm]="loginForm" rdxSignalSubmit>…</form>
+ * ```
  *
  * `errorsFor(name)` routes a field's errors to a `rdxFieldRoot` by its `name`, walking the `FieldTree`
  * so dotted paths into nested object/array fields resolve too (`address.street`, `items.0.name`). A
@@ -62,13 +67,22 @@ declare class RdxSignalField {
  * a field carries both, `rdxFieldError.messages()` deduplicates by text so the shared message is not
  * shown twice.
  *
- * See ADR 0018.
+ * See ADR 0018 and ADR 0020.
  *
  * @group Components
  */
 declare class RdxSignalForm {
     /** The Signal Forms root field (from `form(...)`) whose aggregate state drives the enclosing Form. */
     readonly form: i0.InputSignal<FieldTree<unknown>>;
+    /**
+     * Delegate native submission to Angular Signal Forms' `submit()` lifecycle. Opt-in so adding the
+     * state adapter to an existing 1.x form cannot silently replace its `(onFormSubmit)` side effects.
+     * The bound `form()` must define `submission.action`; Angular reports a descriptive error otherwise.
+     *
+     * @group Props
+     * @defaultValue false
+     */
+    readonly signalSubmit: i0.InputSignalWithTransform<boolean, BooleanInput>;
     private readonly formContext;
     constructor();
     /**
@@ -84,7 +98,7 @@ declare class RdxSignalForm {
     /** The current Signal Forms root field state (a `FieldTree` is callable). */
     private state;
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxSignalForm, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSignalForm, "form[rdxFormRoot][rdxSignalForm]", ["rdxSignalForm"], { "form": { "alias": "rdxSignalForm"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxSignalForm, "form[rdxFormRoot][rdxSignalForm]", ["rdxSignalForm"], { "form": { "alias": "rdxSignalForm"; "required": true; "isSignal": true; }; "signalSubmit": { "alias": "rdxSignalSubmit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare const _importsSignalForms: (typeof RdxSignalField | typeof RdxSignalForm)[];