@expcat/tigercat-react 2.1.2 → 2.1.4

package/dist/{chunk-2YOP55OF.mjs → chunk-HKPRHDW4.mjs}

@@ -1,7 +1,10 @@
+import {
+  composeRefs
+} from "./chunk-WWZZRB7H.mjs";
 import {
   renderOverlayPortal,
   useAnchoredOverlay
-} from "./chunk-HKAZXG74.mjs";
+} from "./chunk-OU2AV7DY.mjs";
 
 // src/components/NavigationMenu.tsx
 import React, {
@@ -9,13 +12,20 @@ import React, {
   useContext,
   useState,
   useEffect,
+  useLayoutEffect,
   useRef,
   useCallback,
   useMemo,
   useId
 } from "react";
 import {
+  applyNavigationMenuPanelKey,
   classNames,
+  createNavigationMenuHoverSession,
+  focusFirstMenuItemWhenVisible,
+  captureActiveElement,
+  restoreFocus,
+  getNavigationMenuBarItems,
   getNavigationMenuClasses,
   getNavigationMenuListClasses,
   getNavigationMenuItemClasses,
@@ -23,136 +33,170 @@ import {
   getNavigationMenuChevronClasses,
   getNavigationMenuContentClasses,
   getNavigationMenuLinkClasses,
+  getNavigationMenuItemValue,
+  getNavigationMenuRovingTabIndex,
+  getNavigationMenuTabExitTarget,
+  getSecureRel,
+  handleMenubarNavigation,
   injectNavigationMenuStyles,
-  NAVIGATION_MENU_ENTER_CLASS,
-  NAVIGATION_MENU_CHEVRON_PATH,
+  isFocusInsideNavigationMenu,
+  isNavigationMenuOpen,
+  isNavigationMenuTriggerOpenKey,
+  isNavigationMenuValueOpen,
   NAVIGATION_MENU_BAR_ITEM_ATTR,
+  NAVIGATION_MENU_CHEVRON_PATH,
   NAVIGATION_MENU_DEFAULT_DELAY_DURATION,
-  NAVIGATION_MENU_DEFAULT_SKIP_DELAY_DURATION,
   NAVIGATION_MENU_DEFAULT_OFFSET,
-  isNavigationMenuValueOpen,
-  isNavigationMenuOpen,
+  NAVIGATION_MENU_DEFAULT_SKIP_DELAY_DURATION,
+  NAVIGATION_MENU_ENTER_CLASS,
+  NAVIGATION_MENU_ITEM_VALUE_ATTR,
+  resolveElementDir,
   resolveNavigationMenuOpenValue,
-  shouldSkipNavigationMenuOpenDelay,
-  isNavigationMenuTriggerOpenKey,
-  handleMenubarNavigation,
-  handleMenuNavigation,
-  initNavigationMenuRovingTabIndex,
-  focusFirstMenuItem,
-  captureActiveElement,
-  restoreFocus,
-  getSecureRel
+  resolveNavigationMenuTabStopValue,
+  warnNavigationMenuOpenWithoutValue
 } from "@expcat/tigercat-core";
 import { jsx, jsxs } from "react/jsx-runtime";
-function containsFocusTarget(container, target) {
-  return Boolean(container && target instanceof Node && container.contains(target));
-}
-function getOpenPanelFromMenubar(menubar) {
-  if (!menubar) return null;
-  const trigger = menubar.querySelector('[aria-expanded="true"][aria-controls]');
-  const contentId = trigger?.getAttribute("aria-controls");
-  if (!contentId) return null;
-  return menubar.ownerDocument.getElementById(contentId);
-}
 var NavigationMenuContext = createContext(null);
 var NavigationMenuItemContext = createContext(null);
 var NavigationMenuContentContext = createContext(
   null
 );
-var NavigationMenuLink = ({
-  href,
-  target,
-  rel,
-  disabled = false,
-  active = false,
-  className,
-  style,
-  onClick,
-  children
-}) => {
-  const root = useContext(NavigationMenuContext);
-  const item = useContext(NavigationMenuItemContext);
-  const content = useContext(NavigationMenuContentContext);
-  const inPanel = Boolean(content);
-  const isDisabled = disabled || Boolean(item?.disabled);
-  const handleClick = (event) => {
-    if (isDisabled) {
-      event.preventDefault();
-      event.stopPropagation();
-      return;
+function hasNavigationMenuList(children) {
+  return React.Children.toArray(children).some((child) => {
+    if (!React.isValidElement(child)) return false;
+    if (child.type === NavigationMenuList) return true;
+    if (child.type === React.Fragment) {
+      return hasNavigationMenuList(child.props.children);
     }
-    onClick?.(event);
-    root?.handleItemClick();
-  };
-  const handleFocus = () => {
-    if (inPanel) return;
-    if (!item?.hasPanel) {
-      root?.setValue(null, { restoreFocus: false });
+    return false;
+  });
+}
+function childIsContent(child) {
+  return React.isValidElement(child) && child.type === NavigationMenuContent;
+}
+var NavigationMenuLink = React.forwardRef(
+  ({
+    href,
+    target,
+    rel,
+    disabled = false,
+    active = false,
+    className,
+    style,
+    onClick,
+    children,
+    ...rest
+  }, forwardedRef) => {
+    const root = useContext(NavigationMenuContext);
+    const item = useContext(NavigationMenuItemContext);
+    const content = useContext(NavigationMenuContentContext);
+    const inPanel = Boolean(content);
+    const isDisabled = disabled || Boolean(item?.disabled) || Boolean(!inPanel && root?.disabled);
+    const tabIndex = inPanel ? -1 : getNavigationMenuRovingTabIndex(item?.value ?? "", root?.tabStopValue);
+    const handleClick = (event) => {
+      if (isDisabled) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      onClick?.(event);
+      root?.handleItemClick();
+    };
+    const handleFocus = () => {
+      if (inPanel) return;
+      if (!item?.hasPanel) {
+        root?.setValue(null, { restoreFocus: false });
+      }
+      if (item) root?.setTabStopValue(item.value);
+    };
+    const handleKeyDown = (event) => {
+      if (inPanel || !root?.menubarRef.current) return;
+      const next = handleMenubarNavigation(root.menubarRef.current, event.nativeEvent);
+      if (!next) return;
+      const value = getNavigationMenuItemValue(next);
+      if (value != null) root.setTabStopValue(value);
+    };
+    const linkClasses = classNames(
+      getNavigationMenuLinkClasses(isDisabled, inPanel, active),
+      className
+    );
+    const computedRel = href && !isDisabled ? getSecureRel(target, rel) : void 0;
+    const shared = {
+      ...rest,
+      className: linkClasses,
+      style,
+      role: "menuitem",
+      tabIndex,
+      [NAVIGATION_MENU_BAR_ITEM_ATTR]: inPanel || isDisabled ? void 0 : "",
+      [NAVIGATION_MENU_ITEM_VALUE_ATTR]: inPanel ? void 0 : String(item?.value ?? ""),
+      "aria-disabled": isDisabled || void 0,
+      "aria-current": active ? "page" : void 0,
+      "data-tiger-navigation-menu-link": "",
+      "data-active": active ? "true" : void 0,
+      onClick: handleClick,
+      onFocus: handleFocus,
+      onKeyDown: handleKeyDown
+    };
+    if (href && !isDisabled) {
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          ref: forwardedRef,
+          href,
+          target,
+          rel: computedRel,
+          ...shared,
+          children
+        }
+      );
     }
-  };
-  const handleKeyDown = (event) => {
-    if (inPanel) return;
-    if (root?.menubarRef.current) {
-      handleMenubarNavigation(root.menubarRef.current, event.nativeEvent);
+    if (href && isDisabled) {
+      return /* @__PURE__ */ jsx("span", { ref: forwardedRef, ...shared, children });
     }
-  };
-  const linkClasses = classNames(
-    getNavigationMenuLinkClasses(isDisabled, inPanel, active),
-    className
-  );
-  const computedRel = href ? getSecureRel(target, rel) : void 0;
-  const shared = {
-    className: linkClasses,
-    style,
-    role: "menuitem",
-    tabIndex: -1,
-    [NAVIGATION_MENU_BAR_ITEM_ATTR]: inPanel ? void 0 : "",
-    "aria-disabled": isDisabled || void 0,
-    "aria-current": active ? "page" : void 0,
-    "data-tiger-navigation-menu-link": "",
-    "data-active": active ? "true" : void 0,
-    onClick: handleClick,
-    onFocus: handleFocus,
-    onKeyDown: handleKeyDown
-  };
-  if (href) {
-    return /* @__PURE__ */ jsx("a", { href, target, rel: computedRel, ...shared, children });
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        ref: forwardedRef,
+        ...shared,
+        type: "button",
+        disabled: isDisabled,
+        children
+      }
+    );
   }
-  return /* @__PURE__ */ jsx("button", { type: "button", disabled: isDisabled, ...shared, children });
-};
-var NavigationMenuTrigger = ({
-  disabled = false,
-  showArrow,
-  className,
-  style,
-  children
-}) => {
+);
+NavigationMenuLink.displayName = "NavigationMenuLink";
+var NavigationMenuTrigger = React.forwardRef(({ disabled = false, showArrow, className, style, children, ...buttonProps }, forwardedRef) => {
   const root = useContext(NavigationMenuContext);
   const item = useContext(NavigationMenuItemContext);
   const isDisabled = disabled || Boolean(item?.disabled) || Boolean(root?.disabled);
   const arrow = showArrow !== void 0 ? showArrow : item?.showArrow ?? true;
+  const tabIndex = getNavigationMenuRovingTabIndex(item?.value ?? "", root?.tabStopValue);
   const handleMouseEnter = () => {
-    if (isDisabled) return;
+    if (isDisabled || !root?.openOnHover) return;
     item?.scheduleOpen();
   };
   const handleMouseLeave = () => {
+    if (!root?.openOnHover) return;
     item?.scheduleClose();
   };
-  const handleFocus = () => {
-    if (isDisabled || root?.isFocusOpenSuppressed()) return;
-    item?.open();
-  };
   const handleClick = (event) => {
     if (isDisabled) {
       event.preventDefault();
       return;
     }
-    item?.open();
+    if (item?.isOpen) item.close({ restoreFocus: false });
+    else item?.open();
   };
   const handleKeyDown = (event) => {
     if (isDisabled || !item) return;
-    if (root?.menubarRef.current && handleMenubarNavigation(root.menubarRef.current, event.nativeEvent)) {
-      return;
+    if (root?.menubarRef.current) {
+      const next = handleMenubarNavigation(root.menubarRef.current, event.nativeEvent);
+      if (next) {
+        const value = getNavigationMenuItemValue(next);
+        if (value != null) root.setTabStopValue(value);
+        return;
+      }
     }
     if (isNavigationMenuTriggerOpenKey(event.key) && item.hasPanel) {
       event.preventDefault();
@@ -173,23 +217,25 @@ var NavigationMenuTrigger = ({
   return /* @__PURE__ */ jsxs(
     "button",
     {
-      ref: item.triggerRef,
+      ...buttonProps,
+      ref: composeRefs(forwardedRef, item.triggerRef),
       type: "button",
       className: triggerClasses,
       style,
       role: "menuitem",
-      tabIndex: -1,
-      ...{ [NAVIGATION_MENU_BAR_ITEM_ATTR]: "" },
+      tabIndex,
+      ...{ [NAVIGATION_MENU_BAR_ITEM_ATTR]: isDisabled ? void 0 : "" },
+      ...{ [NAVIGATION_MENU_ITEM_VALUE_ATTR]: String(item.value) },
       "aria-haspopup": "menu",
       "aria-expanded": item.isOpen,
-      "aria-controls": item.isOpen ? item.contentId : void 0,
+      "aria-controls": item.contentId,
       "aria-disabled": isDisabled || void 0,
       disabled: isDisabled,
       "data-state": item.isOpen ? "open" : "closed",
       "data-tiger-navigation-menu-trigger": "",
       onMouseEnter: handleMouseEnter,
       onMouseLeave: handleMouseLeave,
-      onFocus: handleFocus,
+      onFocus: () => root?.setTabStopValue(item.value),
       onClick: handleClick,
       onKeyDown: handleKeyDown,
       children: [
@@ -211,7 +257,8 @@ var NavigationMenuTrigger = ({
       ]
     }
   );
-};
+});
+NavigationMenuTrigger.displayName = "NavigationMenuTrigger";
 var NavigationMenuContent = ({
   mega = false,
   className,
@@ -227,11 +274,6 @@ var NavigationMenuContent = ({
   const contentRef = item?.contentRef ?? floatingRef;
   const isOpen = Boolean(item?.isOpen);
   const portalEnabled = Boolean(root?.portal);
-  useEffect(() => {
-    if (!item) return;
-    item.setHasPanel(true);
-    return () => item.setHasPanel(false);
-  }, [item]);
   const overlay = useAnchoredOverlay({
     referenceRef,
     floatingRef: contentRef,
@@ -241,31 +283,43 @@ var NavigationMenuContent = ({
     portal: portalEnabled,
     dismissOnOutside: true,
     dismissOnEscape: true,
-    onDismiss: () => item?.close()
+    onDismiss: () => item?.close({ restoreFocus: false })
   });
   const handleMouseEnter = () => {
     item?.cancelClose();
   };
   const handleMouseLeave = () => {
+    if (!root?.openOnHover) return;
     item?.scheduleClose();
   };
   const handleFocusOut = (event) => {
     root?.handleFocusLeave(event);
   };
   const handleKeyDown = (event) => {
-    if (contentRef.current) {
-      handleMenuNavigation(contentRef.current, event.nativeEvent);
+    const panel = contentRef.current;
+    if (!panel || !item || !root) return;
+    const dir = resolveElementDir(root.rootRef.current ?? root.menubarRef.current);
+    const action = applyNavigationMenuPanelKey({ event: event.nativeEvent, panel, dir });
+    if (!action || action === "menu-nav") return;
+    event.stopPropagation();
+    if (action === "close-to-trigger") {
+      item.close();
+      item.triggerRef.current?.focus();
+      return;
     }
-    if (event.key === "Escape" || event.key === "ArrowLeft") {
-      event.preventDefault();
-      event.stopPropagation();
-      item?.close();
-      item?.triggerRef.current?.focus();
+    if (action === "move-menubar-next" && root.menubarRef.current) {
+      item.close({ restoreFocus: false });
+      item.triggerRef.current?.focus();
+      const next = handleMenubarNavigation(root.menubarRef.current, event.nativeEvent);
+      const value = getNavigationMenuItemValue(next);
+      if (value != null) root.setTabStopValue(value);
       return;
     }
-    if (event.key === "ArrowRight" && root?.menubarRef.current && item?.triggerRef.current) {
-      item.triggerRef.current.focus();
-      handleMenubarNavigation(root.menubarRef.current, event.nativeEvent);
+    if (action === "tab-exit" || action === "shift-tab-exit") {
+      const nav = root.rootRef.current;
+      const target = nav ? getNavigationMenuTabExitTarget(nav, panel, action === "shift-tab-exit") : null;
+      item.close({ restoreFocus: false });
+      target?.focus();
     }
   };
   if (!item || !root) return null;
@@ -288,8 +342,8 @@ var NavigationMenuContent = ({
           ...divProps,
           id: item.contentId,
           className: classNames(getNavigationMenuContentClasses(mega), className),
-          style,
-          role: mega ? "group" : "menu",
+          style: mega ? { minWidth: "28rem", ...style } : style,
+          role: "menu",
           children
         }
       )
@@ -310,7 +364,7 @@ var NavigationMenuItem = ({
   const itemValue = valueProp ?? autoValue;
   const triggerRef = useRef(null);
   const contentRef = useRef(null);
-  const [hasPanel, setHasPanel] = useState(false);
+  const hasPanel = React.Children.toArray(children).some(childIsContent);
   const isOpen = Boolean(root && !disabled && isNavigationMenuValueOpen(itemValue, root.value));
   const contentId = `${autoValue}-content`;
   const open = useCallback(
@@ -318,18 +372,22 @@ var NavigationMenuItem = ({
       if (disabled || !root) return;
       root.cancelClose();
       root.setValue(itemValue);
+      root.setTabStopValue(itemValue);
       if (!focusPanel) return;
-      requestAnimationFrame(() => {
+      queueMicrotask(() => {
         const panel = contentRef.current ?? document.getElementById(contentId);
-        if (panel) focusFirstMenuItem(panel);
+        if (panel) focusFirstMenuItemWhenVisible(panel);
       });
     },
     [contentId, disabled, itemValue, root]
   );
-  const close = useCallback(() => {
-    if (!root) return;
-    if (isOpen) root.setValue(null);
-  }, [isOpen, root]);
+  const close = useCallback(
+    (options) => {
+      if (!root) return;
+      if (isOpen) root.setValue(null, options);
+    },
+    [isOpen, root]
+  );
   const scheduleOpen = useCallback(() => {
     if (disabled || !root) return;
     root.scheduleOpen(itemValue);
@@ -346,7 +404,6 @@ var NavigationMenuItem = ({
       isOpen,
       disabled,
       hasPanel,
-      setHasPanel,
       triggerRef,
       contentRef,
       contentId,
@@ -358,9 +415,9 @@ var NavigationMenuItem = ({
       showArrow: root?.showArrow ?? true
     }),
     [
-      autoValue,
       cancelClose,
       close,
+      contentId,
       disabled,
       hasPanel,
       isOpen,
@@ -401,8 +458,16 @@ var NavigationMenuList = ({
     },
     [root]
   );
-  useEffect(() => {
-    if (listRef.current) initNavigationMenuRovingTabIndex(listRef.current);
+  useLayoutEffect(() => {
+    const list = listRef.current;
+    if (!list || !root) return;
+    const next = resolveNavigationMenuTabStopValue({
+      items: getNavigationMenuBarItems(list),
+      tabStopValue: root.tabStopValue
+    });
+    if (next != null && next !== String(root.tabStopValue ?? "")) {
+      root.setTabStopValue(next);
+    }
   });
   return /* @__PURE__ */ jsx(
     "ul",
@@ -422,6 +487,7 @@ var NavigationMenu = ({
   defaultValue,
   open: controlledOpen,
   defaultOpen = false,
+  openOnHover = false,
   disabled = false,
   closeOnClick = true,
   delayDuration = NAVIGATION_MENU_DEFAULT_DELAY_DURATION,
@@ -441,13 +507,10 @@ var NavigationMenu = ({
   const [internalValue, setInternalValue] = useState(
     isNavigationMenuOpen(initialValue) ? initialValue : null
   );
+  const [tabStopValue, setTabStopValue] = useState(null);
   const rootRef = useRef(null);
   const menubarRef = useRef(null);
   const previousActiveElementRef = useRef(null);
-  const openTimerRef = useRef(null);
-  const closeTimerRef = useRef(null);
-  const lastOpenAtRef = useRef(0);
-  const suppressFocusOpenRef = useRef(false);
   const currentValue = resolveNavigationMenuOpenValue({
     value: controlledValue,
     internalValue,
@@ -456,24 +519,36 @@ var NavigationMenu = ({
   const currentValueRef = useRef(currentValue);
   currentValueRef.current = currentValue;
   const currentOpen = isNavigationMenuOpen(currentValue);
+  const delayDurationRef = useRef(delayDuration);
+  delayDurationRef.current = delayDuration;
+  const skipDelayDurationRef = useRef(skipDelayDuration);
+  skipDelayDurationRef.current = skipDelayDuration;
+  const disabledRef = useRef(disabled);
+  disabledRef.current = disabled;
+  const setValueRef = useRef(() => void 0);
+  const hoverRef = useRef(null);
+  if (!hoverRef.current) {
+    hoverRef.current = createNavigationMenuHoverSession({
+      getDelayDuration: () => delayDurationRef.current,
+      getSkipDelayDuration: () => skipDelayDurationRef.current,
+      getValue: () => currentValueRef.current,
+      setValue: (next) => setValueRef.current(next),
+      isDisabled: () => disabledRef.current
+    });
+  }
   useEffect(() => {
     injectNavigationMenuStyles();
   }, []);
-  const clearTimers = useCallback(() => {
-    if (openTimerRef.current) {
-      clearTimeout(openTimerRef.current);
-      openTimerRef.current = null;
-    }
-    if (closeTimerRef.current) {
-      clearTimeout(closeTimerRef.current);
-      closeTimerRef.current = null;
-    }
-  }, []);
-  useEffect(() => () => clearTimers(), [clearTimers]);
+  useEffect(() => {
+    warnNavigationMenuOpenWithoutValue(
+      controlledOpen,
+      isNavigationMenuOpen(controlledValue ?? defaultValue ?? internalValue)
+    );
+  }, [controlledOpen, controlledValue, defaultValue, internalValue]);
   const setValue = useCallback(
     (next, options) => {
       if (disabled && next != null) return;
-      clearTimers();
+      hoverRef.current?.clear();
       const resolvedNext = isNavigationMenuOpen(next) ? next : null;
       const wasOpen = isNavigationMenuOpen(currentValueRef.current);
       const willOpen = resolvedNext != null;
@@ -489,93 +564,39 @@ var NavigationMenu = ({
       }
       onValueChange?.(resolvedNext);
       onOpenChange?.(willOpen);
-      if (!willOpen) {
-        suppressFocusOpenRef.current = true;
-        if (options?.restoreFocus !== false) {
-          restoreFocus(previousActiveElementRef.current);
-        }
+      if (!willOpen && options?.restoreFocus !== false) {
+        restoreFocus(previousActiveElementRef.current);
         previousActiveElementRef.current = null;
-        queueMicrotask(() => {
-          suppressFocusOpenRef.current = false;
-        });
-      }
-    },
-    [clearTimers, controlledValue, disabled, onOpenChange, onValueChange]
-  );
-  const scheduleOpen = useCallback(
-    (itemValue) => {
-      if (disabled) return;
-      if (closeTimerRef.current) {
-        clearTimeout(closeTimerRef.current);
-        closeTimerRef.current = null;
-      }
-      const skip = shouldSkipNavigationMenuOpenDelay(
-        lastOpenAtRef.current,
-        Date.now(),
-        skipDelayDuration
-      );
-      const delay = skip ? 0 : delayDuration;
-      const apply = () => {
-        lastOpenAtRef.current = Date.now();
-        setValue(itemValue);
-        openTimerRef.current = null;
-      };
-      if (delay <= 0) {
-        apply();
-        return;
-      }
-      if (openTimerRef.current) clearTimeout(openTimerRef.current);
-      openTimerRef.current = setTimeout(apply, delay);
-    },
-    [delayDuration, disabled, setValue, skipDelayDuration]
-  );
-  const scheduleClose = useCallback(
-    (itemValue) => {
-      if (openTimerRef.current) {
-        clearTimeout(openTimerRef.current);
-        openTimerRef.current = null;
-      }
-      const close = () => {
-        if (currentValueRef.current === itemValue) setValue(null);
-        closeTimerRef.current = null;
-      };
-      if (skipDelayDuration <= 0) {
-        close();
-        return;
       }
-      if (closeTimerRef.current) clearTimeout(closeTimerRef.current);
-      closeTimerRef.current = setTimeout(close, skipDelayDuration);
     },
-    [setValue, skipDelayDuration]
+    [controlledValue, disabled, onOpenChange, onValueChange]
   );
-  const cancelClose = useCallback(() => {
-    if (closeTimerRef.current) {
-      clearTimeout(closeTimerRef.current);
-      closeTimerRef.current = null;
-    }
-  }, []);
+  setValueRef.current = setValue;
+  useEffect(() => () => hoverRef.current?.clear(), []);
   const handleItemClick = useCallback(() => {
-    if (closeOnClick) setValue(null);
+    if (closeOnClick) setValue(null, { restoreFocus: false });
   }, [closeOnClick, setValue]);
   const handleFocusLeave = useCallback(
     (event) => {
-      const next = event.relatedTarget;
-      if (containsFocusTarget(rootRef.current, next)) return;
-      if (containsFocusTarget(getOpenPanelFromMenubar(menubarRef.current), next)) return;
+      if (isFocusInsideNavigationMenu(rootRef.current, menubarRef.current, event.relatedTarget)) {
+        return;
+      }
       if (!isNavigationMenuOpen(currentValueRef.current)) return;
       setValue(null, { restoreFocus: false });
     },
     [setValue]
   );
-  const isFocusOpenSuppressed = useCallback(() => suppressFocusOpenRef.current, []);
   const contextValue = useMemo(
     () => ({
       value: currentValue,
+      tabStopValue,
+      setTabStopValue,
       setValue,
-      scheduleOpen,
-      scheduleClose,
-      cancelClose,
+      scheduleOpen: (itemValue) => hoverRef.current?.scheduleOpen(itemValue),
+      scheduleClose: (itemValue) => hoverRef.current?.scheduleClose(itemValue),
+      cancelClose: () => hoverRef.current?.cancelClose(),
       closeOnClick,
+      openOnHover,
       handleItemClick,
       handleFocusLeave,
       portal,
@@ -583,30 +604,25 @@ var NavigationMenu = ({
       offset,
       placement,
       showArrow,
-      menubarRef,
-      isFocusOpenSuppressed
+      rootRef,
+      menubarRef
     }),
     [
-      cancelClose,
       closeOnClick,
       currentValue,
       disabled,
       handleFocusLeave,
       handleItemClick,
-      isFocusOpenSuppressed,
       offset,
+      openOnHover,
       placement,
       portal,
-      scheduleClose,
-      scheduleOpen,
       setValue,
-      showArrow
+      showArrow,
+      tabStopValue
     ]
   );
-  const childrenArray = React.Children.toArray(children);
-  const hasList = childrenArray.some(
-    (child) => React.isValidElement(child) && child.type === NavigationMenuList
-  );
+  const hasList = hasNavigationMenuList(children);
   return /* @__PURE__ */ jsx(NavigationMenuContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(
     "nav",
     {
@@ -614,7 +630,6 @@ var NavigationMenu = ({
       ref: rootRef,
       className: classNames(getNavigationMenuClasses(), className),
       style,
-      "aria-label": navProps["aria-label"] ?? "Main",
       "data-tiger-navigation-menu": "",
       "data-state": currentOpen ? "open" : "closed",
       onBlur: (event) => {