@astryxdesign/core 0.7.7-canary.c0929c8 → 0.7.7-canary.c19ca12

package/dist/utils/browserClickWait.d.ts

@@ -0,0 +1,35 @@
+/**
+ * How long a tap's lift waits for the browser's own click, ms. The browser
+ * sends that click with the lift when the page has no double-tap delay. The
+ * wait runs out for a lift that the browser does not count as a click, such
+ * as a hold. It also runs out when a busy main thread holds the click back.
+ */
+export declare const BROWSER_CLICK_WAIT_MS = 300;
+/** What a control does when the browser's click comes, or does not. */
+export interface BrowserClickWaitHandlers {
+    /** The browser's click ran its handlers. `isCancelled`: one cancelled it. */
+    readonly onClicked: (isCancelled: boolean) => void;
+    /** No browser click came in time. */
+    readonly onNoClick: () => void;
+}
+/**
+ * Waits for the browser's own click inside `target` after a tap's lift. That
+ * click is the activation: `onClicked` runs once its handlers have run. With
+ * no click in time, `onNoClick` runs. The returned call ends the wait at once
+ * and leaves no listener or timer behind.
+ */
+export declare function awaitBrowserClick(target: Element, { onClicked, onNoClick }: BrowserClickWaitHandlers): () => void;
+/**
+ * Click `element` (its own `click()`, so its activation behavior and every
+ * handler run as for any click) and report whether a handler cancelled it.
+ * The event is read from a capture listener that exists only for the call.
+ */
+export declare function clickAndReport(element: HTMLElement): boolean;
+/**
+ * Clicks `element` for a lift the control decided itself, and reports
+ * whether a handler cancelled the click. The shared click guard swallows the
+ * browser's own click for the same lift, if it comes later, so the lift
+ * activates once.
+ */
+export declare function clickForLift(element: HTMLElement): boolean;
+//# sourceMappingURL=browserClickWait.d.ts.map

package/dist/utils/browserClickWait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browserClickWait.d.ts","sourceRoot":"","sources":["../../src/utils/browserClickWait.ts"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,uEAAuE;AACvE,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,OAAO,KAAK,IAAI,CAAC;IACnD,qCAAqC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,OAAO,EACf,EAAC,SAAS,EAAE,SAAS,EAAC,EAAE,wBAAwB,GAC/C,MAAM,IAAI,CAwDZ;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAe5D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAG1D"}

package/dist/utils/browserClickWait.js

