@astryxdesign/core 0.7.8 → 0.7.9-canary.0a64fdb

package/dist/hooks/useClickableContainer.js

@@ -5,11 +5,13 @@
 /**
  * @file useClickableContainer.ts
  * @input Container ref, interactive element ref, click/href handlers
- * @output onClick and onMouseUp handlers for the container; INTERACTIVE_SELECTORS list;
+ * @output onClick, onMouseUp and onPointerDown handlers for the container;
+ *   INTERACTIVE_SELECTORS list;
  *   hasInteractiveAncestor and the shared innermostInteractive walk
  * @position Core hook for clickable containers with nested interactive
  *   elements. A click on a nested button or link does not run the card's
- *   action. Each navigation passes the rule in utils/safeUrl.ts first.
+ *   action, and a finger press there shows no press on the card. Each navigation
+ *   passes the rule in utils/safeUrl.ts first.
  *
  * SYNC: When modified, update:
  * - /packages/core/src/hooks/index.ts (export)
@@ -17,6 +19,7 @@
 import { useCallback, useEffect } from 'react';
 import { isLayerSurface } from "../Layer/layerSurfacePress.js";
 import { isSafeUrl } from "../utils/safeUrl.js";
+import { cancelPress } from "../utils/pressFeedback.js";
 
 /**
  * The attribute this hook sets on the container it makes clickable. A click
@@ -90,6 +93,24 @@ function belongsToSomethingElse(element) {
   return matchesInteractiveSelectors(element) || isLayerSurface(element);
 }
 
+/**
+ * The touch half of a container's press rule: a finger press that starts on a nested interactive element
+ * other than the container's own action does not activate the container, so
+ * it ends the press controller's paint on `container`. A mouse or pen press,
+ * and a press on the container's surface or on `ownAction`, are left alone.
+ * Not part of the package's public API.
+ */
+export function cancelNestedTouchPress(event, container, ownAction) {
+  const target = event.target;
+  if (event.pointerType !== 'touch' || container == null || !(target instanceof Element) || target === event.currentTarget || !hasInteractiveAncestor(target, container) ||
+  // The container's own action, such as the control it delegates to: a
+  // press on it activates the container.
+  ownAction?.contains(target) === true) {
+    return;
+  }
+  cancelPress(container);
+}
+
 /**
  * Check if there's a text selection inside the node (don't navigate on text select)
  *
@@ -123,12 +144,16 @@ export function hasTextSelection(node) {
  * @example
  * ```
  * const containerRef = useRef<HTMLDivElement>(null);
- * const { onClick, onMouseUp } = useClickableContainer({
+ * const { onClick, onMouseUp, onPointerDown } = useClickableContainer({
  *   containerRef,
  *   onClick: () => console.log('card clicked'),
  * });
  * return (
- *   <div ref={containerRef} onClick={onClick} onMouseUp={onMouseUp}>
+ *   <div
+ *     ref={containerRef}
+ *     onClick={onClick}
+ *     onMouseUp={onMouseUp}
+ *     onPointerDown={onPointerDown}>
  *     <p>Click anywhere on this card</p>
  *     <button onClick={() => alert('button')}>Nested button</button>
  *   </div>
@@ -226,8 +251,19 @@ export function useClickableContainer({
       window.open(href, '_blank', 'noopener');
     }
   }, [containerRef, href, disabled]);
+
+  // The press-state counterpart of onClick's rule, for touch: a finger press
+  // that would not activate the container shows no press on it. A mouse or
+  // pen press keeps its `:active` paint.
+  const onPointerDown = useCallback(event => {
+    if (disabled) {
+      return;
+    }
+    cancelNestedTouchPress(event, containerRef.current, interactiveRef?.current ?? null);
+  }, [containerRef, interactiveRef, disabled]);
   return {
     onClick,
-    onMouseUp
+    onMouseUp,
+    onPointerDown
   };
 }

package/dist/hooks/useFocusTrap.d.ts

@@ -24,6 +24,16 @@ export declare function useFocusTrapEscapeCompatibilitySignal(isActive: boolean)
  * the trap does. Not re-exported from the package's `hooks` entry.
  */
 export declare function getFocusableElements(container: HTMLElement): HTMLElement[];
+/**
+ * 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 declare function useFocusRegionContainment(containerRef: React.RefObject<HTMLElement | null>, isActive: boolean): void;
 /**
  * Configuration for focus trap behavior
  */

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

@@ -1 +1 @@
-{"version":3,"file":"useFocusTrap.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusTrap.ts"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,qCAAqC,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAY7E;AA+BD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,GAAG,WAAW,EAAE,CAI1E;AA8DD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IACrE;;OAEG;IACH,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAExC;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,OAAO,EAAE,mBAAmB,GAC3B,kBAAkB,CAAC,CAAC,CAAC,CAEvB;AAED;;GAEG;AACH,UAAU,wBAAyB,SAAQ,mBAAmB;IAC5D;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;CAC7C;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,EAAE,wBAAwB,GAChC,kBAAkB,CAAC,CAAC,CAAC,CA2QvB"}
+{"version":3,"file":"useFocusTrap.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusTrap.ts"],"names":[],"mappings":"AAgCA;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,qCAAqC,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAY7E;AAwDD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,GAAG,WAAW,EAAE,CAI1E;AA8GD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACjD,QAAQ,EAAE,OAAO,GAChB,IAAI,CAgLN;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IACrE;;OAEG;IACH,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAExC;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,OAAO,EAAE,mBAAmB,GAC3B,kBAAkB,CAAC,CAAC,CAAC,CAEvB;AAED;;GAEG;AACH,UAAU,wBAAyB,SAAQ,mBAAmB;IAC5D;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;CAC7C;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,EAAE,wBAAwB,GAChC,kBAAkB,CAAC,CAAC,CAAC,CAwHvB"}

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/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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"}