stimeo-ui 0.15.0 → 0.17.0

package/dist/controllers/navigation_menu_controller.d.ts

@@ -73,6 +73,16 @@ import { Controller } from '@hotwired/stimulus';
  * delegated to the opt-in `stimeo-ui/positioning` module (never imported here, so
  * the core stays zero-dependency). For an app command menu with arrow roving and
  * `role="menu"`, use `stimeo--menubar` instead.
+ *
+ * Each move of a panel's open state is reported: `stimeo--navigation-menu:open`
+ * and `stimeo--navigation-menu:close` dispatch
+ * `{ reason: StateReason, index: number, panel: HTMLElement }` — `index` is the
+ * trigger's position in `triggerTargets` — after the state attributes are
+ * written. Both are informational, so neither is cancelable. Switching panels
+ * reports the outgoing `close` before the incoming `open`, both with the reason
+ * that drove the switch. A call that leaves a panel where it already was, the
+ * normalization in {@link connect}, target churn, and {@link disconnect} are all
+ * silent.
  */
 declare class NavigationMenuController extends Controller<HTMLElement> {
     #private;
@@ -87,7 +97,15 @@ declare class NavigationMenuController extends Controller<HTMLElement> {
             default: number;
         };
     };
+    static valueConstraints: {
+        hoverDelay: {
+            readonly finite: true;
+            readonly min: 0;
+            readonly max: 2147483647;
+        };
+    };
     static actions: readonly ["onTriggerKeydown", "toggle"];
+    static events: readonly ["close", "open"];
     readonly triggerTargets: HTMLElement[];
     readonly panelTargets: HTMLElement[];
     readonly hoverAreaTargets: HTMLElement[];