@@ -0,0 +1,123 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file browserClickWait.ts
+ * @input An element a tap's lift released on, and the control that acts on
+ *   its click
+ * @output BROWSER_CLICK_WAIT_MS, awaitBrowserClick, clickForLift and
+ *   clickAndReport
+ * @position The one wait for the browser's click after a tap, shared by
+ *   Switch/useSwitchTouch.ts and SegmentedControl/useSegmentedTouchTracking.ts.
+ *   It swallows nothing: utils/clickGuard.ts is the one guard for a late click.
+ *
+ * SYNC: When modified, update browserClickWait.test.ts.
+ */
+
+import { armClickGuard, withoutClickGuard } from "./clickGuard.js";
+import { subscribeInput } from "./inputStream.js";
+
+/**
+ * How long a tap's lift waits for the browser's own click, ms. The browser
+ * sends that click with the lift when the page has no double-tap delay. The
+ * wait runs out for a lift that the browser does not count as a click, such
+ * as a hold. It also runs out when a busy main thread holds the click back.
+ */
+export const BROWSER_CLICK_WAIT_MS = 300;
+
+/** What a control does when the browser's click comes, or does not. */
+
+/**
+ * Waits for the browser's own click inside `target` after a tap's lift. That
+ * click is the activation: `onClicked` runs once its handlers have run. With
+ * no click in time, `onNoClick` runs. The returned call ends the wait at once
+ * and leaves no listener or timer behind.
+ */
+export function awaitBrowserClick(target, {
+  onClicked,
+  onNoClick
+}) {
+  const view = target.ownerDocument.defaultView;
+  if (view == null) {
+    // A document with no window gets no click: the wait runs out at once.
+    let isEnded = false;
+    queueMicrotask(() => {
+      if (!isEnded) {
+        onNoClick();
+      }
+    });
+    return () => {
+      isEnded = true;
+    };
+  }
+  let isDone = false;
+  let report = null;
+  let timer = null;
+  let stopListening = null;
+  const stop = () => {
+    isDone = true;
+    stopListening?.();
+    stopListening = null;
+    if (timer != null) {
+      view.clearTimeout(timer);
+      timer = null;
+    }
+  };
+  stopListening = subscribeInput(view, 'click', event => {
+    if (isDone || !event.isTrusted || !target.contains(event.target)) {
+      return;
+    }
+    stop();
+    // After every handler has run: was it cancelled?
+    report = view.setTimeout(() => {
+      report = null;
+      onClicked(event.defaultPrevented);
+    }, 0);
+  });
+  timer = view.setTimeout(() => {
+    if (isDone) {
+      return;
+    }
+    stop();
+    onNoClick();
+  }, BROWSER_CLICK_WAIT_MS);
+  return () => {
+    stop();
+    if (report != null) {
+      view.clearTimeout(report);
+      report = null;
+    }
+  };
+}
+
+/**
+ * Click `element` (its own `click()`, so its activation behavior and every
+ * handler run as for any click) and report whether a handler cancelled it.
+ * The event is read from a capture listener that exists only for the call.
+ */
+export function clickAndReport(element) {
+  const view = element.ownerDocument.defaultView;
+  let clicked = null;
+  const grab = event => {
+    if (clicked == null && event.target === element) {
+      clicked = event;
+    }
+  };
+  view?.addEventListener('click', grab, true);
+  try {
+    element.click();
+  } finally {
+    view?.removeEventListener('click', grab, true);
+  }
+  return clicked?.defaultPrevented === true;
+}
+
+/**
+ * Clicks `element` for a lift the control decided itself, and reports
+ * whether a handler cancelled the click. The shared click guard swallows the
+ * browser's own click for the same lift, if it comes later, so the lift
+ * activates once.
+ */
+export function clickForLift(element) {
+  armClickGuard(element.ownerDocument);
+  return withoutClickGuard(() => clickAndReport(element));
+}

package/dist/utils/clickGuard.d.ts

@@ -12,9 +12,22 @@ export interface ClickGuardOptions {
      * @default false
      */
     readonly staysInstalled?: boolean;
+    /**
+     * The gesture host's arm at a claimed touch's lift: the guard also takes
+     * that touch's late `mousedown` and `mouseup` while it is armed.
+     * @default false
+     */
+    readonly takesLateMouse?: boolean;
+    /**
+     * The menu press model's arm at a finger's release: the guard also cancels
+     * that touch's `touchend`, so the browser creates no click for it. A
+     * cancelled `touchend` disarms the guard.
+     * @default false
+     */
+    readonly cancelsTouchEnd?: boolean;
 }
 /** Swallow the browser's next click on `doc` (see the file header). */
-export declare function armClickGuard(doc: Document, { staysInstalled }?: ClickGuardOptions): void;
+export declare function armClickGuard(doc: Document, { staysInstalled, takesLateMouse, cancelsTouchEnd, }?: ClickGuardOptions): void;
 /** Stop swallowing on `doc`; idempotent. */
 export declare function disarmClickGuard(doc: Document): void;
 /** Whether the guard on `doc` would swallow the next click. */

