@astryxdesign/core 0.7.6-canary.fdabeba → 0.7.6

package/dist/gestures/nativeScroll.d.ts

@@ -1,42 +1,12 @@
-/**
- * @file nativeScroll.ts
- * @input An element a touch landed on
- * @output Exports createNativeScrollProbe (the NativeScrollProbe a host gives
- *   each touch) and parseTouchAction
- * @position DOM half of the scroll coordination in packages/core/src/gestures
- *
- * Answers one question for a recognizer without letting it touch the DOM:
- * would the browser scroll something if this finger moved that way?
- *
- * The browser scrolls the innermost scroller that has room, then chains
- * outward, so the answer is "yes" while ANY scroller under the touch can
- * still move in that direction, with three narrowings that match the
- * browser's own:
- *
- * - `touch-action` between the touch target and a scroller must allow the
- *   axis, or the browser will not pan that scroller with a finger;
- * - an `overscroll-behavior` other than `auto` on the axis stops the chain at
- *   that scroller (a sheet body with `contain` never scrolls the page);
- * - a finger moving down scrolls content toward its START (scrollTop
- *   decreasing), and horizontally the range follows the writing direction
- *   (RTL `scrollLeft` runs from minus the overflow to zero).
- *
- * Styles are read once per touch, on the first question; scroll offsets are
- * read fresh on every question, since a native scroll moves them.
- */
 import type { NativeScrollProbe } from './types.js';
+import { parentAcrossShadow } from '../utils/flatTree.js';
+export { parentAcrossShadow };
 export interface AllowedPans {
     readonly x: boolean;
     readonly y: boolean;
 }
 /** Which pans a `touch-action` value lets the browser perform. */
 export declare function parseTouchAction(value: string): AllowedPans;
-/**
- * The node's parent in the flat tree: a slotted node's slot, then out of
- * shadow roots to their hosts, so a scroller inside a shadow tree around the
- * slot is found.
- */
-export declare function parentAcrossShadow(node: Node): Node | null;
 /** A probe of the native scrollers under `target`. */
 export declare function createNativeScrollProbe(target: unknown): NativeScrollProbe;
 //# sourceMappingURL=nativeScroll.d.ts.map

