@radix-ng/primitives 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -1,13 +1,14 @@
 import * as _angular_core from '@angular/core';
-import { Signal, ElementRef } 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 { RdxFloatingRootContext, BooleanInput, Direction, RdxCancelableChangeEventDetails, NumberInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
+import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as i1 from '@radix-ng/primitives/popper';
-import { RdxPopperContentWrapper, RdxPopperAnchorElement } from '@radix-ng/primitives/popper';
+import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_menu from '@radix-ng/primitives/menu';
-import * as i2 from '@radix-ng/primitives/dismissable-layer';
 import * as i1$1 from '@radix-ng/primitives/portal';
-import * as i3 from '@radix-ng/primitives/focus-scope';
+import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
 type RdxMenuTransitionStatus = 'starting' | 'ending' | undefined;
 /**
@@ -20,39 +21,87 @@ type RdxMenuTransitionStatus = 'starting' | 'ending' | undefined;
 type RdxMenuAutoFocus = 'first' | 'last' | 'popup' | false;
 type RdxMenuAutoFocusInput = boolean | RdxMenuAutoFocus;
 type RdxMenuOrientation = 'horizontal' | 'vertical';
+/**
+ * What kind of parent a menu has (Base UI `MenuParent.type`). Drives the per-kind dismissal / focus /
+ * backdrop / scroll-lock policy:
+ * - `'menu'` — a **submenu** (its parent is another menu).
+ * - `'menubar'` — a menu coordinated by a `Menubar`.
+ * - `'context-menu'` — the root of a `ContextMenu` (opened at the pointer).
+ * - `undefined` — a standalone menu (a plain dropdown).
+ */
+type RdxMenuParentType = 'menu' | 'menubar' | 'context-menu' | undefined;
+/**
+ * Why a menu's open state changed (Base UI open-change `reason`). Read by the per-kind policy — e.g. a
+ * `'trigger-hover'` open suppresses the modal backdrop / scroll-lock, and the dismissal reason decides
+ * return-focus.
+ */
+type RdxMenuOpenChangeReason = 'trigger-press' | 'trigger-hover' | 'trigger-focus' | 'list-navigation' | 'sibling-open' | 'escape-key' | 'outside-press' | 'cancel-open' | 'focus-out' | 'none';
+type RdxMenuOpenChangeEventDetails = RdxCancelableChangeEventDetails<RdxMenuOpenChangeReason>;
+interface RdxMenuOpenChange {
+    open: boolean;
+    trigger: HTMLElement | undefined;
+    reason: RdxMenuOpenChangeReason;
+    event: Event;
+    eventDetails: RdxMenuOpenChangeEventDetails;
+}
 interface RdxMenuRootContext {
     isOpen: Signal<boolean>;
+    present: Signal<boolean>;
     disabled: Signal<boolean>;
     modal: Signal<boolean>;
     loopFocus: Signal<boolean>;
     highlightItemOnHover: Signal<boolean>;
     orientation: Signal<RdxMenuOrientation>;
+    dir: Signal<Direction>;
     closeParentOnEsc: Signal<boolean>;
     /** Whether the popup should focus its first item when it opens. */
     autoFocus: Signal<RdxMenuAutoFocus>;
     isSubmenu: Signal<boolean>;
+    /** What kind of parent this menu has (ADR 0015/0017 parity) — drives the per-kind policy. */
+    parentType: Signal<RdxMenuParentType>;
+    /** The reason for the most recent open-change (Base UI open-change `reason`). */
+    lastOpenChangeReason: Signal<RdxMenuOpenChangeReason>;
+    /** Whether a trigger-originated press may activate an item on the following mouseup. */
+    allowMouseUpTrigger: Signal<boolean>;
+    /** Whether the current open was initiated by touch (ADR 0016 §3 — gates the anchored scroll lock). */
+    openedByTouch: Signal<boolean>;
+    openInteractionType: Signal<RdxInteractionType>;
+    closeInteractionType: Signal<RdxInteractionType>;
     hasTriggerInteractionHandler: Signal<boolean>;
     trigger: Signal<HTMLElement | undefined>;
     /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
     popupElement: Signal<HTMLElement | undefined>;
+    beforeContentFocusGuard: Signal<HTMLElement | null>;
     transitionStatus: Signal<RdxMenuTransitionStatus>;
-    close: () => void;
-    toggle: () => void;
-    show: (autoFocus?: RdxMenuAutoFocusInput) => void;
+    close: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
+    /** Close this menu and every ancestor — used by item selection (the whole menu dismisses). */
+    closeEntireMenu: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
+    toggle: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
+    show: (autoFocus?: RdxMenuAutoFocusInput, reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     /** Open the menu without moving focus into the popup (used for menubar hover-switching). */
-    showWithoutAutoFocus: () => void;
+    showWithoutAutoFocus: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     registerTrigger: (el: HTMLElement) => () => void;
     registerPopup: (el: HTMLElement) => () => void;
+    setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
     registerTriggerInteractionHandler: (handler: RdxMenuTriggerInteractionHandler) => () => void;
     markAsSubmenu: () => void;
+    /** Marks this menu as the root of a Context Menu (called by `RdxContextMenuRoot`). */
+    markAsContextMenu: () => void;
+    setAllowMouseUpTrigger: (value: boolean) => void;
     closeParent: () => void;
     handlePopupArrowNavigation: (offset: 1 | -1) => boolean;
     handleTriggerInteraction: (interaction: RdxMenuTriggerInteraction) => boolean;
 }
 type RdxMenuTriggerInteraction = {
     type: 'click';
+} | {
+    type: 'enter';
+    event: Event;
+} | {
+    type: 'space';
+    event: Event;
 } | {
     type: 'pointerenter';
     event: PointerEvent;
@@ -86,6 +135,14 @@ declare const provideRdxMenuRootContext: (useFactory: () => RdxMenuRootContext)
  */
 declare class RdxMenuRoot {
     private readonly popper;
+    private readonly parentRoot;
+    private readonly providedDirection;
+    /**
+     * The shared per-popup floating context (ADR 0015 §1) — `open` mirrors this menu's open state, the
+     * trigger registry is bridged from {@link registerTrigger}, and the reference / floating elements are
+     * set by the trigger / popup. The new dismissal engine reads this once the popup migrates.
+     */
+    readonly floatingContext: RdxFloatingRootContext;
     /** Shared open/close transition state machine (completes on the real animationend). */
     private readonly transition;
     private registeredTrigger;
@@ -98,7 +155,10 @@ declare class RdxMenuRoot {
     readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether interactions with the menu are disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** Whether the menu should block outside interactions. */
+    /**
+     * Whether the menu should block outside interactions and page scrolling.
+     * Nested menus are always non-modal.
+     */
     readonly modal: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether keyboard navigation wraps at list boundaries. */
     readonly loopFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
@@ -106,26 +166,58 @@ declare class RdxMenuRoot {
     readonly highlightItemOnHover: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** The menu orientation. */
     readonly orientation: _angular_core.InputSignal<RdxMenuOrientation>;
+    /** Text direction for submenu arrow-key behavior. Inherited by nested submenu roots. */
+    readonly dirInput: _angular_core.InputSignal<Direction | undefined>;
     /** Whether pressing Escape inside a submenu closes the whole menu chain. */
     readonly closeParentOnEsc: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Emits when the open state changes. */
-    readonly onOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly onOpenChange: _angular_core.OutputEmitterRef<RdxMenuOpenChange>;
     /** Emits when the open/close CSS transition or animation finishes. */
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     readonly transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     /** Whether the popup grabs focus when it opens. Set false for menubar hover-switching. */
     readonly autoFocus: _angular_core.WritableSignal<RdxMenuAutoFocus>;
     readonly isSubmenu: _angular_core.WritableSignal<boolean>;
+    /** Set by `RdxContextMenuRoot` (it composes this root) — distinguishes a context menu from a dropdown. */
+    readonly isContextMenu: _angular_core.WritableSignal<boolean>;
     readonly hasTriggerInteractionHandler: _angular_core.WritableSignal<boolean>;
+    private readonly preventUnmountOnClose;
+    /**
+     * What kind of parent this menu has (Base UI `MenuParent.type`). A submenu wins over everything (its
+     * parent is a menu); otherwise a context-menu marker, then a menubar (detected by the trigger
+     * interaction handler the menubar registers), else a standalone dropdown.
+     */
+    readonly parentType: Signal<RdxMenuParentType>;
+    /** The reason for the most recent open-change (Base UI open-change `reason`), for the per-kind policy. */
+    readonly lastOpenChangeReason: _angular_core.WritableSignal<RdxMenuOpenChangeReason>;
+    private readonly localAllowMouseUpTrigger;
+    readonly allowMouseUpTrigger: Signal<boolean>;
+    /** Whether the current open was initiated by **touch** (ADR 0016 §3 — gates the anchored scroll lock). */
+    readonly openedByTouch: _angular_core.WritableSignal<boolean>;
+    readonly openInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    readonly closeInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    readonly effectiveDisabled: Signal<boolean>;
+    readonly dir: Signal<Direction>;
+    readonly effectiveModal: Signal<boolean>;
     readonly state: Signal<"open" | "closed">;
+    readonly present: Signal<boolean>;
     constructor();
-    show(autoFocus?: RdxMenuAutoFocusInput): void;
-    close(): void;
-    toggle(): void;
+    show(autoFocus?: RdxMenuAutoFocusInput, reason?: RdxMenuOpenChangeReason, event?: Event): void;
+    close(reason?: RdxMenuOpenChangeReason, event?: Event): void;
+    toggle(reason?: RdxMenuOpenChangeReason, event?: Event): void;
+    markAsContextMenu(): void;
+    setAllowMouseUpTrigger(value: boolean): void;
+    /**
+     * Close this menu **and every ancestor menu** in the chain. Selecting an item dismisses the whole
+     * menu, not just the innermost submenu (a submenu's `close()` would leave its parents open).
+     */
+    closeEntireMenu(reason?: RdxMenuOpenChangeReason, event?: Event): void;
     registerTrigger(el: HTMLElement): () => void;
     registerPopup(el: HTMLElement): () => void;
+    setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
     handlePopupArrowNavigation(offset: 1 | -1): boolean;
@@ -133,8 +225,9 @@ declare class RdxMenuRoot {
     handleTriggerInteraction(interaction: RdxMenuTriggerInteraction): boolean;
     markAsSubmenu(): void;
     closeParent(): void;
+    private createOpenChangeEvent;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRoot, "[rdxMenuRoot],[rdxMenuSubmenuRoot]", ["rdxMenuRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "highlightItemOnHover": { "alias": "highlightItemOnHover"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "closeParentOnEsc": { "alias": "closeParentOnEsc"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1.RdxPopper; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRoot, "[rdxMenuRoot],[rdxMenuSubmenuRoot]", ["rdxMenuRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "loopFocus": { "alias": "loopFocus"; "required": false; "isSignal": true; }; "highlightItemOnHover": { "alias": "highlightItemOnHover"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "closeParentOnEsc": { "alias": "closeParentOnEsc"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -144,9 +237,14 @@ declare class RdxMenuTrigger {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
     private readonly elementRef;
     private readonly destroyRef;
-    private readonly dismissableLayersContext;
+    private readonly isBrowser;
     private openTimer;
     private closeTimer;
+    private allowMouseUpTriggerTimer;
+    private lastPointer;
+    private openedByHover;
+    private ignoreNextClick;
+    private readonly handleDocumentMouseUp;
     /** Whether this trigger should be treated as a native button. Auto-detected for `<button>`. */
     readonly nativeButton: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether this trigger is disabled. */
@@ -159,8 +257,11 @@ declare class RdxMenuTrigger {
     readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     protected readonly nativeButtonState: _angular_core.Signal<boolean>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     constructor();
-    protected handleClick(): void;
+    protected handleMouseDown(event: MouseEvent): void;
+    protected handlePointerDown(event: PointerEvent): void;
+    protected handleClick(event: MouseEvent): void;
     protected handleArrowDown(event: Event): void;
     protected handleArrowUp(event: Event): void;
     protected handleArrowLeft(event: Event): void;
@@ -171,8 +272,13 @@ declare class RdxMenuTrigger {
     protected handleKeyboardToggle(event: Event): void;
     protected handlePointerEnter(event: PointerEvent): void;
     protected handlePointerLeave(event: PointerEvent): void;
+    protected handlePointerMove(event: PointerEvent): void;
+    private scheduleClose;
     private clearOpenTimer;
     private clearCloseTimer;
+    private armMouseUpGuard;
+    private clearMouseUpGuard;
+    private restoreKeyboardPopupFocus;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuTrigger, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuTrigger, "[rdxMenuTrigger]", ["rdxMenuTrigger"], { "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
@@ -198,6 +304,7 @@ declare class RdxMenuSubTrigger {
     private lastPointer;
     /** Whether the current open was initiated by hover (vs keyboard / click). */
     private openedByHover;
+    private ignoreNextKeyboardClick;
     /** Whether this trigger (and therefore the submenu) is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether this trigger should be treated as a native button. Auto-detected for `<button>`. */
@@ -212,20 +319,24 @@ declare class RdxMenuSubTrigger {
     readonly label: _angular_core.InputSignal<string | undefined>;
     /** Highlighted when focused OR while the submenu is open. */
     protected readonly highlighted: _angular_core.Signal<boolean>;
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
     protected readonly nativeButtonState: _angular_core.Signal<boolean>;
     constructor();
     private scheduleClose;
     protected onFocus(): void;
     protected onBlur(): void;
-    protected onClick(): void;
+    protected onClick(event: MouseEvent): void;
+    protected onEnter(event: Event): void;
     protected onArrowRight(event: Event): void;
+    protected onArrowLeft(event: Event): void;
     protected onPointerMove(event: PointerEvent): void;
     protected onPointerLeave(): void;
     protected clearHighlight(): void;
     private closeSiblingSubmenus;
     private clearSiblingHighlights;
+    private focusFirstSubmenuItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuSubTrigger, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuSubTrigger, "[rdxMenuSubTrigger]", ["rdxMenuSubTrigger"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxDismissableLayerBranch; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuSubTrigger, "[rdxMenuSubTrigger]", ["rdxMenuSubTrigger"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "nativeButton": { "alias": "nativeButton"; "required": false; "isSignal": true; }; "openOnHover": { "alias": "openOnHover"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.RdxPopperAnchor; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -253,68 +364,17 @@ declare class RdxMenuPortalMisuseGuard {
 
 /**
  * Positions the menu against its trigger.
+ *
+ * A "thin" positioner (ADR 0012): it inherits the popper positioning surface (inputs, `placed`
+ * output, unified vars + placement attrs) from {@link RdxPopperContentWrapper} and adds the menu
+ * defaults, the open/closed state attributes, and the deprecated `--radix-menu-*` aliases.
  */
-declare class RdxMenuPositioner {
+declare class RdxMenuPositioner extends RdxPopperContentWrapper {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
-    protected readonly wrapper: RdxPopperContentWrapper;
-    /**
-     * An element to position the popup against. Defaults to the trigger.
-     */
-    readonly anchor: _angular_core.InputSignal<RdxPopperAnchorElement>;
-    /**
-     * The preferred side of the trigger to render against when open.
-     */
-    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
-    /**
-     * Distance between the trigger and the popup in pixels.
-     */
-    readonly sideOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * How to align the popup relative to the specified side.
-     */
-    readonly align: _angular_core.InputSignal<"end" | "start" | "center">;
-    /**
-     * An offset in pixels from the `start` or `end` alignment options.
-     */
-    readonly alignOffset: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * Minimum distance to maintain between the arrow and the edges of the popup.
-     */
-    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, NumberInput>;
-    /**
-     * Whether to override side and alignment preferences to prevent collisions.
-     */
-    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The element used as the collision boundary.
-     */
-    readonly collisionBoundary: _angular_core.InputSignal<ElementRef<HTMLElement> | ElementRef<HTMLElement>[] | undefined>;
-    /**
-     * Distance in pixels from the boundary edges where collision detection should occur.
-     */
-    readonly collisionPadding: _angular_core.InputSignal<number | Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
-    /**
-     * The sticky behavior on the alignment axis.
-     */
-    readonly sticky: _angular_core.InputSignal<"always" | "partial">;
-    /**
-     * Whether to hide the popup when the trigger becomes fully occluded.
-     */
-    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * The CSS position strategy used by Floating UI.
-     */
-    readonly positionStrategy: _angular_core.InputSignal<"fixed" | "absolute">;
-    /**
-     * Whether to update position on every animation frame.
-     */
-    readonly updatePositionStrategy: _angular_core.InputSignal<"always" | "optimized">;
-    /**
-     * Emits when the popup has been placed.
-     */
-    readonly placed: _angular_core.OutputRef<void>;
+    protected readonly legacyVars: Record<string, string>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuPositioner, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPositioner, "[rdxMenuPositioner]", ["rdxMenuPositioner"], { "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"; }, never, never, true, [{ directive: typeof i1.RdxPopperContentWrapper; inputs: { "anchor": "anchor"; "side": "side"; "sideOffset": "sideOffset"; "align": "align"; "alignOffset": "alignOffset"; "arrowPadding": "arrowPadding"; "avoidCollisions": "avoidCollisions"; "collisionBoundary": "collisionBoundary"; "collisionPadding": "collisionPadding"; "sticky": "sticky"; "hideWhenDetached": "hideWhenDetached"; "positionStrategy": "positionStrategy"; "updatePositionStrategy": "updatePositionStrategy"; }; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuPositioner, "[rdxMenuPositioner]", ["rdxMenuPositioner"], {}, {}, never, never, true, never>;
 }
 
 /**
@@ -322,11 +382,12 @@ declare class RdxMenuPositioner {
  */
 declare class RdxMenuPopup {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
-    private readonly dismissableLayer;
+    private readonly floatingContext;
+    private readonly registration;
+    private readonly focusManager;
     private readonly focusScope;
     private readonly wrapper;
     private readonly elementRef;
-    private readonly dismissableLayersContext;
     private search;
     private searchTimer;
     protected readonly align: _angular_core.Signal<"end" | "start" | "center" | undefined>;
@@ -334,19 +395,19 @@ declare class RdxMenuPopup {
     /**
      * Event handler called when the escape key is pressed. Can be prevented.
      */
-    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
     /**
      * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
      */
-    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent>;
     /**
      * Event handler called when focus moves outside of the popup. Can be prevented.
      */
-    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
     /**
      * Event handler called when an interaction happens outside of the popup. Can be prevented.
      */
-    readonly interactOutside: _angular_core.OutputRef<PointerEvent | FocusEvent>;
+    readonly interactOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent | FocusEvent>;
     /**
      * Event handler called before focus moves into the popup. Can be prevented.
      */
@@ -358,8 +419,10 @@ declare class RdxMenuPopup {
     constructor();
     protected handleCloseParent(event: Event): void;
     protected handleKeydown(event: KeyboardEvent): void;
+    private scheduleSubmenuKeyboardFocus;
+    private applySubmenuKeyboardFocus;
     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 i2.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i3.RdxFocusScope; 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: {}; outputs: {}; }]>;
 }
 
 /**
@@ -435,11 +498,13 @@ declare class RdxMenuItem {
     /** Emits when the item is selected. */
     readonly onSelect: _angular_core.OutputEmitterRef<void>;
     protected readonly highlighted: _angular_core.Signal<boolean>;
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
     onFocus(): void;
     onBlur(): void;
     onPointerMove(event: PointerEvent): void;
     onPointerLeave(event: PointerEvent): void;
     onItemClick(): void;
+    onMouseUp(event: MouseEvent): void;
     protected onActivate(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuItem, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuItem, "[rdxMenuItem]", ["rdxMenuItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
@@ -461,11 +526,13 @@ declare class RdxMenuLinkItem {
     /** Emits when the item is selected. */
     readonly onSelect: _angular_core.OutputEmitterRef<void>;
     protected readonly highlighted: _angular_core.Signal<boolean>;
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
     onFocus(): void;
     onBlur(): void;
     onPointerMove(event: PointerEvent): void;
     onPointerLeave(event: PointerEvent): void;
     onItemClick(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
     protected onActivate(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuLinkItem, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuLinkItem, "a[rdxMenuLinkItem]", ["rdxMenuLinkItem"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
@@ -475,6 +542,7 @@ declare class RdxMenuLinkItem {
  * Groups related menu items together.
  */
 declare class RdxMenuGroup {
+    readonly labelId: _angular_core.WritableSignal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuGroup, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuGroup, "[rdxMenuGroup]", ["rdxMenuGroup"], {}, {}, never, never, true, never>;
 }
@@ -483,6 +551,9 @@ declare class RdxMenuGroup {
  * A label for a menu group.
  */
 declare class RdxMenuGroupLabel {
+    private readonly groupContext;
+    readonly id: string;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuGroupLabel, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuGroupLabel, "[rdxMenuGroupLabel]", ["rdxMenuGroupLabel"], {}, {}, never, never, true, never>;
 }
@@ -522,6 +593,7 @@ declare class RdxMenuCheckboxItem {
     /** Emits when the checked state changes. */
     readonly onCheckedChange: _angular_core.OutputEmitterRef<CheckedState>;
     protected readonly highlighted: Signal<boolean>;
+    protected readonly effectiveDisabled: Signal<boolean>;
     protected readonly isIndeterminate: typeof isIndeterminate;
     protected readonly getCheckedState: typeof getCheckedState;
     onFocus(): void;
@@ -529,6 +601,7 @@ declare class RdxMenuCheckboxItem {
     onPointerMove(event: PointerEvent): void;
     onPointerLeave(event: PointerEvent): void;
     onItemClick(): void;
+    onMouseUp(event: MouseEvent): void;
     protected onActivate(event: Event): void;
     private toggleChecked;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuCheckboxItem, never>;
@@ -549,27 +622,35 @@ declare class RdxMenuCheckboxItemIndicator {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuCheckboxItemIndicator, "[rdxMenuCheckboxItemIndicator]", ["rdxMenuCheckboxItemIndicator"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-interface RdxMenuRadioGroupContext {
-    value: Signal<string | undefined>;
-    selectValue: (value: string) => void;
+interface RdxMenuRadioGroupContext<T = unknown> {
+    value: Signal<T | undefined>;
+    disabled: Signal<boolean>;
+    selectValue: (value: T) => void;
 }
-declare const injectRdxMenuRadioGroupContext: _radix_ng_primitives_core.InjectContext<RdxMenuRadioGroupContext>;
-declare const provideRdxMenuRadioGroupContext: (useFactory: () => RdxMenuRadioGroupContext) => _angular_core.Provider;
+declare const injectRdxMenuRadioGroupContext: _radix_ng_primitives_core.InjectContext<RdxMenuRadioGroupContext<unknown>>;
+declare const provideRdxMenuRadioGroupContext: (useFactory: () => RdxMenuRadioGroupContext<unknown>) => _angular_core.Provider;
 /**
  * Groups radio items in a menu.
  */
-declare class RdxMenuRadioGroup {
+declare class RdxMenuRadioGroup<T = unknown> {
+    private hasAppliedDefaultValue;
     /**
      * The currently selected value.
      */
-    readonly value: _angular_core.ModelSignal<string | undefined>;
+    readonly value: _angular_core.ModelSignal<T | undefined>;
+    /** The initially selected value for uncontrolled usage. */
+    readonly defaultValue: _angular_core.InputSignal<T | undefined>;
+    /** Whether all radio items in the group are disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * Emits when the selected value changes.
      */
-    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
-    selectValue(newValue: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioGroup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioGroup, "[rdxMenuRadioGroup]", ["rdxMenuRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<T>;
+    readonly labelId: _angular_core.WritableSignal<string | undefined>;
+    constructor();
+    selectValue(newValue: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioGroup<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioGroup<any>, "[rdxMenuRadioGroup]", ["rdxMenuRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, never>;
 }
 
 interface RdxMenuRadioItemContext {
@@ -580,13 +661,13 @@ declare const provideRdxMenuRadioItemContext: (useFactory: () => RdxMenuRadioIte
 /**
  * A radio item within a menu radio group.
  */
-declare class RdxMenuRadioItem {
+declare class RdxMenuRadioItem<T = unknown> {
     private readonly rootContext;
     private readonly radioGroupContext;
     private readonly elementRef;
     private readonly isFocused;
     /** The value of this radio item. */
-    readonly value: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<T>;
     /** Whether this item is disabled. */
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Whether selecting closes the menu. Defaults to false — radio items stay open. */
@@ -594,19 +675,21 @@ declare class RdxMenuRadioItem {
     /** Explicit typeahead label. When set, overrides textContent for character search. */
     readonly label: _angular_core.InputSignal<string | undefined>;
     /** Emits when this item is selected. */
-    readonly onSelect: _angular_core.OutputEmitterRef<string>;
+    readonly onSelect: _angular_core.OutputEmitterRef<T>;
     readonly checked: Signal<boolean>;
     protected readonly highlighted: Signal<boolean>;
+    protected readonly effectiveDisabled: Signal<boolean>;
     protected readonly getCheckedState: typeof getCheckedState;
     onFocus(): void;
     onBlur(): void;
     onPointerMove(event: PointerEvent): void;
     onPointerLeave(event: PointerEvent): void;
     onItemClick(): void;
+    onMouseUp(event: MouseEvent): void;
     protected onActivate(event: Event): void;
     private selectItem;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioItem, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioItem, "[rdxMenuRadioItem]", ["rdxMenuRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuRadioItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioItem<any>, "[rdxMenuRadioItem]", ["rdxMenuRadioItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "onSelect": "onSelect"; }, never, never, true, never>;
 }
 
 /**
@@ -623,11 +706,17 @@ declare class RdxMenuRadioItemIndicator {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxMenuRadioItemIndicator, "[rdxMenuRadioItemIndicator]", ["rdxMenuRadioItemIndicator"], { "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+interface RdxMenuGroupContext {
+    labelId: WritableSignal<string | undefined>;
+}
+declare const injectRdxMenuGroupContext: _radix_ng_primitives_core.InjectContext<RdxMenuGroupContext>;
+declare const provideRdxMenuGroupContext: (useFactory: () => RdxMenuGroupContext) => _angular_core.Provider;
+
 declare class RdxMenuModule {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuModule, never>;
     static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxMenuModule, never, [typeof RdxMenuRoot, typeof RdxMenuTrigger, typeof RdxMenuSubTrigger, typeof RdxMenuPortal, typeof RdxMenuPortalMisuseGuard, typeof RdxMenuPositioner, typeof RdxMenuPopup, typeof RdxMenuViewport, typeof RdxMenuBackdrop, typeof RdxMenuArrow, typeof RdxMenuItem, typeof RdxMenuLinkItem, typeof RdxMenuGroup, typeof RdxMenuGroupLabel, typeof RdxMenuSeparator, typeof RdxMenuCheckboxItem, typeof RdxMenuCheckboxItemIndicator, typeof RdxMenuRadioGroup, typeof RdxMenuRadioItem, typeof RdxMenuRadioItemIndicator], [typeof RdxMenuRoot, typeof RdxMenuTrigger, typeof RdxMenuSubTrigger, typeof RdxMenuPortal, typeof RdxMenuPortalMisuseGuard, typeof RdxMenuPositioner, typeof RdxMenuPopup, typeof RdxMenuViewport, typeof RdxMenuBackdrop, typeof RdxMenuArrow, typeof RdxMenuItem, typeof RdxMenuLinkItem, typeof RdxMenuGroup, typeof RdxMenuGroupLabel, typeof RdxMenuSeparator, typeof RdxMenuCheckboxItem, typeof RdxMenuCheckboxItemIndicator, typeof RdxMenuRadioGroup, typeof RdxMenuRadioItem, typeof RdxMenuRadioItemIndicator]>;
     static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxMenuModule>;
 }
 
-export { RdxMenuArrow, RdxMenuBackdrop, RdxMenuCheckboxItem, RdxMenuCheckboxItemIndicator, RdxMenuGroup, RdxMenuGroupLabel, RdxMenuItem, RdxMenuLinkItem, RdxMenuModule, RdxMenuPopup, RdxMenuPortal, RdxMenuPortalMisuseGuard, RdxMenuPositioner, RdxMenuRadioGroup, RdxMenuRadioItem, RdxMenuRadioItemIndicator, RdxMenuRoot, RdxMenuSeparator, RdxMenuSubTrigger, RdxMenuTrigger, RdxMenuViewport, getCheckedState, injectRdxMenuCheckboxItemContext, injectRdxMenuRadioGroupContext, injectRdxMenuRadioItemContext, injectRdxMenuRootContext, isIndeterminate, provideRdxMenuCheckboxItemContext, provideRdxMenuRadioGroupContext, provideRdxMenuRadioItemContext, provideRdxMenuRootContext };
-export type { CheckedState, RdxMenuAutoFocus, RdxMenuAutoFocusInput, RdxMenuCheckboxItemContext, RdxMenuOrientation, RdxMenuRadioGroupContext, RdxMenuRadioItemContext, RdxMenuRootContext, RdxMenuTransitionStatus, RdxMenuTriggerInteraction, RdxMenuTriggerInteractionHandler };
+export { RdxMenuArrow, RdxMenuBackdrop, RdxMenuCheckboxItem, RdxMenuCheckboxItemIndicator, RdxMenuGroup, RdxMenuGroupLabel, RdxMenuItem, RdxMenuLinkItem, RdxMenuModule, RdxMenuPopup, RdxMenuPortal, RdxMenuPortalMisuseGuard, RdxMenuPositioner, RdxMenuRadioGroup, RdxMenuRadioItem, RdxMenuRadioItemIndicator, RdxMenuRoot, RdxMenuSeparator, RdxMenuSubTrigger, RdxMenuTrigger, RdxMenuViewport, getCheckedState, injectRdxMenuCheckboxItemContext, injectRdxMenuGroupContext, injectRdxMenuRadioGroupContext, injectRdxMenuRadioItemContext, injectRdxMenuRootContext, isIndeterminate, provideRdxMenuCheckboxItemContext, provideRdxMenuGroupContext, provideRdxMenuRadioGroupContext, provideRdxMenuRadioItemContext, provideRdxMenuRootContext };
+export type { CheckedState, RdxMenuAutoFocus, RdxMenuAutoFocusInput, RdxMenuCheckboxItemContext, RdxMenuGroupContext, RdxMenuOpenChange, RdxMenuOpenChangeEventDetails, RdxMenuOpenChangeReason, RdxMenuOrientation, RdxMenuParentType, RdxMenuRadioGroupContext, RdxMenuRadioItemContext, RdxMenuRootContext, RdxMenuTransitionStatus, RdxMenuTriggerInteraction, RdxMenuTriggerInteractionHandler };