package/dist/utils/clickGuard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clickGuard.d.ts","sourceRoot":"","sources":["../../src/utils/clickGuard.ts"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,yCAAyC;AACzC,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CACnC;AA8BD,uEAAuE;AACvE,wBAAgB,aAAa,CAC3B,GAAG,EAAE,QAAQ,EACb,EAAC,cAAsB,EAAC,GAAE,iBAAsB,GAC/C,IAAI,CAoBN;AAED,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAYpD;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAOzD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAQ/C"}
+{"version":3,"file":"clickGuard.d.ts","sourceRoot":"","sources":["../../src/utils/clickGuard.ts"],"names":[],"mappings":"AA0CA;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC,yCAAyC;AACzC,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC;AA8BD,uEAAuE;AACvE,wBAAgB,aAAa,CAC3B,GAAG,EAAE,QAAQ,EACb,EACE,cAAsB,EACtB,cAAsB,EACtB,eAAuB,GACxB,GAAE,iBAAsB,GACxB,IAAI,CA+CN;AAED,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAYpD;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAOzD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAQ/C"}

package/dist/utils/clickGuard.js

@@ -21,6 +21,16 @@
 // page adds later (AST-057, AST-094). If only the gesture host arms it, the
 // click listener stays only while the guard is armed.
 //
+// An arm at a claimed touch's lift also takes that touch's late `mousedown`
+// and `mouseup`. WebKit sends them a few ms after a held tap's cancelled
+// `touchend`, aimed at whatever is under the finger by then. They go with
+// the click, the next `pointerdown` or the window, as the guard does.
+//
+// The menu press model's arm at a finger's release also cancels that touch's
+// `touchend`, so the browser creates no click and no compatibility mouse
+// events. A busy main thread can otherwise hold that click past the window,
+// when a drill-in has put another row under the finger.
+//
 // Some clicks always pass:
 // - a click with `detail` 0: a keyboard's, a screen reader's, or one that the
 //   page dispatches;