package/dist/gestures/nativeScroll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nativeScroll.d.ts","sourceRoot":"","sources":["../../src/gestures/nativeScroll.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAiB3D;AAoBD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAY1D;AAuID,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAiD1E"}
+{"version":3,"file":"nativeScroll.d.ts","sourceRoot":"","sources":["../../src/gestures/nativeScroll.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAC/C,OAAO,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAC,kBAAkB,EAAC,CAAC;AAE5B,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAiB3D;AA0JD,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAiD1E"}

package/dist/gestures/nativeScroll.js

@@ -27,6 +27,9 @@
  * read fresh on every question, since a native scroll moves them.
  */
 
+import { isRtlElement } from "../hooks/isRtlElement.js";
+import { parentAcrossShadow } from "../utils/flatTree.js";
+export { parentAcrossShadow };
 /** Which pans a `touch-action` value lets the browser perform. */
 export function parseTouchAction(value) {
   const tokens = value.trim().split(/\s+/);
@@ -49,22 +52,6 @@ export function parseTouchAction(value) {
 }
 const SCROLLABLE = new Set(['auto', 'scroll', 'overlay']);
 const EDGE_TOLERANCE = 1;
-
-/**
- * The node's parent in the flat tree: a slotted node's slot, then out of
- * shadow roots to their hosts, so a scroller inside a shadow tree around the
- * slot is found.
- */
-export function parentAcrossShadow(node) {
-  const slot = node instanceof Element || node instanceof Text ? node.assignedSlot : null;
-  if (slot != null) {
-    return slot;
-  }
-  if (node.parentNode != null) {
-    return node.parentNode instanceof ShadowRoot ? node.parentNode.host : node.parentNode;
-  }
-  return null;
-}
 function buildChain(target) {
   const doc = target.ownerDocument;
   const view = doc.defaultView;
@@ -103,7 +90,8 @@ function buildChain(target) {
         element,
         x: scrollsX && allowX,
         y: scrollsY && allowY,
-        isRtl: style.direction === 'rtl',
+        // The writing direction through core's one helper.
+        isRtl: isRtlElement(element),
         stopsX: behaviorX !== 'auto',
         stopsY: behaviorY !== 'auto',
         isBeyondFixed

package/dist/gestures/pageHold.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Decides, once per one-finger touch, whether its pan would scroll the page:
+ * `origin` is the innermost node under the finger (the composed path's first
+ * node, so a scroller inside a shadow root is seen), `dx` and `dy` the touch's
+ * movement once it clears a small slop. True cancels the touch's moves for as
+ * long as it lasts.
+ */
+export type PageScrollDecision = (origin: EventTarget | null, dx: number, dy: number) => boolean;
+/**
+ * Hold the page of `doc` still under a finger until the returned release runs
+ * (a scroll lock under a modal presentation): `holdPageScroll(document,
+ * decide)`. Never creates a gesture host. Where the primary pointer is
+ * coarse it listens as it starts, since Safari honours a blocking listener
+ * only when it was registered before the touch, and the first drag after an
+ * overlay opens is the one a hold is for; where it is fine it subscribes
+ * only to `pointerdown` and registers no touch listener until a touch or pen
+ * contact. Either way it follows the pointer while held.
+ * Proposed; pending owner review.
+ */
+export declare function holdPageScroll(doc: Document, decide: PageScrollDecision): () => void;
+//# sourceMappingURL=pageHold.d.ts.map

package/dist/gestures/pageHold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageHold.d.ts","sourceRoot":"","sources":["../../src/gestures/pageHold.ts"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,MAAM,EAAE,WAAW,GAAG,IAAI,EAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,KACP,OAAO,CAAC;AA2Kb;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,kBAAkB,GACzB,MAAM,IAAI,CAoCZ"}

package/dist/gestures/pageHold.js

@@ -0,0 +1,216 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file pageHold.ts
+ * @input A document, its gesture host if it has one (which touches a
+ *   recognizer owns), and a scroll lock's decision
+ * @output Exports holdPageScroll and PageScrollDecision
+ * @position Scroll-lock support of packages/core/src/gestures, in its own
+ *   module so a page without a scroll lock never ships it. It imports nothing
+ *   of the gesture host: it asks the document's host only if one exists, so a
+ *   scroll lock does not bring the host, its arena and its recognizers into
+ *   every overlay.
+ *
+ * While a hold is held, a one-finger pan that `decide` says would scroll the
+ * page, and that no recognizer owns, is cancelled for the rest of its touch;
+ * a second finger (pinch-zoom) never is. A document with no gesture host has
+ * no recognizer, so no touch there is owned. Holds stack per document. Only
+ * while one is held is there a non-passive `touchmove` listener, so a scroll
+ * lock costs nothing once it is released, and a touch scrolls as without
+ * the system. The primary pointer is read as a hold starts: where it is
+ * coarse the hold listens then, since Safari honours a blocking listener only
+ * when it was registered before the touch; where it is fine it registers no
+ * touch listener until a touch or pen contact. Either way it follows the
+ * pointer from then on.
+ *
+ * SYNC: When modified, update the gestures README ("Holding the page still").
+ */
+
+import { subscribeInput } from "../utils/inputStream.js";
+import { isCoarsePointer, watchCoarsePointer } from "../utils/coarsePointer.js";
+import { gestureHosts } from "./hostRegistry.js";
+
+/**
+ * Decides, once per one-finger touch, whether its pan would scroll the page:
+ * `origin` is the innermost node under the finger (the composed path's first
+ * node, so a scroller inside a shadow root is seen), `dx` and `dy` the touch's
+ * movement once it clears a small slop. True cancels the touch's moves for as
+ * long as it lasts.
+ */
+
+/**
+ * How far a finger travels before a page-scroll hold judges its pan, in CSS
+ * px: enough that a swipe's first sample (a 2 px by 2 px wobble) does not fix
+ * the wrong axis, and still under WebKit's 10–11 px scroll claim, so the
+ * verdict comes before the browser commits to a scroll.
+ */
+const PAGE_HOLD_SLOP = 5;
+const holdsByDocument = new WeakMap();
+function fingersOf(event) {
+  return event.touches == null ? [] : Array.from(event.touches);
+}
+function createHolds(doc) {
+  const holds = {
+    decisions: new Set(),
+    touch: null,
+    unsubscribers: [],
+    stopPointerDown: null,
+    stopWatchingPointer: null,
+    onPointerDown: event => {
+      if (event.pointerType !== 'touch' && event.pointerType !== 'pen') {
+        return;
+      }
+      // The hold's first touch or pen contact reads the primary pointer and
+      // follows it from then on.
+      holds.stopPointerDown?.();
+      holds.stopPointerDown = null;
+      const view = doc.defaultView;
+      followPointer(doc, holds);
+      if (!isCoarsePointer(view)) {
+        return;
+      }
+      listen(doc, holds, true);
+      // An engine that sends this contact's touchstart first has passed it:
+      // the contact starts here, and its first move names its finger.
+      holds.touch = {
+        id: null,
+        x: event.clientX,
+        y: event.clientY,
+        verdict: null
+      };
+    },
+    onTouchStart: event => {
+      const fingers = fingersOf(event);
+      const current = holds.touch;
+      // Only a finger already down keeps its record: a new touch that reuses
+      // the identifier starts afresh.
+      if (current?.id != null && fingers.some(finger => finger.identifier === current.id) && !Array.from(event.changedTouches).some(finger => finger.identifier === current.id)) {
+        // A second finger joins the held one: nothing is cancelled while two
+        // are down (a pinch), and the first keeps its verdict for the rest
+        // of its touch once it is alone again.
+        return;
+      }
+      const finger = fingers[0];
+      holds.touch = fingers.length === 1 && finger != null ? {
+        id: finger.identifier,
+        x: finger.clientX,
+        y: finger.clientY,
+        verdict: null
+      } : null;
+    },
+    onTouchMove: event => {
+      const fingers = fingersOf(event);
+      const finger = fingers[0];
+      if (holds.touch?.id === null && fingers.length === 1 && finger != null) {
+        holds.touch = {
+          ...holds.touch,
+          id: finger.identifier
+        };
+      }
+      const current = holds.touch;
+      // A second finger is a pinch: zooming the page stays available.
+      if (fingers.length !== 1 || finger == null || current == null || finger.identifier !== current.id) {
+        return;
+      }
+      // A recognizer that owns the touch decides about its moves itself. The
+      // host is read on every move: one may be created after the hold began.
+      if (gestureHosts.get(doc)?.isTouchClaimed(current.id) === true) {
+        return;
+      }
+      if (current.verdict == null) {
+        const dx = finger.clientX - current.x;
+        const dy = finger.clientY - current.y;
+        if (Math.max(Math.abs(dx), Math.abs(dy)) < PAGE_HOLD_SLOP) {
+          return;
+        }
+        // The browser picks the scroller once per gesture; so do the holds.
+        const origin = event.composedPath()[0] ?? event.target;
+        current.verdict = [...holds.decisions].some(hold => hold.decide(origin, dx, dy));
+      }
+      if (current.verdict && event.cancelable) {
+        event.preventDefault();
+      }
+    }
+  };
+  return holds;
+}
+
+/**
+ * Follow the primary pointer while held, once: the holds listen while it is
+ * coarse and not while it is fine (`spec:AST-094` FR24).
+ */
+function followPointer(doc, holds) {
+  if (holds.stopWatchingPointer == null) {
+    holds.stopWatchingPointer = watchCoarsePointer(doc.defaultView, isCoarse => listen(doc, holds, isCoarse));
+  }
+}
+
+/**
+ * Turn the holds' listeners on or off: on only while one is held and the
+ * primary pointer is coarse (`spec:AST-094` FR19, FR24).
+ */
+function listen(doc, holds, on) {
+  const view = doc.defaultView;
+  if (view == null || on === holds.unsubscribers.length > 0) {
+    return;
+  }
+  if (on) {
+    // The window's capture phase, through the shared input stream, as the
+    // host listens; only the touchmove that cancels is non-passive.
+    holds.unsubscribers = [subscribeInput(view, 'touchstart', holds.onTouchStart), subscribeInput(view, 'touchmove', holds.onTouchMove, {
+      cancels: true
+    })];
+  } else {
+    for (const unsubscribe of holds.unsubscribers.splice(0)) {
+      unsubscribe();
+    }
+    holds.touch = null;
+  }
+}
+
+/**
+ * Hold the page of `doc` still under a finger until the returned release runs
+ * (a scroll lock under a modal presentation): `holdPageScroll(document,
+ * decide)`. Never creates a gesture host. Where the primary pointer is
+ * coarse it listens as it starts, since Safari honours a blocking listener
+ * only when it was registered before the touch, and the first drag after an
+ * overlay opens is the one a hold is for; where it is fine it subscribes
+ * only to `pointerdown` and registers no touch listener until a touch or pen
+ * contact. Either way it follows the pointer while held.
+ * Proposed; pending owner review.
+ */
+export function holdPageScroll(doc, decide) {
+  let holds = holdsByDocument.get(doc);
+  if (holds == null) {
+    holds = createHolds(doc);
+    holdsByDocument.set(doc, holds);
+  }
+  const owned = holds;
+  const hold = {
+    decide
+  };
+  owned.decisions.add(hold);
+  const view = doc.defaultView;
+  if (owned.decisions.size === 1 && view != null) {
+    owned.stopPointerDown = subscribeInput(view, 'pointerdown', owned.onPointerDown);
+    if (isCoarsePointer(view)) {
+      followPointer(doc, owned);
+      listen(doc, owned, true);
+    }
+  }
+  let isHeld = true;
+  return () => {
+    if (!isHeld) {
+      return;
+    }
+    isHeld = false;
+    owned.decisions.delete(hold);
+    if (owned.decisions.size === 0) {
+      owned.stopPointerDown?.();
+      owned.stopPointerDown = null;
+      owned.stopWatchingPointer?.();
+      owned.stopWatchingPointer = null;
+      listen(doc, owned, false);
+    }
+  };
+}

package/dist/gestures/recognizerInternals.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @file recognizerInternals.ts
+ * @input GestureRecognizer
+ * @output internals(recognizer): the members the arena, the host and the
+ *   React hooks drive, and RecognizerFamily, the brand the host reads instead
+ *   of `instanceof`
+ * @position Internal to packages/core/src/gestures; never exported from the
+ *   package
+ *
+ * A recognizer's arena plumbing (its arena, a pending recognition, touch
+ * delivery, approved transitions) is `protected` on the class, so the
+ * published type offers it to subclasses only. The arena and the host reach
+ * it through this view, and so do the React hooks, for the arena an Effect's
+ * stop defers its resolution to.
+ *
+ * SYNC: When modified, update the `protected` members of GestureRecognizer.ts.
+ */
+import type { GestureArena } from './GestureArena.js';
+import type { GestureRecognizer } from './GestureRecognizer.js';
+import type { GestureEventContext, GestureState, GestureTouch } from './types.js';
+/**
+ * The kinds of recognizer the host and touch-action treat specially. Each of
+ * those classes brands itself (a subclass inherits the brand), so the host
+ * never imports a recognizer class: a page ships only the recognizers it
+ * constructs.
+ */
+export type RecognizerFamily = 'tap' | 'longPress' | 'pan';
+/** The members of a recognizer only the gesture system calls. */
+export interface RecognizerInternals {
+    /** The recognizer's family, when the host treats it specially. */
+    readonly family?: RecognizerFamily;
+    arena: GestureArena | null;
+    pending: 'began' | 'ended' | null;
+    readonly seenTouchIds: Set<number>;
+    readonly acceptsTouchInput: boolean;
+    requiresFailureOf(other: GestureRecognizer): boolean;
+    allowsSimultaneous(other: GestureRecognizer): boolean;
+    shouldBegin(): boolean;
+    keepsTouch(touchId: number): boolean;
+    wantsTouch(touch: GestureTouch): boolean;
+    deliverBegan(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    deliverBeganElsewhere(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    deliverMoved(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    deliverEnded(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    deliverCancelled(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    deliverTakenByBrowser(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    applyState(next: GestureState): void;
+    resetToPossible(): void;
+}
+/** The gesture system's view of `recognizer`. */
+export declare function internals(recognizer: GestureRecognizer): RecognizerInternals;
+//# sourceMappingURL=recognizerInternals.d.ts.map

package/dist/gestures/recognizerInternals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizerInternals.d.ts","sourceRoot":"","sources":["../../src/gestures/recognizerInternals.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,WAAW,GAAG,KAAK,CAAC;AAE3D,iEAAiE;AACjE,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC;IACrD,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC;IACtD,WAAW,IAAI,OAAO,CAAC;IACvB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACrC,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;IACzC,YAAY,CACV,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,qBAAqB,CACnB,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,YAAY,CACV,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,YAAY,CACV,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,gBAAgB,CACd,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,qBAAqB,CACnB,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI,CAAC;IACR,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACrC,eAAe,IAAI,IAAI,CAAC;CACzB;AAED,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,UAAU,EAAE,iBAAiB,GAAG,mBAAmB,CAE5E"}

package/dist/gestures/recognizerInternals.js

@@ -0,0 +1,33 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file recognizerInternals.ts
+ * @input GestureRecognizer
+ * @output internals(recognizer): the members the arena, the host and the
+ *   React hooks drive, and RecognizerFamily, the brand the host reads instead
+ *   of `instanceof`
+ * @position Internal to packages/core/src/gestures; never exported from the
+ *   package
+ *
+ * A recognizer's arena plumbing (its arena, a pending recognition, touch
+ * delivery, approved transitions) is `protected` on the class, so the
+ * published type offers it to subclasses only. The arena and the host reach
+ * it through this view, and so do the React hooks, for the arena an Effect's
+ * stop defers its resolution to.
+ *
+ * SYNC: When modified, update the `protected` members of GestureRecognizer.ts.
+ */
+
+/**
+ * The kinds of recognizer the host and touch-action treat specially. Each of
+ * those classes brands itself (a subclass inherits the brand), so the host
+ * never imports a recognizer class: a page ships only the recognizers it
+ * constructs.
+ */
+
+/** The members of a recognizer only the gesture system calls. */
+
+/** The gesture system's view of `recognizer`. */
+export function internals(recognizer) {
+  return recognizer;
+}

package/dist/gestures/selectionLock.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file selectionLock.ts
+ * @input The selection lock in utils/selectionLock.ts
+ * @output Re-exports lockSelection and locksSelectionFor
+ * @position A transition re-export: the selection lock moved to utils with
+ *   the shared input stream (utils/inputStream.ts), and stacks based below
+ *   that move still import it from here. Remove it once they have moved up.
+ */
+export { lockSelection, locksSelectionFor } from '../utils/selectionLock.js';
+//# sourceMappingURL=selectionLock.d.ts.map

package/dist/gestures/selectionLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionLock.d.ts","sourceRoot":"","sources":["../../src/gestures/selectionLock.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,EAAC,aAAa,EAAE,iBAAiB,EAAC,MAAM,wBAAwB,CAAC"}

package/dist/gestures/selectionLock.js

@@ -0,0 +1,12 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file selectionLock.ts
+ * @input The selection lock in utils/selectionLock.ts
+ * @output Re-exports lockSelection and locksSelectionFor
+ * @position A transition re-export: the selection lock moved to utils with
+ *   the shared input stream (utils/inputStream.ts), and stacks based below
+ *   that move still import it from here. Remove it once they have moved up.
+ */
+
+export { lockSelection, locksSelectionFor } from "../utils/selectionLock.js";

package/dist/gestures/touchAction.d.ts

@@ -2,9 +2,10 @@
  * @file touchAction.ts
  * @input The recognizers attached to one element
  * @output Exports deriveTouchAction (the element's `touch-action`),
- *   gestureHostStyle (the inline style a host sets for its recognizers),
- *   intersectTouchAction (what both a derived and a caller's value allow) and
- *   holdSelectionStyle (the selection and callout lock for one held press)
+ *   gestureHostStyle (the inline style a host sets for its recognizers) and
+ *   intersectTouchAction (what both a derived and a caller's value allow).
+ *   The selection and callout lock for one held press is the recognizer's
+ *   own `selectionLock` (gestures/selectionLock.ts), which the host calls
  * @position Browser negotiation of packages/core/src/gestures, pure so a
  *   server render can emit the same style the client would set
  *
@@ -27,7 +28,12 @@
  * `touchmove` while a recognizer owns the touch (see GestureHost.ts).
  */
 import type { GestureRecognizer, NativeTouchBehavior } from './GestureRecognizer.js';
-/** The intersection of what each touch recognizer leaves the browser. */
+/**
+ * The intersection of what each touch recognizer leaves the browser. A
+ * watcher (`claimsTouches: false`) never takes a touch, so it leaves the
+ * browser everything: its direction restricts no scroll (`spec:AST-094`
+ * FR20, DEC-7).
+ */
 export declare function combinedNativeBehavior(recognizers: ReadonlyArray<GestureRecognizer>): NativeTouchBehavior;
 /** The `touch-action` value for a set of recognizers, or null for none needed. */
 export declare function deriveTouchAction(recognizers: ReadonlyArray<GestureRecognizer>): string | null;
@@ -49,12 +55,4 @@ export declare function gestureHostStyle(recognizers: ReadonlyArray<GestureRecog
  * derived value never overrides a caller's narrower one.
  */
 export declare function intersectTouchAction(derived: string, caller: string): string;
-/**
- * The lock a host applies for one press only, from touch-down to the lift or
- * a cancel, on an element whose hold does something (a long press): no iOS
- * callout and no text-selection start under the held finger, as a
- * long-pressed row in UIKit selects no text (spec:AST-094 FR41). Null where
- * the hold does nothing, so a long press there selects natively.
- */
-export declare function holdSelectionStyle(recognizers: ReadonlyArray<GestureRecognizer>): GestureHostStyle | null;
 //# sourceMappingURL=touchAction.d.ts.map

package/dist/gestures/touchAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"touchAction.d.ts","sourceRoot":"","sources":["../../src/gestures/touchAction.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAEhF,yEAAyE;AACzE,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,mBAAmB,CAgBrB;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,MAAM,GAAG,IAAI,CAwBf;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,gBAAgB,CAOlB;AAqCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAyB5E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,gBAAgB,GAAG,IAAI,CAQzB"}
+{"version":3,"file":"touchAction.d.ts","sourceRoot":"","sources":["../../src/gestures/touchAction.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAGhF;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,mBAAmB,CAgBrB;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,MAAM,GAAG,IAAI,CAwBf;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,GAC5C,gBAAgB,CAOlB;AAqCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAyB5E"}

package/dist/gestures/touchAction.js

@@ -4,9 +4,10 @@
  * @file touchAction.ts
  * @input The recognizers attached to one element
  * @output Exports deriveTouchAction (the element's `touch-action`),
- *   gestureHostStyle (the inline style a host sets for its recognizers),
- *   intersectTouchAction (what both a derived and a caller's value allow) and
- *   holdSelectionStyle (the selection and callout lock for one held press)
+ *   gestureHostStyle (the inline style a host sets for its recognizers) and
+ *   intersectTouchAction (what both a derived and a caller's value allow).
+ *   The selection and callout lock for one held press is the recognizer's
+ *   own `selectionLock` (gestures/selectionLock.ts), which the host calls
  * @position Browser negotiation of packages/core/src/gestures, pure so a
  *   server render can emit the same style the client would set
  *
@@ -29,14 +30,21 @@
  * `touchmove` while a recognizer owns the touch (see GestureHost.ts).
  */
 
-/** The intersection of what each touch recognizer leaves the browser. */
+import { internals } from "./recognizerInternals.js";
+
+/**
+ * The intersection of what each touch recognizer leaves the browser. A
+ * watcher (`claimsTouches: false`) never takes a touch, so it leaves the
+ * browser everything: its direction restricts no scroll (`spec:AST-094`
+ * FR20, DEC-7).
+ */
 export function combinedNativeBehavior(recognizers) {
   let panX = true;
   let panY = true;
   let pinchZoom = true;
   let doubleTapZoom = true;
   for (const recognizer of recognizers) {
-    if (!recognizer.acceptsTouchInput) {
+    if (!internals(recognizer).acceptsTouchInput || !recognizer.claimsTouches) {
       continue;
     }
     const behavior = recognizer.nativeTouchBehavior;
@@ -138,20 +146,4 @@ export function intersectTouchAction(derived, caller) {
     parts.push('pinch-zoom');
   }
   return parts.length === 0 ? 'none' : parts.join(' ');
-}
-
-/**
- * The lock a host applies for one press only, from touch-down to the lift or
- * a cancel, on an element whose hold does something (a long press): no iOS
- * callout and no text-selection start under the held finger, as a
- * long-pressed row in UIKit selects no text (spec:AST-094 FR41). Null where
- * the hold does nothing, so a long press there selects natively.
- */
-export function holdSelectionStyle(recognizers) {
-  const holds = recognizers.some(recognizer => recognizer.kind === 'longPress' && recognizer.acceptsTouchInput);
-  return holds ? {
-    WebkitTouchCallout: 'none',
-    WebkitUserSelect: 'none',
-    userSelect: 'none'
-  } : null;
 }

package/dist/gestures/types.d.ts

@@ -6,6 +6,7 @@
  *   environment a host provides, and the view-level touch consumer contract
  * @position Shared vocabulary of packages/core/src/gestures; no runtime code
  */
+import type { SelectionLock } from './GestureRecognizer.js';
 /**
  * UIGestureRecognizer.State. A discrete recognizer goes straight from
  * `possible` to `ended` (UIKit's `.recognized` is the same value).
@@ -139,6 +140,22 @@ export interface TouchConsumer {
      * (attached above this consumer) from beginning for a touch on it.
      */
     allowsAncestorRecognizer?(recognizer: unknown): boolean;
+    /**
+     * Whether the consumer holds this touch now (a control whose press was
+     * delivered for that touch): the host cancels the browser's pan for that
+     * finger only, as UIKit's `touchesShouldCancel(in:)` is false for a
+     * tracking control. A move before the press is delivered, and another
+     * finger the consumer is not tracking, still scroll.
+     */
+    keepsTouch?(touchId: number): boolean;
+    /**
+     * A control whose own record defines a hold action (a stepper's
+     * hold-repeat) brings the lock that turns text selection and the callout
+     * off for that press only, as a recognizer created with one does
+     * (`spec:AST-094` FR41). A control whose hold does nothing leaves it
+     * undefined and keeps the browser's long-press selection.
+     */
+    readonly selectionLock?: SelectionLock;
     /**
      * Whether the consumer takes touches now (a disabled control does not).
      * The host listens only while something enabled is attached

package/dist/gestures/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/gestures/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/gestures/types.ts"],"names":[],"mappings":"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"}

package/dist/gestures/useFingerScroll.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file useFingerScroll.ts
+ * @input A scroller (a ref to an element, or the document for the page) and
+ *   the document's gesture host
+ * @output useFingerScroll: whether the scroller's current scroll is a
+ *   finger's, read at any moment
+ * @position Gesture hook of packages/core/src/gestures, over the
+ *   finger-scroll watch (fingerScroll.ts), kept on the scroller's node by
+ *   the gesture hooks' shared attachment (hooks/useAttachment.ts). An internal
+ *   piece of the touch
+ *   module with no public API, not in the gestures barrel: a scroll-driven
+ *   component (a tab bar that minimizes, a header that collapses, a picker
+ *   that commits at rest) imports it from here, so it ships only where used
+ *
+ * A scroll is a finger's from a scroll event while a finger that landed
+ * inside the scroller is down, until the scroller's `scrollend` (the lift
+ * starts the momentum, which is still the finger's), or, where the browser
+ * sends no `scrollend`, until a 150 ms fallback after the last scroll event.
+ * A scroll with no finger down, or a recognizer's own scroll, is the
+ * program's, even right after a tap. A
+ * component that reacts to the person's scrolling only (a tab bar that
+ * minimizes as the page scrolls down) reads this instead of listening to
+ * touches itself.
+ *
+ * SYNC: When modified, update __tests__/useFingerScroll.test.tsx.
+ */
+import { type RefObject } from 'react';
+/**
+ * Watch a scroller's finger scrolls. Pass a ref to a scrolling element, or
+ * the document for the page's own scroll. Returns a reader, stable across
+ * renders: `true` while the scroller's scroll is a finger's.
+ * Internal: not exported from the package.
+ */
+export declare function useFingerScroll(scroller: RefObject<Element | null> | Document): () => boolean;
+//# sourceMappingURL=useFingerScroll.d.ts.map

package/dist/gestures/useFingerScroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFingerScroll.d.ts","sourceRoot":"","sources":["../../src/gestures/useFingerScroll.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAsB,KAAK,SAAS,EAAC,MAAM,OAAO,CAAC;AAc1D;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,QAAQ,GAC7C,MAAM,OAAO,CAwBf"}