@@ -129,7 +147,7 @@ declare class NavigationMenuController extends Controller<HTMLElement> {
      * activation (pointer elsewhere) still toggles it closed, and `Escape` and
      * outside clicks dismiss either way.
      */
-    toggle(event: Event): void;
+    toggle(source: Event | HTMLElement): void;
     /**
      * `ArrowLeft`/`ArrowRight` move focus between triggers (keeping Tab order).
      *

package/dist/controllers/navigation_menu_controller.js

@@ -1,19 +1,46 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/navigation_menu_controller.ts
+var FOCUS_EVENTS = /* @__PURE__ */ new Set(["blur", "focus", "focusin", "focusout"]);
+var POINTER_EVENTS = /* @__PURE__ */ new Set(["mouseenter", "mouseleave", "pointerenter", "pointerleave"]);
+function stateReasonFor(event) {
+  if (!event) return "api";
+  if (FOCUS_EVENTS.has(event.type)) return "focus";
+  if (POINTER_EVENTS.has(event.type)) return "pointer";
+  return "user";
+}
+
+function actionSource(source) {
+  if (source instanceof HTMLElement) {
+    return { event: null, host: source, origin: source, reason: "api" };
+  }
+  const event = source ?? null;
+  return {
+    event,
+    host: event?.currentTarget instanceof Element ? event.currentTarget : null,
+    origin: event?.target instanceof Element ? event.target : null,
+    reason: stateReasonFor(event)
+  };
+}
 
-// src/utils/logical_scroll.ts
 function isRtl(element) {
   return window.getComputedStyle(element).direction === "rtl";
 }
 
-// src/utils/arrow_step.ts
 function isReservedArrowChord(event, allow = []) {
   if (!event.key.startsWith("Arrow")) return false;
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
 
-// src/utils/escape_layer.ts
+function sharedRegistry(key, create) {
+  const symbol = Symbol.for(key);
+  const scope = globalThis;
+  const existing = scope[symbol];
+  if (existing !== void 0) return existing;
+  const registry = create();
+  Object.defineProperty(globalThis, symbol, { value: registry });
+  return registry;
+}
+
 function claimsWhileFocusWithin(element) {
   return () => {
     const active = element.ownerDocument.activeElement;
@@ -21,17 +48,11 @@ function claimsWhileFocusWithin(element) {
   };
 }
 var EscapeLayer = class _EscapeLayer {
-  static #registries = /* @__PURE__ */ new WeakMap();
-  #ownerDocument = null;
-  /** Dismissal callback while active; `null` when inactive. */
-  #onDismiss = null;
-  /** Live predicate deciding whether the layer claims a press; `null` = always. */
-  #claims = null;
-  /**
-   * Activates this layer at the top of its document's Escape stack, installing
-   * the document's shared resolver listener if this is its first layer.
-   * Re-activating an already-active layer moves it to the top.
-   */
+  static #registries = sharedRegistry(
+    "stimeo-ui.escape-layer.registry.v1",
+    () => /* @__PURE__ */ new WeakMap()
+  );
+  #active = null;
   activate(ownerDocument = document, options) {
     this.deactivate();
     let registry = _EscapeLayer.#registries.get(ownerDocument);
@@ -40,44 +61,31 @@ var EscapeLayer = class _EscapeLayer {
       _EscapeLayer.#registries.set(ownerDocument, registry);
       ownerDocument.addEventListener("keydown", registry.onKeydown);
     }
-    registry.stack.push(this);
-    this.#ownerDocument = ownerDocument;
-    this.#onDismiss = options.onDismiss;
-    this.#claims = options.claims ?? null;
-  }
-  /**
-   * Removes this layer from its document's Escape stack, uninstalling the
-   * shared listener when the stack empties. Safe to call when inactive.
-   */
+    const entry = { onDismiss: options.onDismiss, claims: options.claims ?? null };
+    registry.stack.push(entry);
+    this.#active = { document: ownerDocument, entry };
+  }
   deactivate() {
-    const ownerDocument = this.#ownerDocument;
-    if (!ownerDocument) return;
-    const registry = _EscapeLayer.#registries.get(ownerDocument);
+    const active = this.#active;
+    if (!active) return;
+    const registry = _EscapeLayer.#registries.get(active.document);
     if (registry) {
-      const index = registry.stack.lastIndexOf(this);
+      const index = registry.stack.lastIndexOf(active.entry);
       if (index >= 0) registry.stack.splice(index, 1);
       if (registry.stack.length === 0) {
-        ownerDocument.removeEventListener("keydown", registry.onKeydown);
-        _EscapeLayer.#registries.delete(ownerDocument);
+        active.document.removeEventListener("keydown", registry.onKeydown);
+        _EscapeLayer.#registries.delete(active.document);
       }
     }
-    this.#ownerDocument = null;
-    this.#onDismiss = null;
-    this.#claims = null;
-  }
-  /**
-   * Whether this active layer would own a press right now: it is the topmost
-   * layer whose {@link EscapeLayerOptions.claims} passes. Exposed for tests
-   * and diagnostics — production dismissal goes through the shared listener.
-   */
+    this.#active = null;
+  }
   get ownsEscape() {
-    const ownerDocument = this.#ownerDocument;
-    if (!ownerDocument) return false;
-    const registry = _EscapeLayer.#registries.get(ownerDocument);
+    const active = this.#active;
+    if (!active) return false;
+    const registry = _EscapeLayer.#registries.get(active.document);
     if (!registry) return false;
-    return _EscapeLayer.#resolveOwner(registry.stack) === this;
+    return _EscapeLayer.#resolveOwner(registry.stack) === active.entry;
   }
-  /** Builds a document's registry with its shared resolver listener. */
   static #createRegistry() {
     const registry = {
       stack: [],
@@ -86,66 +94,91 @@ var EscapeLayer = class _EscapeLayer {
         const owner = _EscapeLayer.#resolveOwner(registry.stack);
         if (!owner) return;
         event.preventDefault();
-        owner.#onDismiss?.();
+        owner.onDismiss();
       }
     };
     return registry;
   }
-  /** The topmost stack layer whose claims predicate passes, or `null`. */
   static #resolveOwner(stack) {
     for (let index = stack.length - 1; index >= 0; index--) {
       const layer = stack[index];
       if (!layer) continue;
-      if (layer.#claims && !layer.#claims()) continue;
+      if (layer.claims && !layer.claims()) continue;
       return layer;
     }
     return null;
   }
 };
 
-// src/utils/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
 }
 