@@ -61,7 +71,9 @@ function listenForClicks(view) {
 
 /** Swallow the browser's next click on `doc` (see the file header). */
 export function armClickGuard(doc, {
-  staysInstalled = false
+  staysInstalled = false,
+  takesLateMouse = false,
+  cancelsTouchEnd = false
 } = {}) {
   const view = doc.defaultView;
   if (view == null) {
@@ -83,6 +95,30 @@ export function armClickGuard(doc, {
   guard.unsubscribers.push(
   // The next press is a new gesture: its click must never be eaten.
   subscribeInput(view, 'pointerdown', () => disarmClickGuard(doc)));
+  if (takesLateMouse) {
+    for (const type of ['mousedown', 'mouseup']) {
+      guard.unsubscribers.push(subscribeInput(view, type, swallowLateMouse, {
+        cancels: true
+      }));
+    }
+  }
+  if (cancelsTouchEnd) {
+    // A touch sends its pointerup before its touchend, so the next touchend is
+    // that touch's own. The next pointerdown disarms the guard first.
+    const stopTouchEnd = subscribeInput(view, 'touchend', event => {
+      stopTouchEnd();
+      // A touchend that the browser took for a scroll is not cancelable.
+      // The guard stays armed for a click that may follow it.
+      if (event.cancelable) {
+        event.preventDefault();
+        // No click follows a cancelled touchend.
+        disarmClickGuard(doc);
+      }
+    }, {
+      cancels: true
+    });
+    guard.unsubscribers.push(stopTouchEnd);
+  }
   guard.timer = setTimeout(() => disarmClickGuard(doc), CLICK_GUARD_WINDOW_MS);
 }
 
@@ -133,6 +169,15 @@ export function __resetClickGuardForTest() {
     stayingClickListeners.delete(window);
   }
 }
+
+/** Swallows a claimed touch's late `mousedown` or `mouseup`. */
+function swallowLateMouse(event) {
+  if (isExempt(event)) {
+    return;
+  }
+  event.preventDefault();
+  event.stopImmediatePropagation();
+}
 function isExempt(event) {
   if (event.detail === 0 || unguardedDepth > 0) {
     return true;

package/dist/utils/dateParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dateParser.d.ts","sourceRoot":"","sources":["../../src/utils/dateParser.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,EAAC,KAAK,SAAS,EAAqC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EACL,gBAAgB,IAAI,QAAQ,EAC5B,cAAc,IAAI,SAAS,GAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,MAAa,GAAG,OAAO,CAO/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,MAAa,GACpB,SAAS,GAAG,IAAI,CAsGlB"}
+{"version":3,"file":"dateParser.d.ts","sourceRoot":"","sources":["../../src/utils/dateParser.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,EAAC,KAAK,SAAS,EAAqC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EACL,gBAAgB,IAAI,QAAQ,EAC5B,cAAc,IAAI,SAAS,GAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,GAAE,MAAa,GAAG,OAAO,CAO/D;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,MAAa,GACpB,SAAS,GAAG,IAAI,CAiHlB"}

package/dist/utils/dateParser.js

@@ -27,6 +27,11 @@ export function isLocaleDayFirst(locale = 'en') {
   return dayIndex < monthIndex;
 }
 
+// Built at run time: a Unicode property escape in a literal fails a source
+// build whose Babel lacks the Unicode data.
+const LETTER_FREE = new RegExp('^[^\\p{L}]+$', 'u');
+const YEAR_FIRST = new RegExp('^\\d{4}[^\\p{L}\\d]', 'u');
+
 /**
  * Parses user input into a PlainDate.
  *
@@ -122,6 +127,13 @@ export function parseDateInput(input, locale = 'en') {
   if (/^\d+$/.test(trimmed)) {
     return null;
   }
+  // In a day-first locale, letter-free text that no form above matched is not
+  // a date. Native `Date` reads `a/b/c` month first. It also takes a year of
+  // one to three digits. So "12/01/2" gives a wrong date. A four-digit year
+  // written first is not ambiguous.
+  if (isLocaleDayFirst(locale) && LETTER_FREE.test(trimmed) && !YEAR_FIRST.test(trimmed)) {
+    return null;
+  }
   const parsed = new Date(trimmed);
   if (!isNaN(parsed.getTime())) {
     const fromDate = plainDateFromDate(parsed);

package/dist/utils/focusReturn.d.ts

@@ -75,4 +75,19 @@ export declare function moveFocusLeftBehind(note: FocusWithin | null, target: HT
  * in the component that calls this.
  */
 export declare function focusForLastInput(element: HTMLElement, options?: FocusOptions, modality?: InteractionModality): void;
+/**
+ * Prepares the focus return for an open surface that may be removed while
+ * open (rendered only while open, or removed with its view). Removing a
+ * `<dialog>` runs no close and no browser focus return. Call this while the
+ * surface is mounted: it reads the frame that hosts the surface now, because a
+ * removed frame's document has no window. Call the returned function from the
+ * effect cleanup with the opener.
+ *
+ * Once the commit has finished, focus moves to the opener only when the
+ * surface really left the document (StrictMode's simulated unmount keeps it),
+ * the opener is still on the page, and the removal lost focus, both in the
+ * surface's document and in the document that hosts its frame. A control the
+ * user pressed outside the surface, or outside its frame, keeps its focus.
+ */
+export declare function prepareFocusReturnOnRemoval(surface: Element): (opener: Element | null) => void;
 //# sourceMappingURL=focusReturn.d.ts.map

package/dist/utils/focusReturn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,QAAmB,GAAG,OAAO,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM5E;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACxC,WAAW,GAAG,IAAI,CAMpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,GAAG,IAAI,EACxB,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,GAAE,OAAO,GAAG,IAAW,GAC5B,OAAO,CAUT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,GAAE,mBAAqD,GAC9D,IAAI,CA2BN"}
+{"version":3,"file":"focusReturn.d.ts","sourceRoot":"","sources":["../../src/utils/focusReturn.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,GAAG,GAAE,QAAmB,GAAG,OAAO,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,CAM5E;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACxC,WAAW,GAAG,IAAI,CAMpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,GAAG,IAAI,EACxB,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,GAAE,OAAO,GAAG,IAAW,GAC5B,OAAO,CAUT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,YAAY,EACtB,QAAQ,GAAE,mBAAqD,GAC9D,IAAI,CA2BN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,GACf,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,KAAK,IAAI,CAYlC"}

package/dist/utils/focusReturn.js

@@ -126,4 +126,32 @@ export function focusForLastInput(element, options, modality = getInteractionMod
     ...options,
     focusVisible: false
   });
+}
+
+/**
+ * Prepares the focus return for an open surface that may be removed while
+ * open (rendered only while open, or removed with its view). Removing a
+ * `<dialog>` runs no close and no browser focus return. Call this while the
+ * surface is mounted: it reads the frame that hosts the surface now, because a
+ * removed frame's document has no window. Call the returned function from the
+ * effect cleanup with the opener.
+ *
+ * Once the commit has finished, focus moves to the opener only when the
+ * surface really left the document (StrictMode's simulated unmount keeps it),
+ * the opener is still on the page, and the removal lost focus, both in the
+ * surface's document and in the document that hosts its frame. A control the
+ * user pressed outside the surface, or outside its frame, keeps its focus.
+ */
+export function prepareFocusReturnOnRemoval(surface) {
+  const host = surface.ownerDocument.defaultView?.frameElement ?? null;
+  return opener => {
+    queueMicrotask(() => {
+      if (surface.isConnected || opener == null || !opener.isConnected) {
+        return;
+      }
+      if (isFocusLost(surface) && (host == null || isFocusLost(host))) {
+        focusForLastInput(opener);
+      }
+    });
+  };
 }

package/dist/utils/interactionOverlay.stylex.d.ts

@@ -9,8 +9,9 @@
  * SYNC: When modified, update pressFeedback.ts, pressGesture.ts (the fade
  * clock), hooks/usePressFeedback.doc.mjs, the components that paint the touch
  * press off an ancestor scope or a pseudo-element (Switch, Tab,
- * CheckboxInput, RadioListItem, ClickableCard, SelectableCard, Thumbnail)
- * and scripts/build-css.test.mjs.
+ * CheckboxInput, RadioListItem, ClickableCard, SelectableCard, Thumbnail),
+ * Button (a tracked action sizes its `:active` image to zero) and
+ * scripts/build-css.test.mjs.
  */
 import * as stylex from '@stylexjs/stylex';
 /**

package/dist/utils/interactionOverlay.stylex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactionOverlay.stylex.d.ts","sourceRoot":"","sources":["../../src/utils/interactionOverlay.stylex.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AAmCH,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAG3C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;WAEpB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;IACtB,iEAAiE;;CAEjE,CAAC;AA8HH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8HnC,CAAC"}
+{"version":3,"file":"interactionOverlay.stylex.d.ts","sourceRoot":"","sources":["../../src/utils/interactionOverlay.stylex.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AAmCH,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAG3C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS;;WAEpB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;IACtB,iEAAiE;;CAEjE,CAAC;AA8HH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8HnC,CAAC"}

package/dist/utils/interactionOverlay.stylex.js

@@ -15,8 +15,9 @@
  * SYNC: When modified, update pressFeedback.ts, pressGesture.ts (the fade
  * clock), hooks/usePressFeedback.doc.mjs, the components that paint the touch
  * press off an ancestor scope or a pseudo-element (Switch, Tab,
- * CheckboxInput, RadioListItem, ClickableCard, SelectableCard, Thumbnail)
- * and scripts/build-css.test.mjs.
+ * CheckboxInput, RadioListItem, ClickableCard, SelectableCard, Thumbnail),
+ * Button (a tracked action sizes its `:active` image to zero) and
+ * scripts/build-css.test.mjs.
  */
 
 // Every surface that paints a press uses one of these styles, so a change to

package/dist/utils/pressFeedback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../src/utils/pressFeedback.ts"],"names":[],"mappings":"AAiDA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,qDAAqD;AACrD,eAAO,MAAM,cAAc,EAAE;IAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAA;CAE/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AA4nB5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CA0BjD"}
+{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../src/utils/pressFeedback.ts"],"names":[],"mappings":"AAkDA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,0BAA0B,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,sBAAsB,CAAC;AAErD,qDAAqD;AACrD,eAAO,MAAM,cAAc,EAAE;IAAC,QAAQ,CAAC,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAA;CAE/D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAwoB5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,IAAI,CA0BjD"}

package/dist/utils/pressFeedback.js

@@ -2,8 +2,8 @@
 
 /**
  * @file pressFeedback.ts
- * @input The press state machine (pressGesture.ts), the menu-press marker
- *   (hooks/menuPressMarker.ts) and the document's pointer, keyboard, scroll and
+ * @input The press state machine (pressGesture.ts), the menu-press and
+ *   press-group markers and the document's pointer, keyboard, scroll and
  *   visibility events
  * @output PRESSABLE_ATTRIBUTE, PRESSED_ATTRIBUTE, pressableProps and
  *   installPressFeedback
@@ -38,6 +38,7 @@ import { isCoarsePointer, watchCoarsePointer } from "./coarsePointer.js";
 import { subscribeInput } from "./inputStream.js";
 import { TOUCH_QUERY } from "./touchPresentation.js";
 import { holdsPressThroughDrag } from "../privateAttributes/pressHoldsDrag.stylex.js";
+import { isTrackedByGroup } from "../privateAttributes/pressGroupItem.stylex.js";
 
 /**
  * The marker the controller finds with `closest()`. Every Astryx component
@@ -288,14 +289,19 @@ function stylesheetDroppedActive() {
 
 /**
  * The surface a mouse button's or the Space key's press paints, if any: the
- * innermost marked surface, outside a menu. A key's press paints only a
- * focused element that is itself the surface, as `:active` does.
+ * innermost marked surface, outside a menu and off a tracked action. A key's
+ * press paints only a focused element that is itself the surface, as
+ * `:active` does.
  */
 function buttonSurfaceAt(target, pointerId) {
   const element = surfaceAt(target);
   if (element == null || element.closest(MENU_PRESS_ROOT) != null) {
     return null;
   }
+  // A group's tracker follows pointers only, so a key's press stays here.
+  if (pointerId != null && isTrackedByGroup(element)) {
+    return null;
+  }
   if (pointerId == null && element !== target) {
     return null;
   }
@@ -379,7 +385,9 @@ function onPointerDown(event) {
   const braking = element != null && scrollerIsBraking(element);
   lastTouchAt = Date.now();
   lastTouchTarget = event.target instanceof Node ? event.target : null;
-  if (element == null || braking) {
+  // A group's tracker paints a tracked action, so two writers would erase each
+  // other's paint. The touch still counts for the brake above.
+  if (element == null || braking || isTrackedByGroup(element)) {
     return;
   }
   takeOver(button, element);
@@ -509,6 +517,11 @@ function activatesOnSpace(target) {
   return target instanceof HTMLInputElement && SPACE_ACTIVATED_INPUT_TYPES.has(target.type);
 }
 
+/** A tracked action takes no `:active` paint, so a key's press paints here. */
+function isTrackedAction(target) {
+  return target instanceof Element && isTrackedByGroup(target);
+}
+
 /**
  * Space went down on a focused button that is itself a pressable surface.
  * Heard in the BUBBLE phase, after the page's own handlers, so a press the
@@ -516,7 +529,7 @@ function activatesOnSpace(target) {
  * not engage for one.
  */
 function onKeyDown(event) {
-  if (event.key !== ' ' || event.repeat || event.isComposing || event.defaultPrevented || !activatesOnSpace(event.target) || !stylesheetDroppedActive()) {
+  if (event.key !== ' ' || event.repeat || event.isComposing || event.defaultPrevented || !activatesOnSpace(event.target) || !(stylesheetDroppedActive() || isTrackedAction(event.target))) {
     return;
   }
   pressButton(event.target, null);

package/dist/utils/triggerFocus.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file triggerFocus.ts
+ * @input A focus event on a hover-layer trigger and its focusTrigger value
+ * @output Whether that focus counts as focus on the trigger, and a gate that
+ *   remembers it for the matching blur
+ * @position Shared focus-trigger judgement for Tooltip and HoverCard
+ */
+/** When focus on a trigger opens its layer. */
+export type TriggerFocusMode = 'auto' | 'always' | 'never';
+/** Whether `element` is in the tab order or naturally focusable. */
+export declare function isFocusableTrigger(element: HTMLElement): boolean;
+/**
+ * Whether a focus event on a trigger (its `currentTarget`) counts as focus on
+ * the trigger.
+ *
+ * Under `auto` it is decided when focus arrives, not when listeners attach: a
+ * roving-tabindex member that was `tabindex="-1"` then can be the tab stop
+ * now. A trigger that receives focus is focusable by definition, which covers
+ * focusable elements this check does not list, such as a `<summary>` or an SVG
+ * link. Focus inside the trigger counts only while the trigger is focusable
+ * too, so a plain wrapper ignores its children's focus.
+ */
+export declare function isFocusForTrigger(event: Event, mode: TriggerFocusMode): boolean;
+/** Remembers whether a trigger's current focus counted when it arrived. */
+export interface TriggerFocusGate {
+    /** On focusin: whether this focus opens the layer. */
+    focusIn(event: Event, mode: TriggerFocusMode): boolean;
+    /**
+     * On focusout: whether this blur closes the layer. A focus that counted
+     * closes on blur even if the trigger has since left the tab order.
+     */
+    focusOut(event: Event, mode: TriggerFocusMode): boolean;
+}
+/** A gate for one trigger; each hook keeps one for its lifetime. */
+export declare function createTriggerFocusGate(): TriggerFocusGate;
+//# sourceMappingURL=triggerFocus.d.ts.map

package/dist/utils/triggerFocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggerFocus.d.ts","sourceRoot":"","sources":["../../src/utils/triggerFocus.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE3D,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAShE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAWT;AAED,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC;CACzD;AAED,oEAAoE;AACpE,wBAAgB,sBAAsB,IAAI,gBAAgB,CAezD"}

package/dist/utils/triggerFocus.js

@@ -0,0 +1,65 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file triggerFocus.ts
+ * @input A focus event on a hover-layer trigger and its focusTrigger value
+ * @output Whether that focus counts as focus on the trigger, and a gate that
+ *   remembers it for the matching blur
+ * @position Shared focus-trigger judgement for Tooltip and HoverCard
+ */
+
+/** When focus on a trigger opens its layer. */
+
+/** Whether `element` is in the tab order or naturally focusable. */
+export function isFocusableTrigger(element) {
+  if (element.hasAttribute('tabindex')) {
+    return element.tabIndex >= 0;
+  }
+  const focusableTags = ['A', 'BUTTON', 'INPUT', 'SELECT', 'TEXTAREA'];
+  if (focusableTags.includes(element.tagName)) {
+    return !element.disabled;
+  }
+  return element.isContentEditable;
+}
+
+/**
+ * Whether a focus event on a trigger (its `currentTarget`) counts as focus on
+ * the trigger.
+ *
+ * Under `auto` it is decided when focus arrives, not when listeners attach: a
+ * roving-tabindex member that was `tabindex="-1"` then can be the tab stop
+ * now. A trigger that receives focus is focusable by definition, which covers
+ * focusable elements this check does not list, such as a `<summary>` or an SVG
+ * link. Focus inside the trigger counts only while the trigger is focusable
+ * too, so a plain wrapper ignores its children's focus.
+ */
+export function isFocusForTrigger(event, mode) {
+  if (mode === 'always') {
+    return true;
+  }
+  if (mode === 'never') {
+    return false;
+  }
+  const trigger = event.currentTarget;
+  return trigger != null && (event.target === trigger || isFocusableTrigger(trigger));
+}
+
+/** Remembers whether a trigger's current focus counted when it arrived. */
+
+/** A gate for one trigger; each hook keeps one for its lifetime. */
+export function createTriggerFocusGate() {
+  let isCounted = false;
+  return {
+    focusIn(event, mode) {
+      isCounted = isFocusForTrigger(event, mode);
+      return isCounted;
+    },
+    focusOut(event, mode) {
+      if (!isCounted && !isFocusForTrigger(event, mode)) {
+        return false;
+      }
+      isCounted = false;
+      return true;
+    }
+  };
+}