@astryxdesign/core 0.7.8 → 0.7.9-canary.0200dfe

package/dist/hooks/useFocusTrap.js

@@ -5,7 +5,8 @@
 /**
  * @file useFocusTrap.ts
  * @input Uses React useCallback, useEffect, useRef
- * @output Exports useFocusTrap, the deprecated Escape-state shim, and an
+ * @output Exports useFocusTrap, the internal focus-region Tab containment it
+ *   composes, the deprecated Escape-state shim, and an
  *   internal compatibility-signal hook
  * @position Core hook; used by dialogs, modals, date pickers
  *
@@ -61,6 +62,19 @@ export function useFocusTrapEscapeCompatibilitySignal(isActive) {
   }, [isActive]);
 }
 
+/**
+ * Whether an element is shown as a popover. jsdom and browsers without the
+ * Popover API do not recognize `:popover-open`, and nothing is popover-open
+ * there.
+ */
+function isPopoverOpen(el) {
+  try {
+    return el.matches(':popover-open');
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Whether an element is currently perceivable/focusable — excludes ones hidden
  * via `display:none`/`visibility:hidden` or inside an `inert`/`hidden` subtree,
@@ -75,6 +89,14 @@ function isVisiblyFocusable(el) {
   if (el.hidden || el.closest('[hidden]')) {
     return false;
   }
+  // A closed <dialog> renders nothing, so nothing inside it can take focus.
+  // A dialog shown with showPopover() (a non-modal sheet or drawer) never
+  // sets `open`, so it counts as shown while it is popover-open.
+  for (let dialog = el.closest('dialog'); dialog != null; dialog = dialog.parentElement?.closest('dialog') ?? null) {
+    if (!dialog.open && !isPopoverOpen(dialog)) {
+      return false;
+    }
+  }
   // closest() matches the element itself as well as any ancestor.
   if (el.closest('[aria-hidden="true"]')) {
     return false;
@@ -121,6 +143,13 @@ function isHTMLElement(node) {
   return view != null && node instanceof view.HTMLElement;
 }
 
+/**
+ * Whether node `a` comes before node `b` in document order.
+ */
+function precedes(a, b) {
+  return (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
+}
+
 /**
  * Attempt to focus an element. Returns true if focus was successful.
  */
@@ -133,6 +162,18 @@ function attemptFocus(element) {
   return element.ownerDocument.activeElement === element;
 }
 
+/**
+ * Wrap focus to `target` for a Tab press, and cancel the press only when the
+ * target took focus. A target the browser refuses (inert behind a modal
+ * layered over this region) leaves the press to the browser instead of
+ * stranding focus where it was.
+ */
+function wrapFocus(event, target) {
+  if (attemptFocus(target)) {
+    event.preventDefault();
+  }
+}
+
 /**
  * Focus the first focusable descendant of a container.
  * Returns true if a focusable element was found and focused.
@@ -161,6 +202,186 @@ function focusLastDescendant(container) {
   return false;
 }
 
+// Containers of the focus regions currently active, in every document. A Tab
+// is answered by the innermost region that holds focus, so regions that nest
+// in the DOM never fight over one key press.
+const activeRegionContainers = new Set();
+function hasInnerRegionHolding(container, active) {
+  // An open <dialog> nested in the region that holds focus is its own focus
+  // context (a modal step over a covered sheet): it answers Tab, not us.
+  const dialog = active.closest('dialog[open]');
+  if (dialog != null && dialog !== container && container.contains(dialog)) {
+    return true;
+  }
+  for (const other of activeRegionContainers) {
+    if (other !== container && container.contains(other) && other.contains(active)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Tab containment for a focus region: Tab and Shift+Tab pressed inside wrap at
+ * either end, and a Tab that starts outside is left to the page. When regions
+ * nest, the innermost one holding focus answers.
+ *
+ * `useFocusTrap` composes this. Dialog, BottomSheet and Lightbox call it
+ * directly, because their native lifecycle already owns focus entry and
+ * return. Internal: not re-exported from `hooks`.
+ */
+export function useFocusRegionContainment(containerRef, isActive) {
+  const lastFocusRef = useRef(null);
+  // Track if focus change was triggered by keyboard (Tab key)
+  const isKeyboardNavigationRef = useRef(false);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!isActive || container == null) {
+      return;
+    }
+    activeRegionContainers.add(container);
+    return () => {
+      activeRegionContainers.delete(container);
+    };
+  }, [containerRef, isActive]);
+
+  /**
+   * Handle focus events - redirect focus back into container if it escapes.
+   * Only redirects for keyboard navigation, not mouse clicks.
+   */
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const doc = trapDocument(containerRef.current);
+    const handleFocus = event => {
+      const container = containerRef.current;
+      if (!container) {
+        return;
+      }
+      const target = event.target;
+      if (container.contains(target)) {
+        // Focus is inside the container - track it
+        lastFocusRef.current = target;
+      } else if (isKeyboardNavigationRef.current) {
+        // Focus escaped via keyboard - redirect it back
+        const focusedFirst = focusFirstDescendant(container);
+
+        // If we're back at the same element (Shift+Tab from first element),
+        // try focusing the last element instead
+        if (focusedFirst && lastFocusRef.current === doc.activeElement) {
+          focusLastDescendant(container);
+        } else if (!focusedFirst && isHTMLElement(lastFocusRef.current) && container.contains(lastFocusRef.current)) {
+          // A modal surface may intentionally have no tabbable controls and
+          // place initial focus on a tabIndex={-1} heading or panel. Preserve
+          // that programmatic focus target instead of letting Tab escape.
+          attemptFocus(lastFocusRef.current);
+        }
+        lastFocusRef.current = doc.activeElement;
+      }
+      // If focus escaped via mouse click, don't redirect - let light dismiss handle it
+
+      // Reset keyboard navigation flag
+      isKeyboardNavigationRef.current = false;
+    };
+
+    // Use capture phase to intercept focus before it settles
+    doc.addEventListener('focus', handleFocus, true);
+    return () => {
+      doc.removeEventListener('focus', handleFocus, true);
+    };
+  }, [containerRef, isActive]);
+
+  /**
+   * Handle Tab key to wrap focus at boundaries. Also tracks that keyboard
+   * navigation is occurring.
+   *
+   * No Escape here, and no IME guard: the shared layer dismissal stack owns
+   * that press, and each surface that applies a region decides its own
+   * dismissal (`useFocusTrap` through its `onEscape`).
+   */
+  useEffect(() => {
+    if (!isActive) {
+      return;
+    }
+    const doc = trapDocument(containerRef.current);
+    const handleKeyDown = event => {
+      const container = containerRef.current;
+      if (!container) {
+        return;
+      }
+      if (event.key === 'Tab') {
+        if (event.defaultPrevented) {
+          // A control that handles Tab itself (an editor that indents) keeps
+          // focus where it is.
+          return;
+        }
+        const active = doc.activeElement;
+        // Any focused node counts, not only HTML elements: an SVG control
+        // inside the container is still inside.
+        if (active == null || !container.contains(active)) {
+          // The trap contains focus that is inside it; it does not pull in a
+          // Tab pressed elsewhere on the page. A layer can be open while focus
+          // legitimately sits outside it — a listbox popup anchored to its own
+          // input, a non-modal popover beside the content it annotates — and
+          // capturing that Tab would take the rest of the page away from
+          // keyboard users.
+          return;
+        }
+        if (hasInnerRegionHolding(container, active)) {
+          // A region nested in this one (a Dialog opened from a Dialog, a
+          // Popover inside a Drawer) holds focus; that region answers Tab.
+          return;
+        }
+
+        // Mark that keyboard navigation is leaving from inside the trap, so a
+        // focus that lands outside is redirected back in.
+        isKeyboardNavigationRef.current = true;
+        const focusable = getFocusableElements(container);
+        if (focusable.length === 0) {
+          // There is nowhere to advance to. Keep focus on the current
+          // programmatic target (for example a dialog panel with tabIndex=-1)
+          // rather than allowing the browser to move into background content.
+          event.preventDefault();
+          lastFocusRef.current = active;
+          isKeyboardNavigationRef.current = false;
+          return;
+        }
+        const first = focusable[0];
+        const last = focusable[focusable.length - 1];
+        if (doc.activeElement === container) {
+          // Programmatic initial focus can sit on the trap container itself
+          // (for example a dialog panel with no content controls). Move into
+          // the tabbable cycle instead of letting Tab escape to the page.
+          wrapFocus(event, event.shiftKey ? last : first);
+          return;
+        }
+
+        // Programmatic focus can also sit on an element that is not a Tab stop
+        // (a dialog title with tabIndex -1). Its place in document order
+        // decides the edge: nothing tabbable before it means Shift+Tab is
+        // leaving the region, nothing after it means Tab is.
+        const isProgrammaticStop = !focusable.includes(active);
+        if (event.shiftKey) {
+          // Shift+Tab: if on (or before) the first element, wrap to last
+          if (active === first || isProgrammaticStop && precedes(active, first)) {
+            wrapFocus(event, last);
+          }
+        } else {
+          // Tab: if on (or after) the last element, wrap to first
+          if (active === last || isProgrammaticStop && precedes(last, active)) {
+            wrapFocus(event, first);
+          }
+        }
+      }
+    };
+    doc.addEventListener('keydown', handleKeyDown);
+    return () => {
+      doc.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [containerRef, isActive]);
+}
+
 /**
  * Configuration for focus trap behavior
  */
@@ -218,9 +439,9 @@ export function useFocusTrapInternal(options) {
   const getRestoreTargetRef = useRef(getRestoreTarget);
   getRestoreTargetRef.current = getRestoreTarget;
   const containerRef = useRef(null);
-  const lastFocusRef = useRef(null);
-  // Track if focus change was triggered by keyboard (Tab key)
-  const isKeyboardNavigationRef = useRef(false);
+
+  // Tab and Shift+Tab wrap inside the container while the trap is active.
+  useFocusRegionContainment(containerRef, isActive);
 
   // Join the shared layer dismissal stack. The trap no longer listens for
   // Escape itself: the stack owns one listener and routes each press to the
@@ -313,134 +534,6 @@ export function useFocusTrapInternal(options) {
       }
     };
   }, [isActive]);