-// src/utils/safe_timeout.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
+
+var NUMBER_BOUNDS = {
+  timer: { finite: true, min: 0, max: MAX_TIMER_DELAY_MS }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
+
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+var NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 var TimerRegistry = class {
-  /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
   ids = /* @__PURE__ */ new Set();
-  /**
-   * Cancels a single tracked timer.
-   *
-   * No-ops if the id is unknown (already cleared, fired, or never owned by this
-   * registry), so callers can clear defensively without guarding.
-   */
   clear(id) {
     if (this.ids.delete(id)) {
       this.cancel(id);
     }
   }
-  /**
-   * Cancels every tracked timer. Call this from a controller's `disconnect()`
-   * to guarantee no timer outlives the element.
-   */
   clearAll() {
     for (const id of this.ids) {
       this.cancel(id);
     }
     this.ids.clear();
   }
-  /** Number of timers currently tracked (pending). */
   get size() {
     return this.ids.size;
   }
 };
 var SafeTimeout = class extends TimerRegistry {
-  /**
-   * Schedules `callback` after `delay` ms and returns the timer id.
-   *
-   * The id is removed from the registry automatically when the timeout fires,
-   * so {@link TimerRegistry.size | size} reflects only still-pending timers.
-   */
   set(callback, delay) {
     const id = this.schedule(() => {
       this.ids.delete(id);
@@ -162,121 +195,82 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/controllers/navigation_menu_controller.ts
-var NavigationMenuController = class extends Controller {
+function targetSelector(identifier, name) {
+  return `[data-${identifier}-target~="${name}"]`;
+}
+
+var NavigationMenuController = class _NavigationMenuController extends Controller {
+  #numbers = new NumberValueReader();
   static targets = ["trigger", "panel", "hoverArea"];
   static values = {
     openOnHover: { type: Boolean, default: false },
     hoverDelay: { type: Number, default: 150 }
   };
+  static valueConstraints = {
+    hoverDelay: NUMBER_BOUNDS.timer
+  };
   static actions = ["onTriggerKeydown", "toggle"];
-  /** Open/close delay timers for hover mode; cleared together on disconnect. */
+  static events = ["close", "open"];
   #hoverTimers = new SafeTimeout();
-  /**
-   * Elements currently carrying hover listeners. Removal always mirrors this
-   * set (not a recomputed target snapshot), so a rebuild driven by target churn
-   * can never strand a listener on an element that stopped being a target.
-   */
   #hoverWired = /* @__PURE__ */ new Set();
-  /**
-   * The trigger whose hover region the pointer currently occupies, if any. Only
-   * the click semantics under `openOnHover` read it (see {@link toggle}).
-   */
   #hoveredTrigger = null;
-  /**
-   * Whether the controller is between `connect()` and `disconnect()`. Stimulus
-   * disconnects the controller **before** disconnecting its targets, so the
-   * target callbacks below also fire during teardown; without this flag their
-   * rebuild would re-wire hover listeners onto an already-disconnected nav.
-   */
   #connected = false;
-  /** Escape-stack membership while any panel is open; the shared resolver dismisses via it. */
+  #reporting = false;
   #escapeLayer = new EscapeLayer();
-  /** Establishes the closed baseline and the dismissal listeners. */
   connect() {
     this.#connected = true;
-    this.#closeAll();
+    this.#closeAll("api");
     document.addEventListener("click", this.#onOutsideClick, true);
     this.element.addEventListener("focusout", this.#onFocusOut);
     if (this.openOnHoverValue) this.#addHoverListeners();
+    this.#reporting = true;
   }
-  /** Removes every listener, pending hover timer, and stack membership taken while connected. */
   disconnect() {
     this.#connected = false;
+    this.#reporting = false;
     this.#escapeLayer.deactivate();
     document.removeEventListener("click", this.#onOutsideClick, true);
     this.element.removeEventListener("focusout", this.#onFocusOut);
     this.#removeHoverListeners();
     this.#hoverTimers.clearAll();
   }
-  /**
-   * Follows a runtime flip of `openOnHover` (a morph or a scripted attribute
-   * change) by wiring or unwiring the hover listeners in place. Stimulus also
-   * fires this once before `connect()`, which the `#connected` guard skips —
-   * `connect()` owns the initial wiring.
-   */
   openOnHoverValueChanged() {
     if (!this.#connected) return;
     if (this.openOnHoverValue) this.#addHoverListeners();
     else this.#removeHoverListeners();
   }
-  /** Re-wires hover listeners when a target is added after connect (Turbo Streams etc.). */
   triggerTargetConnected() {
     this.#rewireHoverListeners();
   }
-  /** Re-wires hover listeners when a target is removed while connected. */
   triggerTargetDisconnected() {
     this.#rewireHoverListeners();
   }
-  /** See {@link NavigationMenuController.triggerTargetConnected}. */
   panelTargetConnected() {
     this.#rewireHoverListeners();
   }
-  /** See {@link NavigationMenuController.triggerTargetDisconnected}. */
   panelTargetDisconnected() {
     this.#rewireHoverListeners();
   }
-  /** See {@link NavigationMenuController.triggerTargetConnected}. */
   hoverAreaTargetConnected() {
     this.#rewireHoverListeners();
   }
-  /** See {@link NavigationMenuController.triggerTargetDisconnected}. */
   hoverAreaTargetDisconnected() {
     this.#rewireHoverListeners();
   }
-  /**
-   * Toggles a trigger's panel (single-open). Bound via `data-action` (click).
-   *
-   * An explicit activation always wins over a scheduled hover open/close, so any
-   * pending hover timer is dropped first — otherwise a close scheduled just
-   * before the click would fire into the freshly opened panel.
-   *
-   * Under `openOnHover`, closing a panel the pointer itself is holding open is
-   * refused: the pointer stays put, `mouseenter` does not re-fire, and the panel
-   * would be unopenable until the pointer left and came back. Keyboard
-   * activation (pointer elsewhere) still toggles it closed, and `Escape` and
-   * outside clicks dismiss either way.
-   */
-  toggle(event) {
-    const trigger = event.currentTarget;
+  toggle(source) {
+    const { host, origin, reason } = actionSource(source);
+    const trigger = host?.closest(targetSelector(this.identifier, "trigger"));
+    if (!trigger || !this.triggerTargets.includes(trigger)) return;
+    if (origin && origin.closest(`[data-controller~="${this.identifier}"]`) !== this.element)
+      return;
     this.#hoverTimers.clearAll();
     if (!this.#isExpanded(trigger)) {
-      this.#openPanel(trigger);
+      this.#openPanel(trigger, reason);
       return;
     }
     if (this.openOnHoverValue && this.#hoveredTrigger === trigger) return;
-    this.#closePanel(trigger);
-  }
-  /**
-   * `ArrowLeft`/`ArrowRight` move focus between triggers (keeping Tab order).
-   *
-   * Only navigable triggers are destinations, so a `hidden` or disabled item
-   * never swallows the press. A modified arrow belongs to the browser or OS
-   * (`Alt+←`/`Alt+→` is history back/forward), and with no destination at all
-   * (a single-trigger nav) the press is left to the page — `preventDefault()` is
-   * called only when focus actually moves, keeping the scroll-suppression
-   * contract honest.
-   */
+    this.#closePanel(trigger, reason);
+  }
   onTriggerKeydown(event) {
     if (event.defaultPrevented) return;
     if (event.key !== "ArrowRight" && event.key !== "ArrowLeft") return;
@@ -292,60 +286,42 @@ var NavigationMenuController = class extends Controller {
     const step = event.key === forward ? 1 : -1;
     triggers[(index + step + triggers.length) % triggers.length]?.focus();
   }
-  /**
-   * Opens `trigger`'s panel, closing any other open panel first. Re-opening an
-   * already-open panel only re-asserts the Escape layer: the close/open
-   * round-trip would rewrite `aria-expanded` and `hidden` for no state change.
-   */
-  #openPanel(trigger) {
+  #openPanel(trigger, reason) {
     if (trigger.getAttribute("aria-disabled") === "true") return;
     if (this.#isExpanded(trigger)) {
       this.#syncEscapeLayer();
       return;
     }
-    this.#closeAll();
+    this.#closeAll(reason);
     const panel = this.#panelFor(trigger);
     if (!panel) return;
     panel.hidden = false;
     trigger.setAttribute("aria-expanded", "true");
+    this.#report("open", trigger, panel, reason);
     this.#syncEscapeLayer();
   }
-  /** Closes `trigger`'s panel and reflects the collapsed state. */
-  #closePanel(trigger) {
+  #closePanel(trigger, reason) {
+    const was = this.#isExpanded(trigger);
     const panel = this.#panelFor(trigger);
     if (panel) panel.hidden = true;
     trigger.setAttribute("aria-expanded", "false");
+    if (was && panel) this.#report("close", trigger, panel, reason);
     this.#syncEscapeLayer();
   }
-  /**
-   * Closes every open panel and normalizes `aria-expanded="false"` on **all**
-   * triggers, so a trigger whose panel was hidden by other means cannot keep
-   * advertising an open panel.
-   */
-  #closeAll() {
-    for (const trigger of this.triggerTargets) this.#closePanel(trigger);
-  }
-  /**
-   * Whether a trigger can receive arrow-key focus: not `hidden`, not a natively
-   * `disabled` control (mirrors `toolbar`). CSS-only visibility cannot be
-   * detected headlessly and stays the consumer's responsibility.
-   *
-   * **`aria-disabled="true"` stays reachable.** APG separates the attributes by
-   * intent: `disabled` is for controls a neighbour makes inferable, while
-   * `aria-disabled` marks one that must remain *discoverable* — and a nav
-   * section the user cannot even arrow to is a section they cannot learn exists.
-   * Opening is suppressed separately, so the trigger announces itself and does
-   * nothing.
-   */
+  #closeAll(reason) {
+    for (const trigger of this.triggerTargets) this.#closePanel(trigger, reason);
+  }
+  #report(name, trigger, panel, reason) {
+    if (!this.#reporting) return;
+    const index = this.triggerTargets.indexOf(trigger);
+    const detail = { reason, index, panel };
+    if (name === "open") this.dispatch("open", { detail, cancelable: false });
+    else this.dispatch("close", { detail, cancelable: false });
+  }
   #isNavigable(trigger) {
     if (trigger.hasAttribute("hidden")) return false;
     return !trigger.disabled;
   }
-  /**
-   * Aligns Escape-stack membership with the open state: joins (or re-asserts to
-   * the top) while a panel is open, leaves once none is. Re-asserting when the
-   * user switches panels is deliberate — the nav is again the newest layer.
-   */
   #syncEscapeLayer() {
     if (this.#isAnyOpen) {
       this.#escapeLayer.activate(document, {
@@ -356,84 +332,49 @@ var NavigationMenuController = class extends Controller {
       this.#escapeLayer.deactivate();
     }
   }
-  /**
-   * Closes any open panel and returns focus to its trigger (Escape path). A
-   * pending hover open would otherwise re-open the panel the user just
-   * dismissed, so the reservation is dropped with it.
-   */
   #closeAndRestore() {
     const open = this.#openTrigger;
     if (!open) return;
     this.#hoverTimers.clearAll();
-    this.#closePanel(open);
+    this.#closePanel(open, "escape");
     open.focus();
   }
-  /** Closes panels when a click lands outside the nav element. */
   #onOutsideClick = (event) => {
-    if (this.#isAnyOpen && !this.element.contains(event.target)) this.#closeAll();
+    if (this.#isAnyOpen && !this.element.contains(event.target)) this.#closeAll("outside");
   };
-  /**
-   * Closes (without restoring focus) when focus leaves the nav for a known
-   * external destination. A null/non-Node destination is indeterminate:
-   * browsers use it for clicks on non-focusable content and for window
-   * deactivation, so those never close the nav here (matching the popover
-   * convention) — the outside-click handler decides pointer dismissal, and the
-   * Escape stack's body-focus claim keeps keyboard dismissal working.
-   */
   #onFocusOut = (event) => {
     const next = event.relatedTarget;
     if (!(next instanceof Node) || this.element.contains(next)) return;
-    this.#closeAll();
+    this.#closeAll("focus");
   };
-  /** Opens a trigger's panel after the hover delay (hover mode). */
   #onPointerEnter = (event) => {
     const trigger = this.#triggerForHover(event.currentTarget);
     if (!trigger) return;
     this.#hoveredTrigger = trigger;
     this.#hoverTimers.clearAll();
-    this.#hoverTimers.set(() => this.#openFromHover(trigger), this.hoverDelayValue);
+    this.#hoverTimers.set(() => this.#openFromHover(trigger), this.#safeHoverDelay);
   };
-  /**
-   * Closes the open panel after the hover delay (hover mode) — unless the
-   * pointer moved directly into another part of the hover region (an adjacent
-   * trigger, panel, or hoverArea): crossing a shared edge must not schedule a
-   * spurious close, e.g. a hoverArea whose panel sits outside it as a sibling.
-   */
   #onPointerLeave = (event) => {
     const next = event instanceof MouseEvent ? event.relatedTarget : null;
     if (ownerIndex(this.#hoverElements, next) !== -1) return;
     this.#hoveredTrigger = null;
     this.#hoverTimers.clearAll();
-    this.#hoverTimers.set(() => this.#closeFromHover(), this.hoverDelayValue);
+    this.#hoverTimers.set(() => this.#closeFromHover(), this.#safeHoverDelay);
   };
-  /**
-   * Hover-driven open. Switching panels would hide the outgoing one, so focus
-   * standing inside it is handed back to its trigger first: pointer movement
-   * must never send focus to the body (the keyboard user would lose their
-   * place). Focus outside the closing panel is left alone.
-   */
   #openFromHover(trigger) {
     if (trigger.getAttribute("aria-disabled") === "true") return;
     const open = this.#openTrigger;
     if (open && open !== trigger && this.#holdsFocus(this.#panelFor(open))) open.focus();
-    this.#openPanel(trigger);
-  }
-  /**
-   * Hover-driven close: skipped while focus sits inside the panel it would hide,
-   * for the same no-focus-loss reason (cf. `hover_card`'s delayed close). The
-   * panel then stays open until `Escape`, an outside click, or focus leaving the
-   * nav dismisses it — all of which restore or keep focus deliberately.
-   */
+    this.#openPanel(trigger, "pointer");
+  }
   #closeFromHover() {
     const open = this.#openTrigger;
     if (open && this.#holdsFocus(this.#panelFor(open))) return;
-    this.#closeAll();
+    this.#closeAll("pointer");
   }
-  /** Whether `panel` exists and currently contains the focused element. */
   #holdsFocus(panel) {
     return panel?.contains(document.activeElement) ?? false;
   }
-  /** Wires hover open/close on each hover element (opt-in), tracking what was wired. */
   #addHoverListeners() {
     for (const element of this.#hoverElements) {
       element.addEventListener("mouseenter", this.#onPointerEnter);
@@ -441,7 +382,6 @@ var NavigationMenuController = class extends Controller {
       this.#hoverWired.add(element);
     }
   }
-  /** Removes the hover listeners from exactly the elements that were wired. */
   #removeHoverListeners() {
     for (const element of this.#hoverWired) {
       element.removeEventListener("mouseenter", this.#onPointerEnter);
@@ -450,25 +390,11 @@ var NavigationMenuController = class extends Controller {
     this.#hoverWired.clear();
     this.#hoveredTrigger = null;
   }
-  /**
-   * Rebuilds the hover wiring from the current targets. Target callbacks call
-   * this so items added or removed after connect (e.g. a Turbo Stream append)
-   * participate in hover; the wired-set removal keeps the rebuild symmetric.
-   * Stimulus fires those callbacks during teardown too, hence the `#connected`
-   * guard — a rebuild after `disconnect()` would resurrect the listeners.
-   */
   #rewireHoverListeners() {
     if (!this.#connected || !this.openOnHoverValue) return;
     this.#removeHoverListeners();
     this.#addHoverListeners();
   }
-  /**
-   * Elements that participate in hover: each `hoverArea`, plus every trigger and
-   * panel **not** wrapped by one. A wrapped trigger/panel must defer to its
-   * wrapper — its own mouseleave would otherwise schedule a close while the
-   * pointer is still inside the area (mouseenter does not re-fire on the wrapper
-   * when moving among its descendants), flickering the panel shut.
-   */
   get #hoverElements() {
     const areas = this.hoverAreaTargets;
     const covered = (element) => ownerIndex(areas, element) !== -1;
@@ -478,11 +404,6 @@ var NavigationMenuController = class extends Controller {
       ...this.panelTargets.filter((panel) => !covered(panel))
     ];
   }
-  /**
-   * Resolves the trigger for a hovered element: the trigger itself, the trigger
-   * controlling a hovered panel, or the first trigger contained in a hovered
-   * `hoverArea` wrapper.
-   */
   #triggerForHover(element) {
     if (this.triggerTargets.includes(element)) return element;
     if (this.panelTargets.includes(element)) {
@@ -493,25 +414,29 @@ var NavigationMenuController = class extends Controller {
     }
     return null;
   }
-  /** The panel controlled by `trigger` (matched by `aria-controls`/`id`). */
   #panelFor(trigger) {
     const id = trigger.getAttribute("aria-controls");
     return id ? this.panelTargets.find((panel) => panel.id === id) ?? null : null;
   }
-  /** Whether `trigger`'s panel is currently expanded. */
   #isExpanded(trigger) {
     return trigger.getAttribute("aria-expanded") === "true";
   }
-  /** The trigger whose panel is currently open, if any. */
   get #openTrigger() {
     return this.triggerTargets.find((trigger) => this.#isExpanded(trigger)) ?? null;
   }
-  /** Whether any panel is currently open. */
   get #isAnyOpen() {
     return this.#openTrigger !== null;
   }
+  get #safeHoverDelay() {
+    return this.#numbers.read(
+      this,
+      "hoverDelay",
+      this.hoverDelayValue,
+      _NavigationMenuController.values.hoverDelay.default,
+      _NavigationMenuController.valueConstraints.hoverDelay
+    );
+  }
 };
 
 export { NavigationMenuController };
-//# sourceMappingURL=navigation_menu_controller.js.map
 //# sourceMappingURL=navigation_menu_controller.js.map