@radix-ng/primitives 1.0.9 → 1.1.0

package/types/radix-ng-primitives-focus-scope.d.ts

@@ -25,7 +25,10 @@ declare function createAriaOwnsAnchor(ownerDocument: Document, portalId: string)
  * trigger steps onto the guard instead of jumping into the content.
  */
 declare function disableFocusInside(container: HTMLElement): void;
-/** Restores the tabbability that {@link disableFocusInside} suspended. Base UI `enableFocusInside`. */
+/**
+ * Restores the tabbability that {@link disableFocusInside} suspended. Base UI `enableFocusInside`.
+ * Collects markers across the composed tree so guards inside shadow roots / slots are restored too.
+ */
 declare function enableFocusInside(container: HTMLElement): void;
 /**
  * Whether a focus event crossed the `container` boundary — its `relatedTarget` (the other side of the
@@ -134,6 +137,54 @@ type RdxFocusScopeConfig = {
 declare const RdxFocusScopeConfigToken: InjectionToken<RdxFocusScopeConfig>;
 declare function provideRdxFocusScopeConfig(factory: () => RdxFocusScopeConfig): Provider;
 
+/**
+ * Tabbable / focusable detection ported from Base UI (`floating-ui-react/utils/tabbable.ts`). Unlike the
+ * old `TreeWalker` approximation this:
+ * - **pierces shadow DOM and `<slot>`** via composed traversal (`getComposedChildren`), so guards / portal
+ *   tab-order see candidates inside web components and projected content;
+ * - honours **`inert`** ancestors, **`hidden`**, and computed-style visibility (`display`/`visibility`/
+ *   `checkVisibility()` content-visibility);
+ * - treats **`<details>`/`<summary>`**, **`contenteditable`**, and **`audio`/`video[controls]`** as
+ *   focusable with the right implicit tab index;
+ * - applies **radio-group** semantics (only the checked radio of a named group — or the first when none is
+ *   checked — is tabbable).
+ *
+ * `composedContains` is the shadow-aware `Node.contains`, kept here as the low-level primitive so this
+ * module stays a leaf (only `@radix-ng/primitives/core`); `utils.ts` re-exports it for back-compat.
+ */
+type FocusableElement = HTMLElement | SVGElement;
+/**
+ * Shadow-DOM-aware containment: whether `node` is `container` or lives inside it, crossing shadow roots
+ * via their `host` (unlike `Node.contains`, which stops at a shadow boundary). Base UI `contains`.
+ */
+declare function composedContains(container: Node, node: Node | null): boolean;
+/** Collects elements matching `selector` across the composed tree (shadow / slot aware). */
+declare function queryComposedAll(container: ParentNode, selector: string): HTMLElement[];
+/** Whether `element` is reachable by Tab right now (Base UI `isTabbable`). */
+declare function isTabbable(element: Element | null): boolean;
+/** All programmatically focusable elements inside `container`, in composed document order. */
+declare function focusable(container: Element): FocusableElement[];
+/** All keyboard-tabbable elements inside `container`, in composed document order (Base UI `tabbable`). */
+declare function tabbable(container: Element): FocusableElement[];
+/**
+ * Back-compat alias for {@link tabbable} — historically returned a looser `TreeWalker` approximation;
+ * now the full Base UI tabbable set. Kept so existing imports (`getTabbableCandidates`) keep working.
+ */
+declare function getTabbableCandidates(container: Element): FocusableElement[];
+/** The first and last tabbable elements inside `container`. */
+declare function getTabbableEdges(container: Element): readonly [FocusableElement | undefined, FocusableElement | undefined];
+/**
+ * The next tabbable in the document after the current focus (Base UI `getNextTabbable`) — used by the
+ * portal-focus bridge's trailing guard to step focus past the popup. Falls back to `reference`.
+ */
+declare function getNextTabbable(reference: Element | null): FocusableElement | null;
+/** The previous tabbable in the document before the current focus (Base UI `getPreviousTabbable`). */
+declare function getPreviousTabbable(reference: Element | null): FocusableElement | null;
+/** The tabbable immediately after `reference` in the document, wrapping (Base UI `getTabbableAfterElement`). */
+declare function getTabbableAfterElement(reference: Element | null): FocusableElement | null;
+/** The tabbable immediately before `reference` in the document, wrapping (Base UI `getTabbableBeforeElement`). */
+declare function getTabbableBeforeElement(reference: Element | null): FocusableElement | null;
+
 declare const AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
 declare const AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
 declare const EVENT_OPTIONS: {
@@ -148,52 +199,18 @@ type FocusableTarget = HTMLElement | {
  * Falls back to `event.target` when `composedPath` is unavailable.
  */
 declare function getEventTarget(event: Event): EventTarget | null;
-/**
- * Shadow-DOM-aware containment: whether `node` is `container` or lives inside it, crossing shadow roots
- * via their `host` (unlike `Node.contains`, which stops at a shadow boundary).
- */
-declare function composedContains(container: Node, node: Node | null): boolean;
 /**
  * Attempts focusing the first element in a list of candidates.
  * Stops when focus has actually moved.
- */
-declare function focusFirst(candidates: HTMLElement[], { select }?: {
-    select?: boolean | undefined;
-}): true | undefined;
-/**
- * Returns a list of potential tabbable candidates.
- *
- * NOTE: This is only a close approximation. For example it doesn't take into account cases like when
- * elements are not visible. This cannot be worked out easily by just reading a property, but rather
- * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.
  *
- * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
- * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1
- */
-declare function getTabbableCandidates(container: HTMLElement): HTMLElement[];
-declare function isHidden(node: HTMLElement, { upTo }: {
-    upTo?: HTMLElement;
-}): boolean;
-/**
- * Returns the first visible element in a list.
- * NOTE: Only checks visibility up to the `container`.
+ * Reads the active element from `root` (a focus scope passes its host's `ownerDocument`); falling back to
+ * the global `document` would, in an iframe / multi-document scope, never detect that focus moved inside
+ * the inner document and so walk past every candidate, leaving focus on the last one instead of the first.
  */
-declare function findVisible(elements: HTMLElement[], container: HTMLElement): HTMLElement | undefined;
-/**
- * Returns the first and last tabbable elements inside a container.
- */
-declare function getTabbableEdges(container: HTMLElement): readonly [HTMLElement | undefined, HTMLElement | undefined];
-/**
- * The next tabbable in the document after the current focus (Base UI `getNextTabbable`) — used by the
- * portal-focus bridge's trailing guard to step focus past the popup. Falls back to `reference`.
- */
-declare function getNextTabbable(reference: Element | null): HTMLElement | null;
-/** The previous tabbable in the document before the current focus (Base UI `getPreviousTabbable`). */
-declare function getPreviousTabbable(reference: Element | null): HTMLElement | null;
-/** The tabbable immediately after `reference` in the document, wrapping (Base UI `getTabbableAfterElement`). */
-declare function getTabbableAfterElement(reference: Element | null): HTMLElement | null;
-/** The tabbable immediately before `reference` in the document, wrapping (Base UI `getTabbableBeforeElement`). */
-declare function getTabbableBeforeElement(reference: Element | null): HTMLElement | null;
+declare function focusFirst(candidates: FocusableElement[], { select, root }?: {
+    select?: boolean;
+    root?: DocumentOrShadowRoot;
+}): true | undefined;
 declare function isSelectableInput(element: any): element is FocusableTarget & {
     select: () => void;
 };
@@ -201,5 +218,5 @@ declare function focus(element?: FocusableTarget | null, { select }?: {
     select?: boolean | undefined;
 }): void;
 
-export { AUTOFOCUS_ON_MOUNT, AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS, FOCUS_GUARD_ATTR, FOCUS_GUARD_STYLE, RdxFocusScope, RdxFocusScopeConfigToken, composedContains, createAriaOwnsAnchor, createFocusGuard, disableFocusInside, enableFocusInside, findVisible, focus, focusFirst, getEventTarget, getNextTabbable, getPreviousTabbable, getTabbableAfterElement, getTabbableBeforeElement, getTabbableCandidates, getTabbableEdges, injectFocusScopeContext, isHidden, isOutsideEvent, isSelectableInput, provideFocusScopeContext, provideRdxFocusScopeConfig, useFocusGuardsTabbability };
-export type { FocusScopeContext, RdxFocusScopeConfig };
+export { AUTOFOCUS_ON_MOUNT, AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS, FOCUS_GUARD_ATTR, FOCUS_GUARD_STYLE, RdxFocusScope, RdxFocusScopeConfigToken, composedContains, createAriaOwnsAnchor, createFocusGuard, disableFocusInside, enableFocusInside, focus, focusFirst, focusable, getEventTarget, getNextTabbable, getPreviousTabbable, getTabbableAfterElement, getTabbableBeforeElement, getTabbableCandidates, getTabbableEdges, injectFocusScopeContext, isOutsideEvent, isSelectableInput, isTabbable, provideFocusScopeContext, provideRdxFocusScopeConfig, queryComposedAll, tabbable, useFocusGuardsTabbability };
+export type { FocusScopeContext, FocusableElement, RdxFocusScopeConfig };

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

@@ -49,6 +49,13 @@ interface RdxFormState {
     dirty?: () => boolean;
     touched?: () => boolean;
     submitting?: () => boolean;
+    /**
+     * Optional Angular-owned submission lifecycle. Returning `undefined` keeps the Form's Base UI-style
+     * synchronous submit path; returning a Promise delegates this submit to the adapter. Signal Forms
+     * uses this only when its opt-in `rdxSignalSubmit` input is present, and calls Angular's public
+     * `submit()` API so validation, touched state, concurrency, and submission errors stay Angular-owned.
+     */
+    submit?: () => Promise<boolean> | undefined;
     /**
      * Per-name **client** validation errors (e.g. `rdxSignalForm`'s Signal Forms name-routing). Surfaced
      * through the Form's `clientErrorsFor` channel and gated by `validationMode` like any client validity.
@@ -190,6 +197,8 @@ declare class RdxFormRoot {
      */
     clearStateProvider(provider: RdxFormState | null, previous: RdxFormState | null): void;
     onSubmit(event: SubmitEvent): void;
+    private finishDelegatedSubmit;
+    private focusFirstInvalidField;
     onReset(): void;
     private readonly resetTimers;
     constructor();

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

@@ -24,6 +24,7 @@ interface RdxInputValueChangeEvent {
 declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | undefined> {
     private readonly element;
     private readonly fieldRootContext;
+    private readonly ngControlState;
     private initialValue;
     private defaultValueApplied;
     private readonly filledValue;
@@ -78,6 +79,8 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
      * @group Props
      */
     readonly invalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether async validation is pending. Pending inputs publish neither valid nor invalid state. */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * Whether the input has been touched. A two-way model: the input sets it on
      * blur (emitting `touchedChange`, which Signal Forms' `[formField]` listens
@@ -133,8 +136,11 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
      * @group Emits
      */
     readonly touch: _angular_core.OutputEmitterRef<void>;
-    /** The input's own binary invalidity (its `invalid` input or a non-empty `errors` list). */
+    /** Validation errors from the input and a same-host Reactive/template-driven form control. */
+    readonly validationErrors: _angular_core.Signal<readonly RdxValidationError[]>;
+    /** The input's binary invalidity, including a same-host Reactive/template-driven form control. */
     private readonly ownInvalid;
+    private readonly pendingState;
     /**
      * Tri-state *displayed* validity: inside a `rdxFieldRoot` the field's gated `validState` is the single
      * source (so a field whose `validationMode` defers display (e.g. `onBlur`) keeps the input neutral until revealed), otherwise
@@ -153,11 +159,13 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
     onFocus(): void;
     onBlur(): void;
     onInput(event: Event): void;
+    /** Reset the interaction baseline; Angular Signal Forms calls this from `FieldState.reset()`. */
+    reset(): void;
     syncFieldState(): void;
     private writeValue;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxInputDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxInputDirective, "input[rdxInput]", ["rdxInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "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; }; "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; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "onValueChange": "onValueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxInputDirective, "input[rdxInput]", ["rdxInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "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; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "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; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "onValueChange": "onValueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { RdxInputDirective };

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

@@ -11,6 +11,29 @@ import * as i1$1 from '@radix-ng/primitives/composite';
 import * as i1$2 from '@radix-ng/primitives/portal';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
+/**
+ * Submenu "safe polygon" — a faithful port of Floating UI's `safePolygon` algorithm
+ * (https://floating-ui.com/docs/useHover#safepolygon), adapted to this library.
+ *
+ * While a submenu is open by hover, the parent submenu owns the decision to close itself: a
+ * document-level `mousemove` handler keeps it open as long as the cursor is heading toward the
+ * popup inside a safe quadrilateral (built from the cursor's exit point and the popup rect), and
+ * closes it once the cursor leaves that area. Combined with the pointer-events "tunnel" below
+ * (`applyPointerTunnel`), siblings cannot steal the open submenu during a diagonal traversal.
+ *
+ * Differences from the upstream implementation:
+ * - `elements.domReference` / `elements.floating` → `reference` / `floating` (plain elements).
+ * - `placement.split('-')[0]` → the `side` option (read live from the popup's `data-side`).
+ * - the Floating UI tree (`tree` / `nodeId`) → the `hasOpenChild` callback, backed by the
+ *   module-level open-submenu registry.
+ *
+ * This deliberately does NOT reuse the core `useGraceArea` composable (tooltip / navigation-menu /
+ * popover): that one is a simpler convex-hull grace area with no velocity gating, trough handling, or
+ * pointer-events tunnel — none of which it needs, but all of which the submenu does to match Base UI
+ * and to stop sibling triggers from stealing the open submenu mid-traversal.
+ */
+type MenuSide = 'top' | 'bottom' | 'left' | 'right';
+
 type RdxMenuTransitionStatus = 'starting' | 'ending' | undefined;
 /**
  * Why an open/close happened instantly (no transition). Mirrors Base UI's menu `data-instant`:
@@ -81,6 +104,12 @@ interface RdxMenuRootContext {
     trigger: Signal<HTMLElement | undefined>;
     /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
     popupElement: Signal<HTMLElement | undefined>;
+    /**
+     * The popup's **physical** placed side (`top`/`bottom`/`left`/`right`) for safe-polygon geometry —
+     * never the popup's `data-side`, which is the logical `inline-start`/`inline-end` echo when a logical
+     * side was requested and which the geometry cannot interpret.
+     */
+    popupPhysicalSide: Signal<MenuSide | undefined>;
     beforeContentFocusGuard: Signal<HTMLElement | null>;
     transitionStatus: Signal<RdxMenuTransitionStatus>;
     close: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
@@ -92,7 +121,7 @@ interface RdxMenuRootContext {
     /** Open the menu without moving focus into the popup (used for menubar hover-switching). */
     showWithoutAutoFocus: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     registerTrigger: (el: HTMLElement) => () => void;
-    registerPopup: (el: HTMLElement) => () => void;
+    registerPopup: (el: HTMLElement, physicalSide?: Signal<MenuSide | undefined>) => () => void;
     setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
@@ -195,6 +224,9 @@ declare class RdxMenuRoot {
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    private readonly popupPhysicalSideSource;
+    /** Physical placed side read through the popup's own signal (undefined until the popup is placed). */
+    readonly popupPhysicalSide: Signal<MenuSide | undefined>;
     readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     readonly transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     readonly activeIndex: _angular_core.WritableSignal<number | null>;
@@ -239,7 +271,7 @@ declare class RdxMenuRoot {
      */
     closeEntireMenu(reason?: RdxMenuOpenChangeReason, event?: Event): void;
     registerTrigger(el: HTMLElement): () => void;
-    registerPopup(el: HTMLElement): () => void;
+    registerPopup(el: HTMLElement, physicalSide?: Signal<MenuSide | undefined>): () => void;
     setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
@@ -359,6 +391,15 @@ declare class RdxMenuSubTrigger {
     protected onArrowLeft(event: Event): void;
     protected onPointerMove(event: PointerEvent): void;
     protected onPointerLeave(): void;
+    /**
+     * Backup cancellation for a `pointerleave` that Chrome can drop during a fast pointer sweep across
+     * adjacent triggers, which would otherwise leave the delayed hover-open armed and open a stale
+     * submenu for a trigger the pointer has already left (stranding the parent at `pointer-events: none`).
+     * `pointerout` bubbles, so it also fires while crossing between the trigger's own descendants — those
+     * (where `relatedTarget` is still inside the trigger) must not cancel the pending open. Base UI parity
+     * (`guardStaleOpen`); safe on this single, hover-driven trigger.
+     */
+    protected onPointerOut(event: PointerEvent): void;
     protected clearHighlight(): void;
     private closeSiblingSubmenus;
     private clearSiblingHighlights;
@@ -376,11 +417,15 @@ declare class RdxMenuSubTrigger {
  * This replaces the consumer-owned `@if (root.open())` mount: it adds both teleporting *and*
  * exit-animation support. Apply it with the `*` microsyntax on the positioner —
  * `<div *rdxMenuPortal rdxMenuPositioner>` — or as an explicit `<ng-template rdxMenuPortal>`. For a
- * custom container, or a backdrop alongside the positioner (multi-root), use the explicit form.
+ * custom container, a backdrop alongside the positioner (multi-root), or `[keepMounted]`, use the
+ * explicit form.
+ *
+ * Set `[keepMounted]="true"` to keep the popup mounted while the menu is closed (the positioner's
+ * `data-closed` state hides it) — inherited from {@link RdxPortalPresence}.
  */
 declare class RdxMenuPortal {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPortal, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPortal, "ng-template[rdxMenuPortal]", ["rdxMenuPortal"], {}, {}, never, never, true, [{ directive: typeof i1$2.RdxPortalPresence; inputs: { "container": "container"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPortal, "ng-template[rdxMenuPortal]", ["rdxMenuPortal"], {}, {}, never, never, true, [{ directive: typeof i1$2.RdxPortalPresence; inputs: { "container": "container"; "keepMounted": "keepMounted"; }; outputs: {}; }]>;
 }
 /**
  * Dev-mode guard: `rdxMenuPortal` is a structural directive. The old `<div rdxMenuPortal>` markup
@@ -402,6 +447,13 @@ declare class RdxMenuPortalMisuseGuard {
 declare class RdxMenuPositioner extends RdxPopperContentWrapper {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
     protected readonly legacyVars: Record<string, string>;
+    /**
+     * Whether the popup is shown: open, or still running its closing transition. Drives both the native
+     * `hidden` (finding: a closed keep-mounted popup must hide itself) and — via `positioningActive` —
+     * whether the inherited wrapper keeps tracking the anchor, so a closed keep-mounted positioner stops
+     * its `autoUpdate` `requestAnimationFrame` loop (finding: endless rAF while closed).
+     */
+    protected readonly visible: _angular_core.Signal<boolean>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPositioner, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPositioner, "[rdxMenuPositioner]", ["rdxMenuPositioner"], {}, {}, never, never, true, never>;
@@ -422,7 +474,7 @@ declare class RdxMenuPopup {
     private search;
     private searchTimer;
     protected readonly align: _angular_core.Signal<"center" | "end" | "start" | undefined>;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1.SideOrLogical | undefined>;
     /**
      * Event handler called when the escape key is pressed. Can be prevented.
      */
@@ -456,7 +508,7 @@ declare class RdxMenuPopup {
     private currentItemIndex;
     private focusMenuItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPopup, "[rdxMenuPopup]", ["rdxMenuPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }, { directive: typeof i1$1.RdxCompositeList; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPopup, "[rdxMenuPopup]", ["rdxMenuPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1.RdxPopperContent; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: { "returnFocus": "finalFocus"; }; outputs: {}; }, { directive: typeof i1$1.RdxCompositeList; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -509,7 +561,7 @@ declare class RdxMenuBackdrop {
 declare class RdxMenuArrow {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"center" | "end" | "start" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuArrow, never>;

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

@@ -383,7 +383,7 @@ declare class RdxNavigationMenuPopup {
     private readonly registration;
     private readonly wrapper;
     private readonly elementRef;
-    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 id: _angular_core.Signal<string>;
     /**
@@ -420,7 +420,7 @@ declare class RdxNavigationMenuPopup {
 declare class RdxNavigationMenuArrow {
     protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
     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<RdxNavigationMenuArrow, never>;

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

@@ -304,7 +304,7 @@ declare class RdxPopoverPopup {
     private readonly focusScope;
     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. */
     readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
     /** Event handler called when a pointerdown event happens outside of the popup. Can be prevented. */
@@ -328,7 +328,7 @@ declare class RdxPopoverPopup {
 declare class RdxPopoverArrow {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
     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<RdxPopoverArrow, never>;