@userflow-tech/react-native 0.4.4 → 0.5.0

package/src/anchors/elementTapMonitor.ts

@@ -6,10 +6,14 @@
  * tooltip target-press monitor uses. The host fiber is the one captured at
  * touch start, before the press's setState commits a new tree.
  *
+ * A touch that gesture-handler cancels is handed off instead of dropped: the
+ * same fiber is emitted if that handler later ends as a tap.
+ *
  * With no subscribers the monitor stores nothing, so the bridge can skip the
  * fiber lookup entirely.
  */
 import type { AnyFiber } from './fiber/fiberInternals';
+import { gestureHandlerHandoff } from './gestureHandlerHandoff';
 import { type TouchIdentifier, type TouchPoint, withinTapSlop } from './targetPressMonitor';
 
 export interface ElementTap {
@@ -25,6 +29,7 @@ interface TouchStart extends TouchPoint {
 export class ElementTapMonitor {
   private readonly listeners = new Set<ElementTapListener>();
   private readonly touchStarts = new Map<TouchIdentifier, TouchStart>();
+  private readonly handoffStops = new Map<TouchIdentifier, () => void>();
 
   get subscriberCount(): number {
     return this.listeners.size;
@@ -36,10 +41,25 @@ export class ElementTapMonitor {
       this.listeners.delete(listener);
       if (this.listeners.size === 0) {
         this.touchStarts.clear();
+        this.dropHandoffs();
       }
     };
   }
 
+  /** Fingers with a recorded start that have not ended, cancelled, or been handed off. */
+  inProgressIdentifiers(): TouchIdentifier[] {
+    return [...this.touchStarts.keys()];
+  }
+
+  hasTouch(identifier: TouchIdentifier): boolean {
+    return this.touchStarts.has(identifier);
+  }
+
+  /** Fiber captured at touch start, or null when this finger is not in progress. */
+  startFiber(identifier: TouchIdentifier): AnyFiber | null {
+    return this.touchStarts.get(identifier)?.targetFiber ?? null;
+  }
+
   handleTouchStart(
     identifier: TouchIdentifier,
     pageX: number,
@@ -63,31 +83,69 @@ export class ElementTapMonitor {
     if (!start || this.listeners.size === 0 || !start.targetFiber) return;
     if (!withinTapSlop(start, { pageX, pageY })) return;
 
-    const tap: ElementTap = { targetFiber: start.targetFiber };
-    for (const listener of this.listeners) {
-      // One condition's failure must not cost the others this tap, or abort
-      // the bridge's handling of the event's remaining touches.
-      try {
-        listener(tap);
-      } catch {
-        // The condition stays at its current value.
-      }
-    }
+    this.emit(start.targetFiber);
+  }
+
+  /**
+   * Gesture-handler cancelled this finger. Forget the RN touch and emit the
+   * start fiber if that handler later ends as a tap. A start with no fiber
+   * cannot latch, so it is dropped.
+   */
+  handOffTouch(identifier: TouchIdentifier, handlerTags: readonly number[]): void {
+    const start = this.touchStarts.get(identifier);
+    if (!start) return;
+    this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
+    if (!start.targetFiber || handlerTags.length === 0 || this.listeners.size === 0) return;
+    const fiber = start.targetFiber;
+    const stop = gestureHandlerHandoff.track({
+      identifier,
+      pageX: start.pageX,
+      pageY: start.pageY,
+      handlerTags,
+      onResolve: () => this.emit(fiber),
+    });
+    this.handoffStops.set(identifier, () => {
+      stop();
+      this.handoffStops.delete(identifier);
+    });
   }
 
   /** Drop in-progress gesture(s). Omit `identifier` to clear every finger. */
   cancelTouch(identifier?: TouchIdentifier): void {
     if (identifier == null) {
       this.touchStarts.clear();
+      this.dropHandoffs();
       return;
     }
     this.touchStarts.delete(identifier);
+    this.handoffStops.get(identifier)?.();
   }
 
   /** Test helper. */
   resetForTests(): void {
     this.listeners.clear();
     this.touchStarts.clear();
+    this.dropHandoffs();
+  }
+
+  private emit(targetFiber: AnyFiber): void {
+    if (this.listeners.size === 0) return;
+    const tap: ElementTap = { targetFiber };
+    for (const listener of this.listeners) {
+      // One condition's failure must not cost the others this tap, or abort
+      // the bridge's handling of the event's remaining touches.
+      try {
+        listener(tap);
+      } catch {
+        // The condition stays at its current value.
+      }
+    }
+  }
+
+  private dropHandoffs(): void {
+    for (const stop of this.handoffStops.values()) stop();
+    this.handoffStops.clear();
   }
 }
 

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). */