-
-  /**
-   * Handle focus events - redirect focus back into container if it escapes.
-   * Only redirects for keyboard navigation, not mouse clicks.
-   */
-  useEffect(() => {
-    if (!isActive) {
-      return;
-    }
-    const doc = trapDocument(containerRef.current);
-    const handleFocus = event => {
-      const container = containerRef.current;
-      if (!container) {
-        return;
-      }
-      const target = event.target;
-      if (container.contains(target)) {
-        // Focus is inside the container - track it
-        lastFocusRef.current = target;
-      } else if (isKeyboardNavigationRef.current) {
-        // Focus escaped via keyboard - redirect it back
-        const focusedFirst = focusFirstDescendant(container);
-
-        // If we're back at the same element (Shift+Tab from first element),
-        // try focusing the last element instead
-        if (focusedFirst && lastFocusRef.current === doc.activeElement) {
-          focusLastDescendant(container);
-        } else if (!focusedFirst && isHTMLElement(lastFocusRef.current) && container.contains(lastFocusRef.current)) {
-          // A modal surface may intentionally have no tabbable controls and
-          // place initial focus on a tabIndex={-1} heading or panel. Preserve
-          // that programmatic focus target instead of letting Tab escape.
-          attemptFocus(lastFocusRef.current);
-        }
-        lastFocusRef.current = doc.activeElement;
-      }
-      // If focus escaped via mouse click, don't redirect - let light dismiss handle it
-
-      // Reset keyboard navigation flag
-      isKeyboardNavigationRef.current = false;
-    };
-
-    // Use capture phase to intercept focus before it settles
-    doc.addEventListener('focus', handleFocus, true);
-    return () => {
-      doc.removeEventListener('focus', handleFocus, true);
-    };
-  }, [isActive]);
-
-  /**
-   * Handle Tab key to wrap focus at boundaries. Also tracks that keyboard
-   * navigation is occurring.
-   *
-   * No Escape here, and no IME guard: the shared stack owns the press, claims
-   * a composing Escape so no close request follows, and dismisses the trap
-   * through `onEscape` above. The trap renders no element of its own, so it
-   * has no `cancel` to answer either.
-   */
-  useEffect(() => {
-    if (!isActive) {
-      return;
-    }
-    const doc = trapDocument(containerRef.current);
-    const handleKeyDown = event => {
-      const container = containerRef.current;
-      if (!container) {
-        return;
-      }
-      if (event.key === 'Tab') {
-        const active = doc.activeElement;
-        // Any focused node counts, not only HTML elements: an SVG control
-        // inside the container is still inside.
-        if (active == null || !container.contains(active)) {
-          // The trap contains focus that is inside it; it does not pull in a
-          // Tab pressed elsewhere on the page. A layer can be open while focus
-          // legitimately sits outside it — a listbox popup anchored to its own
-          // input, a non-modal popover beside the content it annotates — and
-          // capturing that Tab would take the rest of the page away from
-          // keyboard users.
-          return;
-        }
-
-        // Mark that keyboard navigation is leaving from inside the trap, so a
-        // focus that lands outside is redirected back in.
-        isKeyboardNavigationRef.current = true;
-        const focusable = getFocusableElements(container);
-        if (focusable.length === 0) {
-          // There is nowhere to advance to. Keep focus on the current
-          // programmatic target (for example a dialog panel with tabIndex=-1)
-          // rather than allowing the browser to move into background content.
-          event.preventDefault();
-          lastFocusRef.current = active;
-          isKeyboardNavigationRef.current = false;
-          return;
-        }
-        const first = focusable[0];
-        const last = focusable[focusable.length - 1];
-        if (doc.activeElement === container) {
-          // Programmatic initial focus can sit on the trap container itself
-          // (for example a dialog panel with no content controls). Move into
-          // the tabbable cycle instead of letting Tab escape to the page.
-          event.preventDefault();
-          if (event.shiftKey) {
-            last.focus();
-          } else {
-            first.focus();
-          }
-          return;
-        }
-        if (event.shiftKey) {
-          // Shift+Tab: if on first element, wrap to last
-          if (doc.activeElement === first) {
-            event.preventDefault();
-            last.focus();
-          }
-        } else {
-          // Tab: if on last element, wrap to first
-          if (doc.activeElement === last) {
-            event.preventDefault();
-            first.focus();
-          }
-        }
-      }
-    };
-    doc.addEventListener('keydown', handleKeyDown);
-    return () => {
-      doc.removeEventListener('keydown', handleKeyDown);
-    };
-  }, [isActive, onEscape]);
   return {
     containerRef,
     focusFirst

package/dist/hooks/useKeyboardHighlight.d.ts

@@ -0,0 +1,17 @@
+import type { InteractionModality } from '../utils/interactionModality.js';
+interface KeyboardHighlight<KeyArgs extends unknown[], HoverArgs extends unknown[]> {
+    /** The last highlight move came from keyboard input. */
+    isKeyboardHighlight: boolean;
+    /** Records the current input for a path that moves the highlight. */
+    noteHighlightMove: () => void;
+    onKeyDown: (...args: KeyArgs) => void;
+    onItemMouseEnter: (...args: HoverArgs) => void;
+}
+/**
+ * A highlight moves from both keys and the pointer, but keyboard-only paint
+ * follows the shared interaction modality. The hook reads that modality each
+ * time the highlight moves.
+ */
+export declare function useKeyboardHighlight<KeyArgs extends unknown[], HoverArgs extends unknown[]>(readModality: () => InteractionModality, onKeyDown: (...args: KeyArgs) => void, onItemMouseEnter: (...args: HoverArgs) => void): KeyboardHighlight<KeyArgs, HoverArgs>;
+export {};
+//# sourceMappingURL=useKeyboardHighlight.d.ts.map

package/dist/hooks/useKeyboardHighlight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardHighlight.d.ts","sourceRoot":"","sources":["../../src/hooks/useKeyboardHighlight.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAEtE,UAAU,iBAAiB,CACzB,OAAO,SAAS,OAAO,EAAE,EACzB,SAAS,SAAS,OAAO,EAAE;IAE3B,wDAAwD;IACxD,mBAAmB,EAAE,OAAO,CAAC;IAC7B,qEAAqE;IACrE,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,gBAAgB,EAAE,CAAC,GAAG,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CAChD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,SAAS,OAAO,EAAE,EACzB,SAAS,SAAS,OAAO,EAAE,EAE3B,YAAY,EAAE,MAAM,mBAAmB,EACvC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,KAAK,IAAI,EACrC,gBAAgB,EAAE,CAAC,GAAG,IAAI,EAAE,SAAS,KAAK,IAAI,GAC7C,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,CA4BvC"}

package/dist/hooks/useKeyboardHighlight.js

@@ -0,0 +1,38 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file useKeyboardHighlight.ts
+ * @input The owning combobox's shared modality reader and its keydown and
+ *   option-hover handlers
+ * @output Exports useKeyboardHighlight: whether the last highlight move came
+ *   from keyboard input, the handlers wrapped to record each move, and the
+ *   recorder for other paths that move the highlight
+ * @position Internal hook; used by Selector and MultiSelector to draw
+ *   keyboard-only highlight paint
+ */
+import { useCallback, useState } from 'react';
+/**
+ * A highlight moves from both keys and the pointer, but keyboard-only paint
+ * follows the shared interaction modality. The hook reads that modality each
+ * time the highlight moves.
+ */
+export function useKeyboardHighlight(readModality, onKeyDown, onItemMouseEnter) {
+  const [isKeyboardHighlight, setIsKeyboardHighlight] = useState(() => readModality() === 'keyboard');
+  const noteHighlightMove = useCallback(() => setIsKeyboardHighlight(readModality() === 'keyboard'), [readModality]);
+  const handleKeyDown = useCallback((...args) => {
+    onKeyDown(...args);
+    noteHighlightMove();
+  }, [onKeyDown, noteHighlightMove]);
+  const handleItemMouseEnter = useCallback((...args) => {
+    onItemMouseEnter(...args);
+    noteHighlightMove();
+  }, [onItemMouseEnter, noteHighlightMove]);
+  return {
+    isKeyboardHighlight,
+    noteHighlightMove,
+    onKeyDown: handleKeyDown,
+    onItemMouseEnter: handleItemMouseEnter
+  };
+}

package/dist/hooks/useMediaQuery.d.ts

@@ -1,7 +1,8 @@
 /**
  * SSR-safe media query hook.
  * Returns whether the given media query matches. Where the window has no
- * `matchMedia`, as in a test DOM, it returns `serverDefault`.
+ * `matchMedia`, as in a test DOM, it returns `serverDefault`. All callers of
+ * the same query share one listener.
  *
  * @param query - CSS media query string
  * @param serverDefault - Value to return during SSR. Pass a server-side hint

package/dist/hooks/useMediaQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaQuery.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,UAAQ,GAAG,OAAO,CAyB3E"}
+{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../src/hooks/useMediaQuery.ts"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,UAAQ,GAAG,OAAO,CAiB3E"}

package/dist/hooks/useMediaQuery.js

@@ -4,23 +4,56 @@
 
 /**
  * @file useMediaQuery.ts
- * @input Uses React useSyncExternalStore, useCallback
+ * @input Uses React useSyncExternalStore, useCallback, and watchMediaQuery
+ *   (utils/coarsePointer.ts)
  * @output Exports useMediaQuery hook for responsive breakpoint detection
  * @position Core hook; used by consumers for responsive patterns
  *
  * SSR-safe media query hook that subscribes to window.matchMedia changes
  * via useSyncExternalStore — the canonical React pattern for external
- * browser state.
+ * browser state. Every caller of a query shares one watch.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/index.ts
  */
 import { useCallback, useSyncExternalStore } from 'react';
+import { watchMediaQuery } from "../utils/coarsePointer.js";
+const watches = new Map();
+function subscribeToQuery(query, reader) {
+  // A DOM without `matchMedia`, such as a test DOM, has nothing to watch.
+  if (typeof window.matchMedia !== 'function') {
+    return () => {};
+  }
+  let watch = watches.get(query);
+  if (watch == null) {
+    const readers = new Set();
+    const stop = watchMediaQuery(window, query, () => {
+      for (const each of Array.from(readers)) {
+        each();
+      }
+    });
+    watch = {
+      readers,
+      stop
+    };
+    watches.set(query, watch);
+  }
+  const entry = watch;
+  entry.readers.add(reader);
+  return () => {
+    entry.readers.delete(reader);
+    if (entry.readers.size === 0 && watches.get(query) === entry) {
+      entry.stop();
+      watches.delete(query);
+    }
+  };
+}
 
 /**
  * SSR-safe media query hook.
  * Returns whether the given media query matches. Where the window has no
- * `matchMedia`, as in a test DOM, it returns `serverDefault`.
+ * `matchMedia`, as in a test DOM, it returns `serverDefault`. All callers of
+ * the same query share one listener.
  *
  * @param query - CSS media query string
  * @param serverDefault - Value to return during SSR. Pass a server-side hint
@@ -33,15 +66,7 @@ import { useCallback, useSyncExternalStore } from 'react';
  * ```
  */
 export function useMediaQuery(query, serverDefault = false) {
-  const subscribe = useCallback(onStoreChange => {
-    // A DOM without `matchMedia`, such as a test DOM, has nothing to watch.
-    if (typeof window.matchMedia !== 'function') {
-      return () => {};
-    }
-    const mql = window.matchMedia(query);
-    mql.addEventListener('change', onStoreChange);
-    return () => mql.removeEventListener('change', onStoreChange);
-  }, [query]);
+  const subscribe = useCallback(onStoreChange => subscribeToQuery(query, onStoreChange), [query]);
   const getSnapshot = useCallback(() => typeof window.matchMedia === 'function' ? window.matchMedia(query).matches : serverDefault, [query, serverDefault]);
   const getServerSnapshot = useCallback(() => serverDefault, [serverDefault]);
   return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);

package/dist/hooks/useMenuPress.d.ts

@@ -2,7 +2,8 @@
  * @file useMenuPress.ts
  * @input The menu root, its trigger, the enabled-row selector, and callbacks
  *   for opening, highlighting, activating and dismissing
- * @output useMenuPress, the marker attributes, and the activation mark
+ * @output useMenuPress, the marker attributes, the activation mark, and the
+ *   internal useDropdownMenuPress entry with its touch model
  * @position Core hook for DropdownMenu, ContextMenu, DropdownMenuSubMenu,
  *   Selector and MenuBottomSheetActionList. The transition table lives in
  *   menuPressGesture.ts.
@@ -119,6 +120,30 @@ export interface UseMenuPressReturn {
     /** End the gesture in flight with nothing acting (the menu closed). */
     cancel: () => void;
 }
+/**
+ * DropdownMenu's options for the press model: everything the public hook
+ * takes, plus its touch model. DropdownMenu reaches the touch model through
+ * its `presentation`, so the public hook has no such option.
+ *
+ * @internal
+ */
+export interface DropdownMenuPressOptions extends UseMenuPressOptions {
+    /**
+     * How the finger that opened the menu from the trigger picks.
+     * `'pointer'`: its opening press follows the settle rule. `'uikit'`: it
+     * picks only after UIMenu's handoff distance, so the row that appeared
+     * under it never acts on a still lift. A mouse is unaffected.
+     * @default 'pointer'
+     */
+    touchModel?: 'pointer' | 'uikit';
+}
+/**
+ * What core's own menus get from {@link useDropdownMenuPress}: the public
+ * return. Not exported from the hooks entry point.
+ *
+ * @internal
+ */
+export type DropdownMenuPressReturn = UseMenuPressReturn;
 /**
  * The press model for a menu: the row under the release acts, the highlight
  * follows a held pointer, and a mouse opens the menu on press.
@@ -155,4 +180,12 @@ export interface UseMenuPressReturn {
  * ```
  */
 export declare function useMenuPress(options: UseMenuPressOptions): UseMenuPressReturn;
+/**
+ * The press model with DropdownMenu's touch model
+ * ({@link DropdownMenuPressOptions.touchModel}). Not exported from the hooks
+ * entry point.
+ *
+ * @internal
+ */
+export declare function useDropdownMenuPress(options: DropdownMenuPressOptions): DropdownMenuPressReturn;
 //# sourceMappingURL=useMenuPress.d.ts.map

package/dist/hooks/useMenuPress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMenuPress.d.ts","sourceRoot":"","sources":["../../src/hooks/useMenuPress.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAML,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AAEf,OAAO,EAML,KAAK,oBAAoB,EAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAiBpD,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,yBAAyB,MAAwB,CAAC;AAC/D,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,MAAyB,CAAC;AAC/D;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,KAAK,CAAC;AAM9C,oFAAoF;AACpF,eAAO,MAAM,6BAA6B,KAAK,CAAC;AAUhD;;;;;GAKG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C;AAED,4DAA4D;AAC5D,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED,MAAM,WAAW,mBAAmB;IAClC,+EAA+E;IAC/E,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACvC,uEAAuE;IACvE,UAAU,CAAC,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAC3C;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CAAC,WAAW,EAAE,oBAAoB,KAAK,OAAO,CAAC;IAChE;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IAC/D,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;IACvC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAAC;IACnD,mBAAmB;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,SAAS,EAAE;QACT,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;QAChE,CAAC,iBAAiB,CAAC,EAAE,EAAE,CAAC;KACzB,CAAC;IACF,yEAAyE;IACzE,YAAY,EAAE;QACZ,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;QAChE,aAAa,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;KAC/D,CAAC;IACF;;;;OAIG;IACH,uBAAuB,EAAE,MAAM,OAAO,CAAC;IACvC,uEAAuE;IACvE,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AA0DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAglB7E"}
+{"version":3,"file":"useMenuPress.d.ts","sourceRoot":"","sources":["../../src/hooks/useMenuPress.ts"],"names":[],"mappings":"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"}