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

package/fesm2022/radix-ng-primitives-floating-focus-manager.mjs

@@ -0,0 +1,803 @@
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from '@angular/core';
+import { InjectionToken, booleanAttribute, signal, input, output, inject, computed, ElementRef, PLATFORM_ID, effect, DestroyRef, Directive } from '@angular/core';
+import { RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_REGISTRATION } from '@radix-ng/primitives/core';
+import * as i1 from '@radix-ng/primitives/focus-scope';
+import { provideRdxFocusScopeConfig, RdxFocusScopeConfigToken, useFocusGuardsTabbability, RdxFocusScope, FOCUS_GUARD_ATTR, getTabbableCandidates, focus, createFocusGuard, enableFocusInside, isOutsideEvent, getNextTabbable, getPreviousTabbable, composedContains, createAriaOwnsAnchor, getTabbableBeforeElement, getTabbableAfterElement } from '@radix-ng/primitives/focus-scope';
+
+/** The neutral "outside the active floating layer" marker (Base UI `data-base-ui-inert`). */
+const RDX_FLOATING_MARKER = 'data-rdx-floating-inert';
+/** Per-element, per-attribute ref-counts. Keyed by element, so they are naturally per-`Document`. */
+const controlCounters = {
+    inert: new WeakMap(),
+    'aria-hidden': new WeakMap()
+};
+/** Elements that already carried the control attribute before we touched them — left in place on undo. */
+const preExistingControlled = {
+    inert: new WeakSet(),
+    'aria-hidden': new WeakSet()
+};
+let markerCounters = new WeakMap();
+let lockCount = 0;
+function unwrapHost(node) {
+    if (!node) {
+        return null;
+    }
+    return node instanceof ShadowRoot ? node.host : unwrapHost(node.parentNode);
+}
+/** Maps each target to the element actually inside `parent` (piercing shadow hosts), dropping the rest. */
+function correctElements(parent, targets) {
+    return targets
+        .map((target) => {
+        if (parent.contains(target)) {
+            return target;
+        }
+        const host = unwrapHost(target);
+        return host && parent.contains(host) ? host : null;
+    })
+        .filter((element) => element != null);
+}
+/** The set of nodes on the path from each target up to the root — the "keep" subtree. */
+function buildKeepSet(targets) {
+    const keep = new Set();
+    targets.forEach((target) => {
+        let node = target;
+        while (node && !keep.has(node)) {
+            keep.add(node);
+            node = node.parentNode;
+        }
+    });
+    return keep;
+}
+/** Collects every element outside the kept subtree (a sibling of the kept ancestor chain). */
+function collectOutsideElements(root, keep, stop) {
+    const outside = [];
+    const walk = (parent) => {
+        if (!parent || stop.has(parent)) {
+            return;
+        }
+        Array.from(parent.children).forEach((node) => {
+            if (node.nodeName.toLowerCase() === 'script') {
+                return;
+            }
+            if (keep.has(node)) {
+                walk(node);
+            }
+            else {
+                outside.push(node);
+            }
+        });
+    };
+    walk(root);
+    return outside;
+}
+function markOthers(avoidElements, options = {}) {
+    const { ariaHidden = false, inert = false, mark = true } = options;
+    const first = avoidElements[0];
+    if (!first) {
+        return () => { };
+    }
+    const body = first.ownerDocument.body;
+    const avoid = correctElements(body, avoidElements);
+    // `inert` wins over `aria-hidden` (it already removes the subtree from the a11y tree, Base UI).
+    const controlAttribute = inert ? 'inert' : ariaHidden ? 'aria-hidden' : null;
+    const controlledElements = [];
+    const markedElements = [];
+    if (controlAttribute) {
+        const counters = controlCounters[controlAttribute];
+        const preExisting = preExistingControlled[controlAttribute];
+        // `aria-live` regions stay announceable, so keep them out of the controlled set too.
+        const live = correctElements(body, Array.from(body.querySelectorAll('[aria-live]')));
+        const controlElements = avoid.concat(live);
+        const targets = collectOutsideElements(body, buildKeepSet(controlElements), new Set(controlElements));
+        targets.forEach((node) => {
+            const attr = node.getAttribute(controlAttribute);
+            const already = attr !== null && attr !== 'false';
+            const count = (counters.get(node) ?? 0) + 1;
+            counters.set(node, count);
+            controlledElements.push(node);
+            if (count === 1 && already) {
+                preExisting.add(node);
+            }
+            if (!already) {
+                node.setAttribute(controlAttribute, controlAttribute === 'inert' ? '' : 'true');
+            }
+        });
+    }
+    if (mark) {
+        const targets = collectOutsideElements(body, buildKeepSet(avoid), new Set(avoid));
+        targets.forEach((node) => {
+            const count = (markerCounters.get(node) ?? 0) + 1;
+            markerCounters.set(node, count);
+            markedElements.push(node);
+            if (count === 1) {
+                node.setAttribute(RDX_FLOATING_MARKER, '');
+            }
+        });
+    }
+    lockCount += 1;
+    return () => {
+        if (controlAttribute) {
+            const counters = controlCounters[controlAttribute];
+            const preExisting = preExistingControlled[controlAttribute];
+            controlledElements.forEach((element) => {
+                const count = (counters.get(element) ?? 0) - 1;
+                counters.set(element, count);
+                if (count === 0) {
+                    if (!preExisting.has(element)) {
+                        element.removeAttribute(controlAttribute);
+                    }
+                    preExisting.delete(element);
+                }
+            });
+        }
+        markedElements.forEach((element) => {
+            const count = (markerCounters.get(element) ?? 0) - 1;
+            markerCounters.set(element, count);
+            if (count === 0) {
+                element.removeAttribute(RDX_FLOATING_MARKER);
+            }
+        });
+        lockCount -= 1;
+        if (lockCount === 0) {
+            // No active locks anywhere — drop the ref-count tables so detached elements can be GC'd.
+            controlCounters.inert = new WeakMap();
+            controlCounters['aria-hidden'] = new WeakMap();
+            preExistingControlled.inert = new WeakSet();
+            preExistingControlled['aria-hidden'] = new WeakSet();
+            markerCounters = new WeakMap();
+        }
+    };
+}
+
+/** Normalizes a DOM event into Base UI-like interaction intent for focus policy decisions. */
+function getInteractionTypeFromEvent(event) {
+    if (!event) {
+        return null;
+    }
+    if (typeof KeyboardEvent !== 'undefined' && event instanceof KeyboardEvent) {
+        return 'keyboard';
+    }
+    if ('pointerType' in event && typeof event.pointerType === 'string') {
+        return (event.pointerType || 'mouse');
+    }
+    if (typeof MouseEvent !== 'undefined' && event instanceof MouseEvent) {
+        return event.detail === 0 ? 'keyboard' : 'mouse';
+    }
+    return '';
+}
+/** Resolves an {@link RdxFocusTarget} (element | getter | null) to a concrete element. */
+function resolveFocusTarget(target) {
+    return typeof target === 'function' ? target() : target;
+}
+/**
+ * Resolves an {@link RdxInitialFocus} policy against how the popup opened.
+ */
+function resolveInitialFocus(policy, openInteractionType) {
+    const resolved = typeof policy === 'function' ? policy(openInteractionType) : policy;
+    return resolved === false ? false : resolveFocusTarget(resolved);
+}
+/**
+ * Resolves an {@link RdxReturnFocus} policy against how the popup closed. `false` = do not return focus;
+ * `true` = the default (return to the previously-focused element); an element = return there.
+ */
+function resolveReturnFocus(policy, closeInteractionType) {
+    const resolved = typeof policy === 'function' ? policy(closeInteractionType) : policy;
+    return typeof resolved === 'boolean' ? resolved : resolveFocusTarget(resolved);
+}
+const RDX_FLOATING_FOCUS_MANAGER_CONFIG = new InjectionToken('RdxFloatingFocusManagerConfig');
+/** Provides a {@link RdxFloatingFocusManagerConfig} for an enclosing primitive's focus manager. */
+function provideFloatingFocusManagerConfig(factory) {
+    return { provide: RDX_FLOATING_FOCUS_MANAGER_CONFIG, useFactory: factory };
+}
+/** Coerces a boolean-ish input while preserving `undefined` ("not set" → fall back to the config). */
+function coerceOptionalBoolean(value) {
+    return value === undefined ? undefined : booleanAttribute(value);
+}
+/**
+ * Provides a {@link RdxFocusScopeConfig} whose `trapped` is a **writable** signal, so the enclosing
+ * {@link RdxFloatingFocusManager} can drive it from its `modal`/`enabled` policy after construction. The
+ * factory has **no** dependency on the manager instance, so it cannot deadlock the host-directive
+ * construction order (the manager later injects this same config and writes the signal).
+ */
+function provideManagedFocusScopeConfig() {
+    return provideRdxFocusScopeConfig(() => ({ trapped: signal(false) }));
+}
+/**
+ * `RdxFloatingFocusManager` (ADR 0017 Phase 1b skeleton) — the Angular counterpart of Base UI's
+ * `FloatingFocusManager`. It is a **coordinator** that composes three low-level focus parts (it never
+ * inherits them, which would re-fuse trap + popup policy): the **reworked {@link RdxFocusScope}** (the
+ * trap, via `hostDirectives`), the portal-focus bridge, and owner-`Document` guards. Per ADR 0017 §1/§2
+ * its policies are **independent**, none derived from `modal`.
+ *
+ * **This skeleton wires the composition + lifecycle gates:**
+ * - `enabled` — the manager's active-ness (`mounted && !hover-open`). When off, **no trap** (and, later,
+ *   no aria-hidden / no marker — Phase 2).
+ * - `modal` → `RdxFocusScope.trapped`: the effective trap is `enabled() && modal()`, pushed into the
+ *   composed focus scope through its config token (the composition seam).
+ * - `loop` is forwarded to `RdxFocusScope`.
+ * - `initialFocus` / `returnFocus` are **orchestrated** here (the §2 policy contract, incl. the
+ *   interaction-type callback forms): `initialFocus` via the scope's `mountAutoFocus` hook, `returnFocus`
+ *   via the scope's `returnFocus` config seam (resolved at the scope's queued post-unmount frame).
+ */
+class RdxFloatingFocusManager {
+    constructor() {
+        /** Manager active-ness (ADR 0017 §2): the popup is mounted **and** not hover-opened. */
+        this.enabled = input(undefined, { ...(ngDevMode ? { debugName: "enabled" } : /* istanbul ignore next */ {}), transform: coerceOptionalBoolean });
+        /** Modal popup → focus trap. Combined with `enabled` to drive the composed `RdxFocusScope`. */
+        this.modal = input(undefined, { ...(ngDevMode ? { debugName: "modal" } : /* istanbul ignore next */ {}), transform: coerceOptionalBoolean });
+        /**
+         * Whether outside elements receive the real `inert` attribute. Defaults to the effective `modal` value,
+         * but primitives can split focus trapping from pointer/AT isolation (Base UI `modal="trap-focus"`).
+         */
+        this.inert = input(undefined, { ...(ngDevMode ? { debugName: "inert" } : /* istanbul ignore next */ {}), transform: coerceOptionalBoolean });
+        /** Where focus goes when the popup opens (ADR 0017 §2). */
+        this.initialFocus = input(undefined, ...(ngDevMode ? [{ debugName: "initialFocus" }] : /* istanbul ignore next */ []));
+        /** Where focus returns when the popup closes (ADR 0017 §2). */
+        this.returnFocus = input(undefined, ...(ngDevMode ? [{ debugName: "returnFocus" }] : /* istanbul ignore next */ []));
+        /**
+         * Restores focus inside the floating tree when the currently focused inside element is removed and
+         * the browser drops focus onto `<body>` (Base UI `restoreFocus`). `true` restores to the last
+         * available tabbable candidate, `'popup'` restores to the popup container.
+         */
+        this.restoreFocus = input(undefined, ...(ngDevMode ? [{ debugName: "restoreFocus" }] : /* istanbul ignore next */ []));
+        /** Overrides where backward tabbing out of a non-modal portaled popup lands. */
+        this.previousFocusableElement = input(undefined, ...(ngDevMode ? [{ debugName: "previousFocusableElement" }] : /* istanbul ignore next */ []));
+        /** Overrides where forward tabbing out of a non-modal portaled popup lands. */
+        this.nextFocusableElement = input(undefined, ...(ngDevMode ? [{ debugName: "nextFocusableElement" }] : /* istanbul ignore next */ []));
+        /** Optional callback/signal that receives the leading content focus guard. */
+        this.beforeContentFocusGuardRef = input(undefined, ...(ngDevMode ? [{ debugName: "beforeContentFocusGuardRef" }] : /* istanbul ignore next */ []));
+        /** Explicit floating tree for detached sibling composition (Base UI `externalTree`). */
+        this.externalTree = input(undefined, ...(ngDevMode ? [{ debugName: "externalTree" }] : /* istanbul ignore next */ []));
+        /** Additional elements treated as inside the floating subtree (Base UI `getInsideElements`). */
+        this.getInsideElements = input(undefined, ...(ngDevMode ? [{ debugName: "getInsideElements" }] : /* istanbul ignore next */ []));
+        /**
+         * Whether a **non-modal** popup closes when focus leaves to an unrelated node (Base UI
+         * `closeOnFocusOut`, default `true`; Dialog sets it to `!disablePointerDismissal`). Modal popups
+         * never close on focus-out (the trap keeps focus in).
+         */
+        this.closeOnFocusOut = input(undefined, { ...(ngDevMode ? { debugName: "closeOnFocusOut" } : /* istanbul ignore next */ {}), transform: coerceOptionalBoolean });
+        /**
+         * Emitted when focus leaves a non-modal popup to a node **unrelated** to the floating tree (ADR 0017
+         * §3) — the consumer should close the popup. This is the focus-manager's focus-out close (it reads
+         * the shared tree), replacing the dismissal capability's focus-out at the ADR 0015 Phase-4 cutover.
+         */
+        this.focusOut = output();
+        /** Optional DI config a composing primitive provides to drive the gates (input wins over config). */
+        this.config = inject(RDX_FLOATING_FOCUS_MANAGER_CONFIG, { optional: true });
+        /** Effective gates: `input ?? config ?? default`. */
+        this.effectiveEnabled = computed(() => this.enabled() ?? this.config?.enabled?.() ?? true, ...(ngDevMode ? [{ debugName: "effectiveEnabled" }] : /* istanbul ignore next */ []));
+        this.effectiveModal = computed(() => this.modal() ?? this.config?.modal?.() ?? false, ...(ngDevMode ? [{ debugName: "effectiveModal" }] : /* istanbul ignore next */ []));
+        this.effectiveInert = computed(() => this.inert() ?? this.config?.inert?.() ?? this.effectiveModal(), ...(ngDevMode ? [{ debugName: "effectiveInert" }] : /* istanbul ignore next */ []));
+        this.effectiveCloseOnFocusOut = computed(() => this.closeOnFocusOut() ?? this.config?.closeOnFocusOut?.() ?? true, ...(ngDevMode ? [{ debugName: "effectiveCloseOnFocusOut" }] : /* istanbul ignore next */ []));
+        this.effectiveInitialFocus = computed(() => this.initialFocus() !== undefined ? this.initialFocus() : (this.config?.initialFocus?.() ?? null), ...(ngDevMode ? [{ debugName: "effectiveInitialFocus" }] : /* istanbul ignore next */ []));
+        this.effectiveReturnFocus = computed(() => this.returnFocus() !== undefined ? this.returnFocus() : (this.config?.returnFocus?.() ?? true), ...(ngDevMode ? [{ debugName: "effectiveReturnFocus" }] : /* istanbul ignore next */ []));
+        this.effectiveRestoreFocus = computed(() => this.restoreFocus() ?? this.config?.restoreFocus?.() ?? false, ...(ngDevMode ? [{ debugName: "effectiveRestoreFocus" }] : /* istanbul ignore next */ []));
+        this.effectivePreviousFocusableElement = computed(() => this.previousFocusableElement() !== undefined
+            ? this.previousFocusableElement()
+            : this.config?.previousFocusableElement?.(), ...(ngDevMode ? [{ debugName: "effectivePreviousFocusableElement" }] : /* istanbul ignore next */ []));
+        this.effectiveNextFocusableElement = computed(() => this.nextFocusableElement() !== undefined ? this.nextFocusableElement() : this.config?.nextFocusableElement?.(), ...(ngDevMode ? [{ debugName: "effectiveNextFocusableElement" }] : /* istanbul ignore next */ []));
+        this.effectiveBeforeContentFocusGuardRef = computed(() => this.beforeContentFocusGuardRef() ?? this.config?.beforeContentFocusGuardRef?.(), ...(ngDevMode ? [{ debugName: "effectiveBeforeContentFocusGuardRef" }] : /* istanbul ignore next */ []));
+        this.effectiveExternalTree = computed(() => this.externalTree() ?? this.config?.externalTree?.() ?? null, ...(ngDevMode ? [{ debugName: "effectiveExternalTree" }] : /* istanbul ignore next */ []));
+        this.insideElements = computed(() => {
+            const getElements = this.getInsideElements() ?? this.config?.getInsideElements;
+            return (getElements?.() ?? []).filter((element) => element != null);
+        }, ...(ngDevMode ? [{ debugName: "insideElements" }] : /* istanbul ignore next */ []));
+        this.effectiveOpenInteractionType = computed(() => this.config?.openInteractionType?.() ?? this._interactionType(), ...(ngDevMode ? [{ debugName: "effectiveOpenInteractionType" }] : /* istanbul ignore next */ []));
+        this.effectiveCloseInteractionType = computed(() => this.config?.closeInteractionType?.() ?? this._interactionType(), ...(ngDevMode ? [{ debugName: "effectiveCloseInteractionType" }] : /* istanbul ignore next */ []));
+        /** The effective trap state the composed `RdxFocusScope` reads via its config token. */
+        this.trapped = computed(() => this.effectiveEnabled() && this.effectiveModal(), ...(ngDevMode ? [{ debugName: "trapped" }] : /* istanbul ignore next */ []));
+        // The config this directive provides — its `trapped` signal is writable so we can drive it, and we
+        // attach a `returnFocus` resolver the composed focus scope calls at unmount (ADR 0017 `returnFocus`).
+        this.focusScopeConfig = inject(RdxFocusScopeConfigToken);
+        this.host = inject(ElementRef).nativeElement;
+        this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        /** The shared per-popup context (open / triggers / elements), if a primitive root provides one. */
+        this.rootContext = inject(RDX_FLOATING_ROOT_CONTEXT, { optional: true });
+        /** The registration handle for this node, used to read the shared tree (ancestors / descendants). */
+        this.registration = inject(RDX_FLOATING_REGISTRATION, { optional: true });
+        this._interactionType = signal('', ...(ngDevMode ? [{ debugName: "_interactionType" }] : /* istanbul ignore next */ []));
+        /** How the popup was most recently interacted with — fed to the initial/return focus policy callbacks. */
+        this.interactionType = this._interactionType.asReadonly();
+        effect(() => this.focusScopeConfig.trapped.set(this.trapped()));
+        // Own the return-focus *target* (the composed focus scope owns the *timing*): the scope calls this
+        // in its queued post-unmount frame, resolving the `returnFocus` policy against the close interaction.
+        this.focusScopeConfig.returnFocus = () => this.resolveReturnFocusTarget();
+        if (!this.isBrowser) {
+            return; // SSR: no DOM marking / listeners.
+        }
+        // Marker pass (ADR 0017 §3) — applied to outside elements while the manager is active **and the
+        // popup is open**, independent of `modal`. Read by ADR 0015's outside-press guard.
+        effect((onCleanup) => {
+            if (!this.effectiveEnabled() || !this.isFloatingOpen()) {
+                return;
+            }
+            onCleanup(markOthers(this.avoidElements(), { ariaHidden: false, mark: true }));
+        });
+        // Pointer/AT isolation pass — apply the real `inert` attribute to outside elements only when the
+        // composing primitive asks for outside interaction to be blocked. This is intentionally separate from
+        // focus trapping: Base UI `modal="trap-focus"` traps focus but leaves outside pointer interaction
+        // enabled.
+        effect((onCleanup) => {
+            if (!this.effectiveEnabled() || !this.isFloatingOpen() || !this.effectiveInert()) {
+                return;
+            }
+            onCleanup(markOthers(this.avoidElements(), { inert: true, mark: false }));
+        });
+        this.trackInteractionType();
+        useFocusGuardsTabbability(() => (this.rootContext?.floatingElement ?? this.host), {
+            enabled: () => Boolean(this.rootContext) && this.effectiveEnabled() && this.isFloatingOpen() && !this.effectiveModal()
+        });
+        this.wireCloseOnFocusOut();
+        this.wireRestoreFocus();
+        this.wirePortalFocusBridge();
+        this.wireFocusOrchestration();
+        this.wireInitialFocusFallback();
+    }
+    /** Records the most recent open/close interaction (pointer type or keyboard) for the focus policies. */
+    trackInteractionType() {
+        const ownerDocument = this.host.ownerDocument;
+        const onPointer = (event) => {
+            this._interactionType.set((event.pointerType || 'mouse'));
+        };
+        const onKey = () => this._interactionType.set('keyboard');
+        ownerDocument.addEventListener('pointerdown', onPointer, true);
+        ownerDocument.addEventListener('keydown', onKey, true);
+        inject(DestroyRef).onDestroy(() => {
+            ownerDocument.removeEventListener('pointerdown', onPointer, true);
+            ownerDocument.removeEventListener('keydown', onKey, true);
+        });
+    }
+    /**
+     * Initial-focus orchestration (ADR 0017 §2). The manager owns the focus *policy*; it intercepts the
+     * composed {@link RdxFocusScope}'s preventable `mountAutoFocus` (its designed extension point) and
+     * applies the `initialFocus` policy, falling back to the scope's first-tabbable default when the
+     * policy is `null`. (`returnFocus` is orchestrated separately via the config seam — see
+     * {@link resolveReturnFocusTarget} — because it must run during the scope's queued *post-unmount* frame.)
+     */
+    wireFocusOrchestration() {
+        const focusScope = inject(RdxFocusScope);
+        focusScope.mountAutoFocus.subscribe((event) => {
+            const interactionType = this.effectiveOpenInteractionType();
+            const target = resolveInitialFocus(this.effectiveInitialFocus(), interactionType) ??
+                this.defaultInitialFocus(interactionType);
+            if (target === false) {
+                event.preventDefault();
+                return;
+            }
+            if (target) {
+                event.preventDefault(); // override the scope's first-tabbable default
+                target.focus();
+            }
+        });
+    }
+    /**
+     * Resolves the {@link returnFocus} policy against the **close** interaction type for the composed
+     * focus scope to apply at unmount (ADR 0017 §2). Mirrors Base UI's `getReturnElement`:
+     * - `false` → `false` (the scope suppresses return-focus);
+     * - `true` / `null` → `undefined` (the scope's default — return to the element focused before mount);
+     * - an element (direct or from a callback) → that element (returned **explicitly**, bypassing the
+     *   "focus moved elsewhere" guard).
+     */
+    resolveReturnFocusTarget() {
+        const resolved = resolveReturnFocus(this.effectiveReturnFocus(), this.effectiveCloseInteractionType());
+        if (resolved === false) {
+            return false;
+        }
+        if (resolved === undefined) {
+            return false;
+        }
+        if (resolved === true || resolved == null) {
+            return undefined;
+        }
+        return resolved;
+    }
+    /**
+     * Base UI's `defaultInitialFocus`: on a **touch** open, focus the popup itself instead of its first
+     * tabbable control, so a soft keyboard (Android) does not pop up over the popup. Any other interaction
+     * returns `null`, keeping the focus scope's first-tabbable default. The popup is made programmatically
+     * focusable (`tabindex="-1"`) if it isn't already.
+     */
+    defaultInitialFocus(interactionType) {
+        if (interactionType !== 'touch') {
+            return null;
+        }
+        const popup = (this.rootContext?.floatingElement ?? this.host);
+        if (!popup.hasAttribute('tabindex')) {
+            popup.setAttribute('tabindex', '-1');
+        }
+        return popup;
+    }
+    /**
+     * Manager-owned post-open fallback. Some popup types open from a trigger event that fired before the
+     * manager existed, and some policies resolve their final target only after a couple of renders. Re-run
+     * the initial-focus policy for a few animation frames while the popup is open so the target can settle.
+     */
+    wireInitialFocusFallback() {
+        effect(() => {
+            if (!this.effectiveEnabled() || !this.isFloatingOpen()) {
+                return;
+            }
+            this.scheduleInitialFocusFallback();
+        });
+    }
+    scheduleInitialFocusFallback(attempt = 0) {
+        const view = this.host.ownerDocument.defaultView ?? globalThis;
+        view.requestAnimationFrame(() => this.applyInitialFocusFallback(attempt));
+    }
+    applyInitialFocusFallback(attempt) {
+        if (!this.effectiveEnabled() || !this.isFloatingOpen()) {
+            return;
+        }
+        const popup = (this.rootContext?.floatingElement ?? this.host);
+        const activeElement = this.host.ownerDocument.activeElement;
+        if (activeElement instanceof HTMLElement && popup.contains(activeElement)) {
+            return;
+        }
+        const interactionType = this.effectiveOpenInteractionType();
+        const resolved = resolveInitialFocus(this.effectiveInitialFocus(), interactionType);
+        if (resolved === false) {
+            return;
+        }
+        const target = resolved ?? this.defaultInitialFocus(interactionType);
+        if (target && activeElement !== target) {
+            target.focus({ preventScroll: true });
+        }
+        if (attempt < 2) {
+            this.scheduleInitialFocusFallback(attempt + 1);
+        }
+    }
+    /**
+     * Close-on-focus-out (ADR 0017 §3): a **non-modal** active popup closes when focus moves to a node
+     * unrelated to the floating tree — not the popup, its trigger(s), a focus guard, or an ancestor /
+     * descendant popup — and not during a pointer press (a drag must not close it). Mirrors Base UI's
+     * `FloatingFocusManager` `!modal` branch (`movedToUnrelatedNode`).
+     */
+    wireCloseOnFocusOut() {
+        const ownerDocument = this.host.ownerDocument;
+        let pointerDown = false;
+        const onPointerDown = () => {
+            pointerDown = true;
+        };
+        const onPointerUp = () => {
+            pointerDown = false;
+        };
+        const onFocusOut = (event) => {
+            if (!this.effectiveEnabled() || !this.effectiveCloseOnFocusOut() || this.effectiveModal() || pointerDown) {
+                return;
+            }
+            const relatedTarget = event.relatedTarget;
+            if (!relatedTarget) {
+                return; // focus left to nothing (tab-away / window blur) — let the browser handle it
+            }
+            if (relatedTarget instanceof Element && relatedTarget.hasAttribute(FOCUS_GUARD_ATTR)) {
+                return; // moved onto a focus guard — still inside the focus system
+            }
+            if (this.isRelatedTargetInside(relatedTarget)) {
+                return; // moved to a related node (trigger / ancestor / descendant) — keep open
+            }
+            this.focusOut.emit(event);
+        };
+        ownerDocument.addEventListener('pointerdown', onPointerDown, true);
+        ownerDocument.addEventListener('pointerup', onPointerUp, true);
+        ownerDocument.addEventListener('focusout', onFocusOut, true);
+        inject(DestroyRef).onDestroy(() => {
+            ownerDocument.removeEventListener('pointerdown', onPointerDown, true);
+            ownerDocument.removeEventListener('pointerup', onPointerUp, true);
+            ownerDocument.removeEventListener('focusout', onFocusOut, true);
+        });
+    }
+    /**
+     * Restore focus when an inside focused element disappears and the document focus falls back to
+     * `<body>`. This mirrors the practical Base UI `restoreFocus` path used by Select while keeping the
+     * broader portal-guard navigation separate.
+     */
+    wireRestoreFocus() {
+        const ownerDocument = this.host.ownerDocument;
+        const onFocusOut = (event) => {
+            if (!this.effectiveEnabled() || !this.effectiveRestoreFocus() || !this.isFloatingOpen()) {
+                return;
+            }
+            const target = event.target;
+            if (!target || !this.isRelatedTargetInside(target)) {
+                return;
+            }
+            const view = ownerDocument.defaultView ?? globalThis;
+            view.requestAnimationFrame(() => {
+                if (!this.effectiveEnabled() || !this.effectiveRestoreFocus() || !this.isFloatingOpen()) {
+                    return;
+                }
+                if (ownerDocument.activeElement !== ownerDocument.body) {
+                    return;
+                }
+                const popup = this.rootContext?.floatingElement ?? this.host;
+                const targetToFocus = this.effectiveRestoreFocus() === 'popup' ? popup : (getTabbableCandidates(popup).at(-1) ?? popup);
+                focus(targetToFocus);
+            });
+        };
+        ownerDocument.addEventListener('focusout', onFocusOut, true);
+        inject(DestroyRef).onDestroy(() => ownerDocument.removeEventListener('focusout', onFocusOut, true));
+    }
+    /**
+     * Portal focus bridge (Base UI inside guards): when focus reaches the hidden guards around portaled
+     * content, redirect it either back inside the popup or to the configured neighboring tabbable node.
+     */
+    wirePortalFocusBridge() {
+        effect((onCleanup) => {
+            if (!this.effectiveEnabled() || !this.isFloatingOpen()) {
+                this.setBeforeContentFocusGuardRef(null);
+                return;
+            }
+            const ownerDocument = this.host.ownerDocument;
+            const parent = this.host.parentNode;
+            if (!parent) {
+                return;
+            }
+            const beforeGuard = createFocusGuard(ownerDocument);
+            const afterGuard = createFocusGuard(ownerDocument);
+            beforeGuard.setAttribute('data-type', 'inside');
+            afterGuard.setAttribute('data-type', 'inside');
+            parent.insertBefore(beforeGuard, this.host);
+            parent.insertBefore(afterGuard, this.host.nextSibling);
+            this.setBeforeContentFocusGuardRef(beforeGuard);
+            const onBeforeFocus = (event) => {
+                if (this.effectiveModal()) {
+                    focus(this.getTabbableContent().at(-1) ?? this.host);
+                    return;
+                }
+                if (this.isFromOutsideFocusGuard(event)) {
+                    const popup = this.rootContext?.floatingElement ?? this.host;
+                    enableFocusInside(popup);
+                    focus(this.getTabbableContent()[0] ?? this.host);
+                    return;
+                }
+                if (isOutsideEvent(event, this.portalFocusContainer())) {
+                    focus(getNextTabbable(this.rootContext?.referenceElement ?? this.host));
+                    return;
+                }
+                focus(resolveFocusTarget(this.effectivePreviousFocusableElement()) ?? this.defaultPreviousFocusable());
+            };
+            const onAfterFocus = (event) => {
+                if (this.effectiveModal()) {
+                    focus(this.getTabbableContent()[0] ?? this.host);
+                    return;
+                }
+                if (isOutsideEvent(event, this.portalFocusContainer())) {
+                    focus(getPreviousTabbable(this.rootContext?.referenceElement ?? this.host));
+                    return;
+                }
+                focus(resolveFocusTarget(this.effectiveNextFocusableElement()) ?? this.defaultNextFocusable());
+            };
+            beforeGuard.addEventListener('focus', onBeforeFocus);
+            afterGuard.addEventListener('focus', onAfterFocus);
+            onCleanup(() => {
+                beforeGuard.removeEventListener('focus', onBeforeFocus);
+                afterGuard.removeEventListener('focus', onAfterFocus);
+                beforeGuard.remove();
+                afterGuard.remove();
+                this.setBeforeContentFocusGuardRef(null);
+            });
+        });
+    }
+    /**
+     * The marker keep-set is intentionally narrow: the popup/focus host only. Own sibling roots such as a
+     * user backdrop are DOM-footprint bookkeeping, not marker keep-set members.
+     */
+    avoidElements() {
+        return [
+            this.host,
+            ...this.insideElements(),
+            resolveFocusTarget(this.effectivePreviousFocusableElement()) ?? null,
+            resolveFocusTarget(this.effectiveNextFocusableElement()) ?? null
+        ].filter((element) => element != null);
+    }
+    isFloatingOpen() {
+        return this.rootContext?.open() ?? true;
+    }
+    /** Whether `relatedTarget` is inside the popup, its trigger(s), or an ancestor / descendant popup. */
+    isRelatedTargetInside(relatedTarget) {
+        const floating = this.rootContext?.floatingElement ?? this.host;
+        if (composedContains(floating, relatedTarget)) {
+            return true;
+        }
+        if (this.rootContext && this.contextContains(this.rootContext, relatedTarget)) {
+            return true;
+        }
+        if (this.insideElements().some((element) => element === relatedTarget || composedContains(element, relatedTarget))) {
+            return true;
+        }
+        const node = this.currentFloatingNode();
+        if (node) {
+            for (const ancestor of node.tree.ancestors(node)) {
+                if (ancestor.context && this.contextContains(ancestor.context, relatedTarget)) {
+                    return true;
+                }
+            }
+            for (const child of node.tree.children(node, { onlyOpen: true })) {
+                if (child.context && this.contextContains(child.context, relatedTarget)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    contextContains(context, relatedTarget) {
+        if (context.floatingElement && composedContains(context.floatingElement, relatedTarget)) {
+            return true;
+        }
+        if (context.referenceElement && composedContains(context.referenceElement, relatedTarget)) {
+            return true;
+        }
+        return context.triggers.contains(relatedTarget);
+    }
+    currentFloatingNode() {
+        const node = this.registration?.node() ?? null;
+        if (node) {
+            return node;
+        }
+        const tree = this.effectiveExternalTree();
+        return tree?.all.find((candidate) => candidate.context === this.rootContext) ?? null;
+    }
+    getTabbableContent() {
+        return getTabbableCandidates(this.rootContext?.floatingElement ?? this.host);
+    }
+    portalFocusContainer() {
+        const floating = this.rootContext?.floatingElement ?? this.host;
+        const parent = floating.parentElement;
+        return parent && parent !== floating.ownerDocument.body ? parent : floating;
+    }
+    defaultPreviousFocusable() {
+        return getPreviousTabbable(this.rootContext?.referenceElement ?? this.host);
+    }
+    defaultNextFocusable() {
+        return getNextTabbable(this.rootContext?.referenceElement ?? this.host);
+    }
+    setBeforeContentFocusGuardRef(element) {
+        const ref = this.effectiveBeforeContentFocusGuardRef();
+        if (!ref) {
+            return;
+        }
+        if (typeof ref === 'function') {
+            ref(element);
+        }
+        else {
+            ref.set(element);
+        }
+    }
+    isFromOutsideFocusGuard(event) {
+        const relatedTarget = event.relatedTarget;
+        return (relatedTarget instanceof Element &&
+            relatedTarget.hasAttribute(FOCUS_GUARD_ATTR) &&
+            relatedTarget.getAttribute('data-type') === 'outside');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFloatingFocusManager, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: RdxFloatingFocusManager, isStandalone: true, selector: "[rdxFloatingFocusManager]", inputs: { enabled: { classPropertyName: "enabled", publicName: "enabled", isSignal: true, isRequired: false, transformFunction: null }, modal: { classPropertyName: "modal", publicName: "modal", isSignal: true, isRequired: false, transformFunction: null }, inert: { classPropertyName: "inert", publicName: "inert", isSignal: true, isRequired: false, transformFunction: null }, initialFocus: { classPropertyName: "initialFocus", publicName: "initialFocus", isSignal: true, isRequired: false, transformFunction: null }, returnFocus: { classPropertyName: "returnFocus", publicName: "returnFocus", isSignal: true, isRequired: false, transformFunction: null }, restoreFocus: { classPropertyName: "restoreFocus", publicName: "restoreFocus", isSignal: true, isRequired: false, transformFunction: null }, previousFocusableElement: { classPropertyName: "previousFocusableElement", publicName: "previousFocusableElement", isSignal: true, isRequired: false, transformFunction: null }, nextFocusableElement: { classPropertyName: "nextFocusableElement", publicName: "nextFocusableElement", isSignal: true, isRequired: false, transformFunction: null }, beforeContentFocusGuardRef: { classPropertyName: "beforeContentFocusGuardRef", publicName: "beforeContentFocusGuardRef", isSignal: true, isRequired: false, transformFunction: null }, externalTree: { classPropertyName: "externalTree", publicName: "externalTree", isSignal: true, isRequired: false, transformFunction: null }, getInsideElements: { classPropertyName: "getInsideElements", publicName: "getInsideElements", isSignal: true, isRequired: false, transformFunction: null }, closeOnFocusOut: { classPropertyName: "closeOnFocusOut", publicName: "closeOnFocusOut", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { focusOut: "focusOut" }, providers: [provideManagedFocusScopeConfig()], exportAs: ["rdxFloatingFocusManager"], hostDirectives: [{ directive: i1.RdxFocusScope, inputs: ["loop", "loop"] }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RdxFloatingFocusManager, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rdxFloatingFocusManager]',
+                    exportAs: 'rdxFloatingFocusManager',
+                    hostDirectives: [{ directive: RdxFocusScope, inputs: ['loop'] }],
+                    providers: [provideManagedFocusScopeConfig()]
+                }]
+        }], ctorParameters: () => [], propDecorators: { enabled: [{ type: i0.Input, args: [{ isSignal: true, alias: "enabled", required: false }] }], modal: [{ type: i0.Input, args: [{ isSignal: true, alias: "modal", required: false }] }], inert: [{ type: i0.Input, args: [{ isSignal: true, alias: "inert", required: false }] }], initialFocus: [{ type: i0.Input, args: [{ isSignal: true, alias: "initialFocus", required: false }] }], returnFocus: [{ type: i0.Input, args: [{ isSignal: true, alias: "returnFocus", required: false }] }], restoreFocus: [{ type: i0.Input, args: [{ isSignal: true, alias: "restoreFocus", required: false }] }], previousFocusableElement: [{ type: i0.Input, args: [{ isSignal: true, alias: "previousFocusableElement", required: false }] }], nextFocusableElement: [{ type: i0.Input, args: [{ isSignal: true, alias: "nextFocusableElement", required: false }] }], beforeContentFocusGuardRef: [{ type: i0.Input, args: [{ isSignal: true, alias: "beforeContentFocusGuardRef", required: false }] }], externalTree: [{ type: i0.Input, args: [{ isSignal: true, alias: "externalTree", required: false }] }], getInsideElements: [{ type: i0.Input, args: [{ isSignal: true, alias: "getInsideElements", required: false }] }], closeOnFocusOut: [{ type: i0.Input, args: [{ isSignal: true, alias: "closeOnFocusOut", required: false }] }], focusOut: [{ type: i0.Output, args: ["focusOut"] }] } });
+
+/**
+ * Shared trigger state for floating primitives. It intentionally stays small: each primitive still owns
+ * its open/close business rules, while this layer normalizes active-trigger state and the open method
+ * signal that must be captured before the popup/focus manager mounts.
+ */
+function createRdxTriggerInteraction(options) {
+    const lastPointerType = signal('', ...(ngDevMode ? [{ debugName: "lastPointerType" }] : /* istanbul ignore next */ []));
+    const activeTrigger = options.activeTrigger ?? (() => options.trigger());
+    const disabled = computed(() => options.disabled?.() ?? false, ...(ngDevMode ? [{ debugName: "disabled" }] : /* istanbul ignore next */ []));
+    const isActive = computed(() => options.open() && activeTrigger() === options.trigger(), ...(ngDevMode ? [{ debugName: "isActive" }] : /* istanbul ignore next */ []));
+    const dataState = computed(() => (options.open() ? 'open' : 'closed'), ...(ngDevMode ? [{ debugName: "dataState" }] : /* istanbul ignore next */ []));
+    const dataPopupOpen = computed(() => (isActive() ? '' : undefined), ...(ngDevMode ? [{ debugName: "dataPopupOpen" }] : /* istanbul ignore next */ []));
+    const ariaControls = computed(() => (isActive() ? (options.contentId?.() ?? undefined) : undefined), ...(ngDevMode ? [{ debugName: "ariaControls" }] : /* istanbul ignore next */ []));
+    const ariaExpanded = computed(() => isActive(), ...(ngDevMode ? [{ debugName: "ariaExpanded" }] : /* istanbul ignore next */ []));
+    return {
+        lastPointerType: lastPointerType.asReadonly(),
+        isActive,
+        isInactive: computed(() => !isActive()),
+        dataState,
+        dataPopupOpen,
+        ariaControls,
+        ariaExpanded,
+        disabled,
+        recordPointerDown: (event) => {
+            lastPointerType.set(event.pointerType);
+        },
+        clickInteractionType: (event) => {
+            if (event.detail !== 0 && lastPointerType() === 'touch') {
+                return 'touch';
+            }
+            return getInteractionTypeFromEvent(event);
+        }
+    };
+}
+/**
+ * Adds Base UI's trigger-side focus guards for portaled content. The content guards remain owned by
+ * `RdxFloatingFocusManager`; these guards bridge tab order from the trigger into the portal and close the
+ * popup when focus leaves past either trigger-side boundary.
+ */
+function useTriggerFocusGuards(options) {
+    const enabled = options.enabled ?? (() => true);
+    effect((onCleanup) => {
+        if (!enabled()) {
+            return;
+        }
+        const trigger = options.trigger();
+        const preGuard = createFocusGuard(trigger.ownerDocument);
+        const postGuard = createFocusGuard(trigger.ownerDocument);
+        preGuard.setAttribute('data-type', 'outside');
+        postGuard.setAttribute('data-type', 'outside');
+        const contentId = options.contentId?.();
+        const anchor = contentId ? createAriaOwnsAnchor(trigger.ownerDocument, contentId) : null;
+        const handlePreGuardFocus = (event) => {
+            const previousTabbable = getTabbableBeforeElement(preGuard);
+            options.close(event);
+            focus(previousTabbable);
+        };
+        const handlePostGuardFocus = (event) => {
+            const popup = options.popupElement?.() ?? null;
+            const beforeContentGuard = options.beforeContentFocusGuard?.() ?? null;
+            if (popup && beforeContentGuard && isOutsideEvent(event, popup)) {
+                focus(beforeContentGuard);
+                return;
+            }
+            let nextTabbable = getTabbableAfterElement(postGuard);
+            while (nextTabbable &&
+                (nextTabbable.hasAttribute(FOCUS_GUARD_ATTR) || (popup && composedContains(popup, nextTabbable)))) {
+                const previous = nextTabbable;
+                nextTabbable = getTabbableAfterElement(nextTabbable);
+                if (nextTabbable === previous) {
+                    break;
+                }
+            }
+            options.close(event);
+            focus(nextTabbable);
+        };
+        preGuard.addEventListener('focus', handlePreGuardFocus);
+        postGuard.addEventListener('focus', handlePostGuardFocus);
+        trigger.insertAdjacentElement('beforebegin', preGuard);
+        if (anchor) {
+            trigger.insertAdjacentElement('afterend', anchor);
+            anchor.insertAdjacentElement('afterend', postGuard);
+        }
+        else {
+            trigger.insertAdjacentElement('afterend', postGuard);
+        }
+        onCleanup(() => {
+            preGuard.removeEventListener('focus', handlePreGuardFocus);
+            postGuard.removeEventListener('focus', handlePostGuardFocus);
+            preGuard.remove();
+            postGuard.remove();
+            anchor?.remove();
+        });
+    });
+}
+/**
+ * Backwards-compatible aria-owns-only bridge for modal popups that do not need trigger-side tab guards.
+ */
+function useTriggerFocusGuardAnchor(options) {
+    const enabled = options.enabled ?? (() => true);
+    effect((onCleanup) => {
+        const contentId = options.contentId();
+        if (!enabled() || !contentId) {
+            return;
+        }
+        const trigger = options.trigger();
+        const anchor = createAriaOwnsAnchor(trigger.ownerDocument, contentId);
+        trigger.insertAdjacentElement('afterend', anchor);
+        onCleanup(() => anchor.remove());
+    });
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { RDX_FLOATING_FOCUS_MANAGER_CONFIG, RDX_FLOATING_MARKER, RdxFloatingFocusManager, createRdxTriggerInteraction, getInteractionTypeFromEvent, provideFloatingFocusManagerConfig, resolveFocusTarget, resolveInitialFocus, resolveReturnFocus, useTriggerFocusGuardAnchor, useTriggerFocusGuards };
+//# sourceMappingURL=radix-ng-primitives-floating-focus-manager.mjs.map