@userflow-tech/react-native 0.4.5 → 0.5.0

package/src/anchors/elementTargetMatch.ts

@@ -26,19 +26,46 @@ export function anchorIdsAboveTap(tap: ElementTap): ReadonlySet<string> {
   const ids = new Set<string>();
   let current: AnyFiber = tap.targetFiber;
   for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
-    const props = getMemoizedProps(current);
-    if (props) {
-      for (const tier of ANCHOR_PROP_TIERS) {
-        const value = props[tier];
-        if (typeof value === 'string') ids.add(value);
-      }
-    }
+    collectAnchorIds(current, ids);
     current = getReturn(current);
   }
   anchorIdsByTap.set(tap, ids);
   return ids;
 }
 
+/**
+ * The fiber on `start` (or an ancestor) that carries `anchorId`.
+ *
+ * The touch-start fiber is kept after the press navigates away, so a click can
+ * still match when a live scan of the new screen no longer finds the id.
+ */
+export function fiberBearingAnchorId(start: AnyFiber, anchorId: string): AnyFiber | null {
+  let current: AnyFiber = start;
+  for (let depth = 0; current && depth < MAX_ANCESTOR_WALK; depth += 1) {
+    if (fiberHasAnchorId(current, anchorId)) return current;
+    current = getReturn(current);
+  }
+  return null;
+}
+
+function fiberHasAnchorId(fiber: AnyFiber, anchorId: string): boolean {
+  const props = getMemoizedProps(fiber);
+  if (!props) return false;
+  for (const tier of ANCHOR_PROP_TIERS) {
+    if (props[tier] === anchorId) return true;
+  }
+  return false;
+}
+
+function collectAnchorIds(fiber: AnyFiber, ids: Set<string>): void {
+  const props = getMemoizedProps(fiber);
+  if (!props) return;
+  for (const tier of ANCHOR_PROP_TIERS) {
+    const value = props[tier];
+    if (typeof value === 'string') ids.add(value);
+  }
+}
+
 export function sameFiber(a: AnyFiber, b: AnyFiber): boolean {
   if (a == null || b == null) return false;
   if (a === b) return true;

package/src/anchors/fiber/fiberInternals.ts

@@ -319,6 +319,74 @@ export function resolveCurrentFiber(fiber: AnyFiber): AnyFiber {
   return fiber;
 }
 
+/** Where a fiber sits: its tree's current fiber, and whether it is under it. */
+interface TreePlace {
+  current: AnyFiber;
+  inTree: boolean;
+}
+
+/**
+ * {@link resolveCurrentFiber} for many fibers in one synchronous pass. Where
+ * each ancestor sits is remembered, so the pass walks every ancestor once
+ * instead of once per fiber below it. Discard it when the pass ends: a render
+ * moves `return` pointers.
+ */
+export function createCurrentFiberResolver(): (fiber: AnyFiber) => AnyFiber {
+  const placeOf = new Map<object, TreePlace | null>();
+
+  const locate = (fiber: AnyFiber): TreePlace | null => {
+    const path: AnyFiber[] = [];
+    let above: TreePlace | null = null;
+    let cur: AnyFiber = fiber;
+    for (let depth = 0; cur && depth < MAX_ANCESTOR_WALK; depth += 1) {
+      const known = placeOf.get(cur);
+      if (known !== undefined) {
+        above = known;
+        break;
+      }
+      path.push(cur);
+      // Only a HostRoot (or a detached fiber) has no parent, so the tag is
+      // read once, at the top, not at every step.
+      const parent = getReturn(cur);
+      if (!parent) {
+        const rootState =
+          getFiberTag(cur) === HOST_ROOT_TAG
+            ? (getStateNode(cur) as { current?: AnyFiber } | null)
+            : null;
+        above = rootState?.current ? { current: rootState.current, inTree: false } : null;
+        break;
+      }
+      cur = parent;
+    }
+    // Top down: a fiber is in the current tree when the current fiber is it
+    // or one of its ancestors.
+    let place = above;
+    for (let i = path.length - 1; i >= 0; i -= 1) {
+      if (place && !place.inTree && path[i] === place.current) {
+        place = { current: place.current, inTree: true };
+      }
+      placeOf.set(path[i], place);
+    }
+    return place;
+  };
+
+  return (fiber) => {
+    if (!fiber) return fiber;
+    try {
+      const alternate = getAlternate(fiber);
+      if (!alternate) return fiber;
+      const own = locate(fiber);
+      if (!own || own.inTree) return fiber;
+      const other = locate(alternate);
+      // Two trees for one pair only happens on a corrupt graph.
+      if (!other || other.current !== own.current) return resolveCurrentFiber(fiber);
+      return other.inTree ? alternate : fiber;
+    } catch {
+      return fiber;
+    }
+  };
+}
+
 function isInTree(fiber: AnyFiber, root: AnyFiber): boolean {
   let cur: AnyFiber = fiber;
   for (let depth = 0; cur && depth < MAX_ANCESTOR_WALK; depth += 1) {

package/src/anchors/fiber/indexHostFibers.ts

@@ -111,13 +111,18 @@ export function createLazyHostFiberIndex(
 
 /**
  * Fiber for a public instance: direct pointer first, then the scan-root index
- * by identity / native tag.
+ * by identity / native tag. Pass a `createCurrentFiberResolver()` resolver when
+ * looking up many instances in one pass.
  */
-export function lookupHostFiber(index: HostFiberIndexSource, instance: unknown): AnyFiber | null {
+export function lookupHostFiber(
+  index: HostFiberIndexSource,
+  instance: unknown,
+  resolveCurrent: (fiber: AnyFiber) => AnyFiber = resolveCurrentFiber,
+): AnyFiber | null {
   const direct = fiberFromPublicInstance(instance);
   if (direct) {
     try {
-      return resolveCurrentFiber(direct);
+      return resolveCurrent(direct);
     } catch {
       return direct;
     }

package/src/anchors/fiber/resolveFiberPath.ts

@@ -31,10 +31,13 @@ import { walkVisibleFibers } from './walkVisibleFibers';
 const MIN_SCORE = 40;
 const UNIQUENESS_MARGIN = 12;
 
+/** Why a fiber path did not resolve. Element conditions map these differently. */
+export type FiberPathMissReason = 'empty' | 'no-root' | 'no-match';
+
 export type FiberPathResolution =
   | { status: 'found'; fiber: AnyFiber; cacheId: string; textDisagreed?: boolean }
   | { status: 'ambiguous' }
-  | { status: 'unknown' };
+  | { status: 'unknown'; reason: FiberPathMissReason };
 
 function stringProp(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim() ? value.trim() : undefined;
@@ -50,18 +53,13 @@ function sameFiber(a: AnyFiber, b: AnyFiber): boolean {
   return alt != null && alt === b;
 }
 
-function liveSegment(fiber: AnyFiber): MobileFiberSegment {
+/** The live segment without its text, which needs a subtree walk. */
+function liveIdentity(fiber: AnyFiber): MobileFiberSegment {
   const props = getLiveHostProps(fiber);
   const role = stringProp(props?.accessibilityRole) ?? stringProp(props?.role);
   const testID = stringProp(props?.testID);
   const accessibilityLabel =
     stringProp(props?.accessibilityLabel) ?? stringProp(props?.['aria-label']);
-  let text: string | undefined;
-  try {
-    text = readHostText(fiber, 1);
-  } catch {
-    text = undefined;
-  }
   const hostKind = getHostTypeName(fiber);
   return {
     displayName: typeof fiber?.type === 'string' ? fiber.type : '',
@@ -69,10 +67,19 @@ function liveSegment(fiber: AnyFiber): MobileFiberSegment {
     ...(role ? { role } : {}),
     ...(testID ? { testID } : {}),
     ...(accessibilityLabel ? { accessibilityLabel } : {}),
-    ...(text ? { text } : {}),
   };
 }
 
+function liveSegment(fiber: AnyFiber): MobileFiberSegment {
+  let text: string | undefined;
+  try {
+    text = readHostText(fiber, 1);
+  } catch {
+    text = undefined;
+  }
+  return { ...liveIdentity(fiber), ...(text ? { text } : {}) };
+}
+
 function ancestorsOf(fiber: AnyFiber): AnyFiber[] {
   const chain: AnyFiber[] = [];
   let current: AnyFiber | null = fiber;
@@ -90,7 +97,8 @@ function scoreAlignment(expected: MobileFiberSegment[], actual: AnyFiber[]): num
   let kindAligned = 0;
   for (let i = 0; i < n; i += 1) {
     const exp = expected[expected.length - 1 - i]!;
-    const live = liveSegment(actual[actual.length - 1 - i]!);
+    // Alignment never compares text, so skip the subtree walk for every ancestor.
+    const live = liveIdentity(actual[actual.length - 1 - i]!);
     const expKind = exp.hostKind ?? exp.displayName;
     const liveKind = live.hostKind ?? live.displayName;
     if (expKind && liveKind && expKind !== liveKind) break;
@@ -107,13 +115,14 @@ function scoreHost(
   path: MobileFiberPath,
   fiber: AnyFiber,
 ): { score: number; textDisagreed: boolean } {
-  const live = liveSegment(fiber);
   const leaf = path.segments[path.segments.length - 1];
   const leafKind = leaf?.hostKind ?? path.leafKind;
-  const liveKind = live.hostKind ?? '';
+  // Kind first: most hosts fail here, before any props or text are read.
+  const liveKind = getHostTypeName(fiber) ?? '';
   if (leafKind && liveKind && leafKind !== liveKind) {
     return { score: -Infinity, textDisagreed: false };
   }
+  const live = liveSegment(fiber);
 
   let score = 20;
   if (leaf?.role && live.role === leaf.role) score += 15;
@@ -151,15 +160,15 @@ function scoreHost(
 
 function resolveScored(path: MobileFiberPath, root: AnyFiber): FiberPathResolution {
   const scored: Array<{ fiber: AnyFiber; score: number; textDisagreed: boolean }> = [];
+  // The walk already skips covered screens, so no per-host visibility walk.
   walkVisibleFibers(root, (fiber) => {
     if (!isHostFiber(fiber)) return;
-    if (!isFiberOnVisibleScreen(fiber)) return;
     const { score, textDisagreed } = scoreHost(path, fiber);
     if (score > -Infinity) scored.push({ fiber, score, textDisagreed });
   });
   scored.sort((a, b) => b.score - a.score);
   const best = scored[0];
-  if (!best || best.score < MIN_SCORE) return { status: 'unknown' };
+  if (!best || best.score < MIN_SCORE) return { status: 'unknown', reason: 'no-match' };
   const second = scored[1];
   if (second && best.score - second.score < UNIQUENESS_MARGIN) return { status: 'ambiguous' };
   return {
@@ -175,7 +184,7 @@ function resolveScored(path: MobileFiberPath, root: AnyFiber): FiberPathResoluti
  * and reuses the manual fiber scan.
  */
 export function resolveFiberPath(path: MobileFiberPath | null | undefined): FiberPathResolution {
-  if (!path || path.segments.length === 0) return { status: 'unknown' };
+  if (!path || path.segments.length === 0) return { status: 'unknown', reason: 'empty' };
 
   const leaf = path.segments[path.segments.length - 1];
   const exactId = leaf?.testID;
@@ -200,7 +209,7 @@ export function resolveFiberPath(path: MobileFiberPath | null | undefined): Fibe
   }
 
   const root = fiberScanRoot.getFiber();
-  if (!root) return { status: 'unknown' };
+  if (!root) return { status: 'unknown', reason: 'no-root' };
 
   const resolved = resolveScored(path, root);
   if (resolved.status === 'found') {

package/src/anchors/fiberAnchorCache.ts

@@ -7,6 +7,7 @@ interface FiberCacheEntry {
 
 const fiberCache = new Map<string, FiberCacheEntry>();
 let currentScreenKey: string | null = null;
+const screenChangeListeners = new Set<() => void>();
 
 export function getFiberAnchorScreenKey(): string | null {
   return currentScreenKey;
@@ -17,6 +18,24 @@ export function notifyAnchorScreenChange(screenKey: string | null): void {
   if (screenKey === currentScreenKey) return;
   currentScreenKey = screenKey;
   fiberCache.clear();
+  for (const listener of Array.from(screenChangeListeners)) {
+    try {
+      listener();
+    } catch {
+      // A listener must not break screen tracking.
+    }
+  }
+}
+
+/**
+ * `listener` runs after the active screen changes, once the cache above is
+ * cleared. Searches that back off while a target is missing restart from here.
+ */
+export function subscribeAnchorScreenChange(listener: () => void): () => void {
+  screenChangeListeners.add(listener);
+  return () => {
+    screenChangeListeners.delete(listener);
+  };
 }
 
 /** Drop the fiber cache (preview restart / tests). */

package/src/anchors/gestureHandlerHandoff.ts

@@ -0,0 +1,356 @@
+/**
+ * Taps that react-native-gesture-handler takes away from React Native.
+ *
+ * When a gesture-handler control activates, it cancels RN's touch stream, so
+ * the bridge sees `touchcancel` instead of `touchend`. The handler tag is read
+ * off the touched fiber (no import of gesture-handler), and the touch counts
+ * as a tap only if that handler later ends from ACTIVE on
+ * `onGestureHandlerStateChange`. Apps that never hit this path never subscribe.
+ *
+ * State numbers are gesture-handler's `State` enum. A future major that
+ * renumbers them degrades to "no tap", which is today's behavior.
+ */
+import type { AnyFiber } from './fiber/fiberInternals';
+import {
+  getMemoizedProps,
+  getReturn,
+  getStateNode,
+  MAX_ANCESTOR_WALK,
+} from './fiber/fiberInternals';
+import { type TouchPoint, withinTapSlop } from './tapSlop';
+
+/** gesture-handler `State` values this hand-off acts on. */
+export const GESTURE_HANDLER_STATE = {
+  FAILED: 1,
+  CANCELLED: 3,
+  ACTIVE: 4,
+  END: 5,
+} as const;
+
+/** Drop a handed-off touch that never reaches a terminal state. */
+export const GESTURE_HANDLER_HANDOFF_TIMEOUT_MS = 10_000;
+
+const STATE_CHANGE_EVENT = 'onGestureHandlerStateChange';
+
+export interface HandedOffTouch {
+  identifier: number | string;
+  pageX: number;
+  pageY: number;
+  handlerTags: readonly number[];
+  /**
+   * The gesture completed as a tap. `end` is set when the payload carried
+   * window coordinates; otherwise only the start point is known.
+   */
+  onResolve: (end: TouchPoint | null) => void;
+}
+
+interface DeviceEventSubscription {
+  remove: () => void;
+}
+
+interface DeviceEventEmitterLike {
+  addListener(event: string, listener: (payload: unknown) => void): DeviceEventSubscription;
+}
+
+interface GestureStatePayload {
+  handlerTag: number;
+  state: number;
+  oldState?: number;
+  pointerInside?: boolean;
+  translationX?: number;
+  translationY?: number;
+  absoluteX?: number;
+  absoluteY?: number;
+  /** Present only so a long-press payload can be told apart from a tap. */
+  hasDuration: boolean;
+}
+
+interface PendingTouch extends HandedOffTouch {
+  id: number;
+  settled: boolean;
+  /** Tags that already reached a terminal state without counting as a tap. */
+  finishedTags: Set<number>;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+/**
+ * Handler tags for the control under `fiber`.
+ *
+ * Old-API buttons keep `handlerTag` on the class instance. `GestureDetector`
+ * keeps a `gesture` prop whose `toGestureArray()` entries each have one.
+ * Negative tags (gesture-handler's own root helper) are ignored.
+ *
+ * The walk stops at the nearest fiber that has a tag. A native handler with
+ * `disallowInterruption` (gesture-handler `ScrollView`, `FlatList`,
+ * `RefreshControl`) is a container, not a tap, so a scroll that starts inside
+ * it is dropped instead of latching the row. Never throws.
+ */
+export function collectGestureHandlerTags(fiber: AnyFiber | null): number[] {
+  if (fiber == null) return [];
+  try {
+    let current: AnyFiber | null = fiber;
+    let steps = 0;
+    while (current && steps < MAX_ANCESTOR_WALK) {
+      steps += 1;
+      const found = tagsOnFiber(current);
+      if (found.pressable.length > 0) return found.pressable;
+      // The nearest handler is a scroll container. An outer control did not
+      // receive this touch.
+      if (found.container) return [];
+      current = getReturn(current);
+    }
+  } catch {
+    return [];
+  }
+  return [];
+}
+
+export class GestureHandlerHandoff {
+  private readonly pending = new Map<number, PendingTouch>();
+  private nextId = 1;
+  private subscription: DeviceEventSubscription | null = null;
+
+  /**
+   * Keep `touch` until its handler finishes or it expires.
+   * Returns a stop function; calling it drops the touch without a tap.
+   */
+  track(touch: HandedOffTouch): () => void {
+    if (touch.handlerTags.length === 0) return () => {};
+    const id = this.nextId;
+    this.nextId += 1;
+    const pending: PendingTouch = {
+      ...touch,
+      id,
+      settled: false,
+      finishedTags: new Set(),
+      timer: setTimeout(() => {
+        this.drop(id);
+      }, GESTURE_HANDLER_HANDOFF_TIMEOUT_MS),
+    };
+    this.pending.set(id, pending);
+    this.ensureListening();
+    return () => this.drop(id);
+  }
+
+  /** Test helper. Drops every pending touch and unsubscribes. */
+  resetForTests(): void {
+    for (const touch of this.pending.values()) {
+      touch.settled = true;
+      clearTimeout(touch.timer);
+    }
+    this.pending.clear();
+    this.stopListeningIfIdle();
+  }
+
+  /** @internal Test hook: how many touches are still waiting. */
+  get pendingCount(): number {
+    return this.pending.size;
+  }
+
+  private ensureListening(): void {
+    if (this.subscription || this.pending.size === 0) return;
+    const emitter = deviceEventEmitter();
+    if (!emitter) return;
+    this.subscription = emitter.addListener(STATE_CHANGE_EVENT, (payload: unknown) => {
+      try {
+        this.handleStateChange(payload);
+      } catch {
+        // A bad payload must not break the next gesture.
+      }
+    });
+  }
+
+  private stopListeningIfIdle(): void {
+    if (this.pending.size > 0 || !this.subscription) return;
+    this.subscription.remove();
+    this.subscription = null;
+  }
+
+  private handleStateChange(event: unknown): void {
+    const payload = asPayload(event);
+    if (!payload) return;
+    const matching = [...this.pending.values()].filter(
+      (touch) => !touch.settled && touch.handlerTags.includes(payload.handlerTag),
+    );
+    for (const touch of matching) {
+      this.apply(touch, payload);
+    }
+  }
+
+  private apply(touch: PendingTouch, payload: GestureStatePayload): void {
+    if (touch.settled || !isTerminal(payload.state)) return;
+    if (isCompletedTap(touch, payload)) {
+      this.resolve(touch, endPoint(payload));
+      return;
+    }
+    touch.finishedTags.add(payload.handlerTag);
+    const allDone = touch.handlerTags.every((tag) => touch.finishedTags.has(tag));
+    if (allDone) this.drop(touch.id);
+  }
+
+  private resolve(touch: PendingTouch, end: TouchPoint | null): void {
+    const notify = touch.onResolve;
+    this.drop(touch.id);
+    try {
+      notify(end);
+    } catch {
+      // One monitor's failure must not skip the other touch on this event.
+    }
+  }
+
+  private drop(id: number): void {
+    const touch = this.pending.get(id);
+    if (!touch || touch.settled) return;
+    touch.settled = true;
+    clearTimeout(touch.timer);
+    this.pending.delete(id);
+    this.stopListeningIfIdle();
+  }
+}
+
+/** Shared singleton used by the tap monitors. */
+export const gestureHandlerHandoff = new GestureHandlerHandoff();
+
+interface FiberTags {
+  /** Tags that can count as a tap. */
+  pressable: number[];
+  /** The fiber has a container handler and no pressable tag. */
+  container: boolean;
+}
+
+function tagsOnFiber(fiber: AnyFiber): FiberTags {
+  try {
+    const pressable: number[] = [];
+    const seen = new Set<number>();
+    let container = false;
+    const add = (tag: number | undefined, isContainer: boolean): void => {
+      if (tag === undefined) return;
+      if (isContainer) {
+        container = true;
+        return;
+      }
+      if (seen.has(tag)) return;
+      seen.add(tag);
+      pressable.push(tag);
+    };
+
+    const props = getMemoizedProps(fiber);
+    add(handlerTagOf(getStateNode(fiber)), props?.disallowInterruption === true);
+
+    const gesture = props?.gesture;
+    if (gesture && typeof gesture === 'object' && 'toGestureArray' in gesture) {
+      const toArray = (gesture as { toGestureArray?: unknown }).toGestureArray;
+      if (typeof toArray === 'function') {
+        const list = (toArray as () => unknown).call(gesture);
+        if (Array.isArray(list)) {
+          for (const item of list) {
+            const tag = handlerTagOf(item) ?? handlerTagOf(readHandlers(item));
+            add(tag, disallowsInterruption(item));
+          }
+        }
+      }
+    }
+    return { pressable, container: container && pressable.length === 0 };
+  } catch {
+    return { pressable: [], container: false };
+  }
+}
+
+/** Gesture-handler scroll containers set this so a drag is not stolen. */
+function disallowsInterruption(value: unknown): boolean {
+  if (!value || typeof value !== 'object' || !('config' in value)) return false;
+  const config = (value as { config?: unknown }).config;
+  if (!config || typeof config !== 'object' || !('disallowInterruption' in config)) return false;
+  return (config as { disallowInterruption?: unknown }).disallowInterruption === true;
+}
+
+function readHandlers(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || !('handlers' in value)) return undefined;
+  return (value as { handlers?: unknown }).handlers;
+}
+
+/** A mounted gesture-handler tag. `-1` means "not attached yet". */
+function handlerTagOf(value: unknown): number | undefined {
+  if (!value || typeof value !== 'object' || !('handlerTag' in value)) return undefined;
+  const tag = (value as { handlerTag?: unknown }).handlerTag;
+  if (typeof tag !== 'number' || !Number.isFinite(tag) || tag < 0) return undefined;
+  return tag;
+}
+
+function deviceEventEmitter(): DeviceEventEmitterLike | null {
+  try {
+    // Lazy so a tap that is never cancelled does not load React Native's emitter
+    // into unit tests that only exercise the monitors.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const reactNative = require('react-native') as {
+      DeviceEventEmitter?: DeviceEventEmitterLike;
+    };
+    const emitter = reactNative.DeviceEventEmitter;
+    if (!emitter || typeof emitter.addListener !== 'function') return null;
+    return emitter;
+  } catch {
+    return null;
+  }
+}
+
+function asPayload(event: unknown): GestureStatePayload | null {
+  if (!event || typeof event !== 'object') return null;
+  const raw = event as Record<string, unknown>;
+  const body =
+    raw.nativeEvent && typeof raw.nativeEvent === 'object'
+      ? (raw.nativeEvent as Record<string, unknown>)
+      : raw;
+  if (typeof body.handlerTag !== 'number' || typeof body.state !== 'number') return null;
+  return {
+    handlerTag: body.handlerTag,
+    state: body.state,
+    ...(typeof body.oldState === 'number' ? { oldState: body.oldState } : {}),
+    ...(typeof body.pointerInside === 'boolean' ? { pointerInside: body.pointerInside } : {}),
+    ...(typeof body.translationX === 'number' ? { translationX: body.translationX } : {}),
+    ...(typeof body.translationY === 'number' ? { translationY: body.translationY } : {}),
+    ...(typeof body.absoluteX === 'number' ? { absoluteX: body.absoluteX } : {}),
+    ...(typeof body.absoluteY === 'number' ? { absoluteY: body.absoluteY } : {}),
+    hasDuration: 'duration' in body && body.duration != null,
+  };
+}
+
+function isTerminal(state: number): boolean {
+  return (
+    state === GESTURE_HANDLER_STATE.FAILED ||
+    state === GESTURE_HANDLER_STATE.CANCELLED ||
+    state === GESTURE_HANDLER_STATE.END
+  );
+}
+
+function isCompletedTap(touch: PendingTouch, payload: GestureStatePayload): boolean {
+  if (payload.state !== GESTURE_HANDLER_STATE.END) return false;
+  if (payload.oldState !== GESTURE_HANDLER_STATE.ACTIVE) return false;
+  if (payload.pointerInside === false) return false;
+  if (payload.hasDuration) return false;
+  if (
+    payload.translationX !== undefined &&
+    payload.translationY !== undefined &&
+    !withinTapSlop(
+      { pageX: 0, pageY: 0 },
+      { pageX: payload.translationX, pageY: payload.translationY },
+    )
+  ) {
+    return false;
+  }
+  if (payload.absoluteX !== undefined && payload.absoluteY !== undefined) {
+    if (
+      !withinTapSlop(
+        { pageX: touch.pageX, pageY: touch.pageY },
+        { pageX: payload.absoluteX, pageY: payload.absoluteY },
+      )
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function endPoint(payload: GestureStatePayload): TouchPoint | null {
+  if (payload.absoluteX === undefined || payload.absoluteY === undefined) return null;
+  return { pageX: payload.absoluteX, pageY: payload.absoluteY };
+}

package/src/anchors/resolveAnchorHost.ts

@@ -15,6 +15,8 @@ import {
   setCachedFiberAnchor,
 } from './fiberAnchorCache';
 
+export { subscribeAnchorScreenChange } from './fiberAnchorCache';
+
 export type AnchorResolution =
   | { status: 'found'; host: AnchorHost; fiber?: AnyFiber }
   | { status: 'ambiguous' }