react-native-screen-transitions 3.10.0 → 3.11.1

package/src/shared/components/boundary/hooks/lifecycles/use-initial-destination-measurement.ts

@@ -1,4 +1,4 @@
-import { useCallback, useLayoutEffect } from "react";
+import { useCallback, useLayoutEffect, useMemo } from "react";
 import {
 	cancelAnimation,
 	runOnUI,
@@ -7,10 +7,17 @@ import {
 	withDelay,
 	withTiming,
 } from "react-native-reanimated";
+import { useStack } from "../../../../hooks/navigation/use-stack";
 import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
 import { AnimationStore } from "../../../../stores/animation.store";
-import { getSourceScreenKeyFromPairKey } from "../../../../stores/bounds/helpers/link-pairs.helpers";
-import { getEntry } from "../../../../stores/bounds/internals/entries";
+import {
+	createScreenPairKey,
+	getSourceScreenKeyFromPairKey,
+} from "../../../../stores/bounds/helpers/link-pairs.helpers";
+import {
+	getEntry,
+	getMatchingSourceScreenKey,
+} from "../../../../stores/bounds/internals/entries";
 import { getLink } from "../../../../stores/bounds/internals/links";
 import { pairs } from "../../../../stores/bounds/internals/state";
 import type { BoundTag } from "../../../../stores/bounds/types";
@@ -19,7 +26,9 @@ import { logger } from "../../../../utils/logger";
 import type { MeasureBoundary } from "../../types";
 import { getInitialDestinationMeasurementSignal } from "../../utils/destination-signals";
 
-const HANDSHAKE_RETRY_DELAY_MS = 100;
+// A missed layout should be retried on the next frame. The previous 100 ms
+// interval made each ordinary Android layout miss visibly delay navigation.
+const HANDSHAKE_RETRY_DELAY_MS = 16;
 /**
  * A destination whose initial handshake never completes must not hold the
  * transition gate forever. After this budget, release the block with a warning
@@ -48,12 +57,21 @@ export const useInitialDestinationMeasurement = ({
 	const destinationPairKey = useDescriptorsStore(
 		(s) => s.derivations.destinationPairKey,
 	);
-	const ancestorDestinationPairKey = useDescriptorsStore(
-		(s) => s.derivations.ancestorDestinationPairKey,
-	);
 	const destinationEnabled = enabled && !nextScreenKey;
-	const initialDestinationPairKey =
-		destinationPairKey ?? ancestorDestinationPairKey;
+	const canReceiveDestination = destinationEnabled && !!destinationPairKey;
+	const preferredSourceScreenKey = destinationPairKey
+		? getSourceScreenKeyFromPairKey(destinationPairKey)
+		: undefined;
+	const stackScenes = useStack((store) => store.scenes);
+	// A retained closing screen can still have registered boundaries, but it
+	// cannot own a new transition link.
+	const closingSourceScreenKeys = useMemo(
+		() =>
+			stackScenes
+				.filter((scene) => scene.activity === "closing")
+				.map((scene) => scene.route.key),
+		[stackScenes],
+	);
 	const progress = AnimationStore.getValue(
 		currentScreenKey,
 		"transitionProgress",
@@ -67,6 +85,7 @@ export const useInitialDestinationMeasurement = ({
 	const retryToken = useSharedValue(0);
 	const handshakeRetries = useSharedValue(0);
 	const hasGivenUp = useSharedValue(0);
+	const hasFinishedInitialMeasurement = useSharedValue(0);
 
 	const releaseLifecycleStartBlock = useCallback(() => {
 		"worklet";
@@ -76,12 +95,25 @@ export const useInitialDestinationMeasurement = ({
 			return;
 		}
 
+		hasFinishedInitialMeasurement.set(1);
 		isBlockingLifecycleStart.set(0);
 		unblockLifecycleStart();
-	}, [isBlockingLifecycleStart, retryToken, unblockLifecycleStart]);
+	}, [
+		hasFinishedInitialMeasurement,
+		isBlockingLifecycleStart,
+		retryToken,
+		unblockLifecycleStart,
+	]);
 
 	const claimLifecycleStartBlock = useCallback(() => {
 		"worklet";
+		if (
+			!canReceiveDestination ||
+			hasFinishedInitialMeasurement.get() ||
+			!getMatchingSourceScreenKey(tag, currentScreenKey)
+		) {
+			return;
+		}
 
 		// The progress check and block claim must share one UI-thread operation.
 		// Otherwise a JS-thread layout effect can observe zero, enqueue the block,
@@ -92,10 +124,18 @@ export const useInitialDestinationMeasurement = ({
 
 		blockLifecycleStart();
 		isBlockingLifecycleStart.set(1);
-	}, [blockLifecycleStart, isBlockingLifecycleStart, progress]);
+	}, [
+		blockLifecycleStart,
+		canReceiveDestination,
+		currentScreenKey,
+		hasFinishedInitialMeasurement,
+		isBlockingLifecycleStart,
+		progress,
+		tag,
+	]);
 
 	useLayoutEffect(() => {
-		if (!destinationEnabled || !initialDestinationPairKey) {
+		if (!canReceiveDestination) {
 			return;
 		}
 
@@ -113,34 +153,45 @@ export const useInitialDestinationMeasurement = ({
 		};
 	}, [
 		claimLifecycleStartBlock,
-		destinationEnabled,
 		escapeClipping,
-		initialDestinationPairKey,
+		canReceiveDestination,
 		releaseLifecycleStartBlock,
 	]);
 
 	useAnimatedReaction(
 		() => {
 			"worklet";
+
+			if (
+				!canReceiveDestination ||
+				hasFinishedInitialMeasurement.get() ||
+				isBlockingLifecycleStart.get() <= 0
+			) {
+				return null;
+			}
+
+			if (progress.get() > 0) {
+				return null;
+			}
+
 			const retryTick = retryToken.get();
-			const isWaitingForOpenToStart = progress.get() <= 0;
-			const sourceScreenKey = initialDestinationPairKey
-				? getSourceScreenKeyFromPairKey(initialDestinationPairKey)
+			const sourceScreenKey = getMatchingSourceScreenKey(
+				tag,
+				currentScreenKey,
+				preferredSourceScreenKey,
+				closingSourceScreenKeys,
+			);
+			const pairKey = sourceScreenKey
+				? createScreenPairKey(sourceScreenKey, currentScreenKey)
 				: undefined;
 			const signal = getInitialDestinationMeasurementSignal({
-				enabled:
-					destinationEnabled &&
-					isWaitingForOpenToStart &&
-					isBlockingLifecycleStart.get() > 0,
-				destinationPairKey,
-				ancestorDestinationPairKey,
+				enabled: destinationEnabled,
+				pairKey,
 				linkId: linkKey,
 				group,
 				destinationPresent: getEntry(tag, currentScreenKey) !== null,
-				sourcePresent:
-					sourceScreenKey !== undefined &&
-					getEntry(tag, sourceScreenKey) !== null,
-				linkState: initialDestinationPairKey ? pairs.get() : undefined,
+				sourcePresent: sourceScreenKey !== null,
+				linkState: pairs.get(),
 			});
 
 			return [
@@ -149,9 +200,14 @@ export const useInitialDestinationMeasurement = ({
 				retryTick,
 			] as const;
 		},
-		([measurePairKey, action, retryTick], previous) => {
+		(next, previous) => {
 			"worklet";
-			if (!measurePairKey || !action) {
+			if (!next || hasFinishedInitialMeasurement.get()) {
+				return;
+			}
+
+			const [measurePairKey, action, retryTick] = next;
+			if (!action) {
 				return;
 			}
 
@@ -177,19 +233,20 @@ export const useInitialDestinationMeasurement = ({
 				return;
 			}
 
-			if (action === "measure") {
+			if (action === "measure" && measurePairKey) {
 				measureBoundary({
 					type: "destination",
 					pairKey: measurePairKey,
 				});
 			}
 
-			const link = getLink(measurePairKey, linkKey);
+			const link = measurePairKey ? getLink(measurePairKey, linkKey) : null;
 			const linkComplete = !!link?.source && !!link.destination;
 
 			if (linkComplete || action === "complete") {
 				cancelAnimation(retryToken);
 				handshakeRetries.set(0);
+				hasFinishedInitialMeasurement.set(1);
 				if (escapeClipping) {
 					// Screen-level escape has a second readiness phase after destination
 					// matching: the host must commit before the transition starts, or

package/src/shared/components/boundary/hooks/lifecycles/use-initial-source-measurement.ts

@@ -1,5 +1,6 @@
 import { useAnimatedReaction, useSharedValue } from "react-native-reanimated";
 import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
+import { getPairKeyForSource } from "../../../../stores/bounds/internals/links";
 import { pairs } from "../../../../stores/bounds/internals/state";
 import type { BoundTag } from "../../../../stores/bounds/types";
 import type { MeasureBoundary } from "../../types";
@@ -11,12 +12,16 @@ export const useInitialSourceMeasurement = (params: {
 	boundTag: BoundTag;
 }) => {
 	const { enabled, measureBoundary, boundTag } = params;
-	const sourcePairKey = useDescriptorsStore((s) => s.derivations.sourcePairKey);
+	const currentScreenKey = useDescriptorsStore(
+		(s) => s.derivations.currentScreenKey,
+	);
 	const lastSourceCaptureSignal = useSharedValue<string | null>(null);
 
 	useAnimatedReaction(
 		() => {
 			"worklet";
+			const sourcePairKey =
+				getPairKeyForSource(boundTag.tag, currentScreenKey) ?? undefined;
 			return getInitialSourceCaptureSignal({
 				enabled,
 				sourcePairKey,

package/src/shared/components/boundary/hooks/lifecycles/use-refresh-boundary.ts

@@ -1,9 +1,12 @@
 import { useAnimatedReaction } from "react-native-reanimated";
 import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
 import { AnimationStore } from "../../../../stores/animation.store";
+import {
+	getPairKeyForDestination,
+	getPairKeyForSource,
+} from "../../../../stores/bounds/internals/links";
 import { pairs } from "../../../../stores/bounds/internals/state";
 import type { BoundTag } from "../../../../stores/bounds/types";
-import { GestureStore } from "../../../../stores/gesture.store";
 import type { MeasureBoundary } from "../../types";
 import { getRefreshBoundarySignal } from "../../utils/refresh-signals";
 
@@ -23,13 +26,6 @@ export const useRefreshBoundary = ({
 		(s) => s.derivations.currentScreenKey,
 	);
 	const nextScreenKey = useDescriptorsStore((s) => s.derivations.nextScreenKey);
-	const sourcePairKey = useDescriptorsStore((s) => s.derivations.sourcePairKey);
-	const destinationPairKey = useDescriptorsStore(
-		(s) => s.derivations.destinationPairKey,
-	);
-	const ancestorDestinationPairKey = useDescriptorsStore(
-		(s) => s.derivations.ancestorDestinationPairKey,
-	);
 	// Source-side boundaries refresh from the next screen's lifecycle pulse.
 	// Destination-side boundaries have no next screen, so they refresh from self.
 	const refreshScreenKey = nextScreenKey ?? currentScreenKey;
@@ -38,43 +34,29 @@ export const useRefreshBoundary = ({
 		"willAnimate",
 	);
 	const refreshClosing = AnimationStore.getValue(refreshScreenKey, "closing");
-	const refreshEntering = AnimationStore.getValue(refreshScreenKey, "entering");
-	const refreshAnimating = AnimationStore.getValue(
-		refreshScreenKey,
-		"progressAnimating",
-	);
-	const refreshProgress = AnimationStore.getValue(
-		refreshScreenKey,
-		"transitionProgress",
-	);
-	const refreshDragging = GestureStore.getValue(refreshScreenKey, "dragging");
-	const refreshDismissing = GestureStore.getValue(
-		refreshScreenKey,
-		"dismissing",
-	);
-	const refreshSettling = GestureStore.getValue(refreshScreenKey, "settling");
 
 	useAnimatedReaction(
 		() => {
 			"worklet";
+
+			const shouldRefresh = enabled && !!refreshWillAnimate.get();
+			if (!shouldRefresh) {
+				return null;
+			}
+			const sourcePairKey =
+				getPairKeyForSource(boundTag.tag, currentScreenKey) ?? undefined;
+			const destinationPairKey =
+				getPairKeyForDestination(boundTag.tag, currentScreenKey) ?? undefined;
+
 			return getRefreshBoundarySignal({
 				enabled,
 				currentScreenKey,
 				sourcePairKey,
 				destinationPairKey,
-				ancestorDestinationPairKey,
-				nextScreenKey,
 				linkId: linkKey,
 				group,
-				shouldRefresh: !!refreshWillAnimate.get(),
+				shouldRefresh,
 				closing: !!refreshClosing.get(),
-				entering: !!refreshEntering.get(),
-				animating: !!refreshAnimating.get(),
-				progress: refreshProgress.get(),
-				gestureInProgress:
-					!!refreshDragging.get() ||
-					!!refreshDismissing.get() ||
-					!!refreshSettling.get(),
 				linkState: pairs.get(),
 			});
 		},

package/src/shared/components/boundary/hooks/use-boundary-measurement.ts

@@ -60,10 +60,11 @@ export const useBoundaryMeasurement = ({
 		escapeClipping,
 	});
 
-	// Register/unregister this boundary in the presence map so source/destination
-	// matching can resolve across concrete screen keys.
+	// Presence and source capture must not depend on this screen owning an
+	// interpolator: a nested source can participate in a transition owned by a
+	// different navigator.
 	useBoundaryPresence({
-		enabled: runtimeEnabled,
+		enabled,
 		boundTag,
 		currentScreenKey,
 		boundaryConfig,
@@ -72,7 +73,7 @@ export const useBoundaryMeasurement = ({
 	});
 
 	useInitialSourceMeasurement({
-		enabled: runtimeEnabled,
+		enabled,
 		measureBoundary,
 		boundTag,
 	});

package/src/shared/components/boundary/hooks/use-measurer.ts

@@ -1,13 +1,8 @@
 import { useCallback } from "react";
 import type { View } from "react-native";
 import { useWindowDimensions } from "react-native";
-import {
-	type AnimatedRef,
-	measure,
-	type StyleProps,
-} from "react-native-reanimated";
+import type { AnimatedRef, StyleProps } from "react-native-reanimated";
 import { applyMeasuredBoundsWrites } from "../../../providers/helpers/measured-bounds-writes";
-import { useOriginContext } from "../../../providers/screen/origin.provider";
 import { useScreenSlots } from "../../../providers/screen/styles";
 import type { BoundTag } from "../../../stores/bounds/types";
 import { ScrollStore } from "../../../stores/scroll.store";
@@ -16,9 +11,9 @@ import { getVisibilityBlockOffset } from "../../../utils/visibility-block-offset
 import type { MeasureBoundary } from "../types";
 import {
 	attachScrollSnapshotToMeasuredBounds,
+	correctMeasuredBoundsForVisibilityGate,
 	isMeasurementInViewport,
 	measureWithOverscrollAwareness,
-	normalizeMeasuredBoundsWithVisibilityGate,
 } from "../utils/measured-bounds";
 
 interface UseMeasurerParams {
@@ -49,7 +44,6 @@ export const useMeasurer = ({
 		currentScreenKey,
 		"pendingLifecycleStartBlockCount",
 	);
-	const { originRef } = useOriginContext();
 	const { visibilityBlocked } = useScreenSlots();
 
 	return useCallback(
@@ -61,14 +55,12 @@ export const useMeasurer = ({
 				measuredAnimatedRef,
 				scrollState.get(),
 			);
-			const measuredOrigin = measure(originRef);
 
-			if (!measured || !measuredOrigin) return;
+			if (!measured) return;
 
-			const normalizedMeasured = normalizeMeasuredBoundsWithVisibilityGate({
+			const correctedMeasured = correctMeasuredBoundsForVisibilityGate({
 				measured,
-				origin: measuredOrigin,
-				visibilityBlocked: escapeClipping && visibilityBlocked.get(),
+				visibilityBlocked: visibilityBlocked.get(),
 				visibilityBlockOffset: getVisibilityBlockOffset(viewportHeight),
 				viewportWidth,
 				viewportHeight,
@@ -88,7 +80,7 @@ export const useMeasurer = ({
 				target.type !== "destination" ||
 				!shouldGuardDestinationViewport ||
 				isMeasurementInViewport(
-					normalizedMeasured,
+					correctedMeasured,
 					viewportWidth,
 					viewportHeight,
 				);
@@ -96,7 +88,7 @@ export const useMeasurer = ({
 			if (!viewportAllowsDestinationWrite) return;
 
 			const measuredWithScroll = attachScrollSnapshotToMeasuredBounds(
-				normalizedMeasured,
+				correctedMeasured,
 				scrollMetadata.get(),
 			);
 
@@ -125,7 +117,6 @@ export const useMeasurer = ({
 			scrollState,
 			scrollMetadata,
 			pendingLifecycleStartBlockCount,
-			originRef,
 			visibilityBlocked,
 		],
 	);

package/src/shared/components/boundary/portal/components/boundary-content-portal/components/host.tsx

@@ -46,7 +46,7 @@ export const BoundaryContentPortalHost = memo(
 
 const styles = StyleSheet.create({
 	host: {
-		...StyleSheet.absoluteFillObject,
+		...StyleSheet.flatten(StyleSheet.absoluteFill),
 		overflow: "visible",
 	},
 });

package/src/shared/components/boundary/portal/components/boundary-content-portal/helpers/active-handoff-receiver.ts

@@ -0,0 +1,103 @@
+type ReceiverRoute = {
+	key: string;
+};
+
+type ReceiverScene = {
+	activity: string;
+	route: ReceiverRoute;
+};
+
+type ResolveActiveHandoffReceiverParams = {
+	focusedIndex: number;
+	routes: ReceiverRoute[];
+	scenes: ReceiverScene[];
+};
+
+export const resolveActiveHandoffReceiver = ({
+	focusedIndex,
+	routes,
+	scenes,
+}: ResolveActiveHandoffReceiverParams): string | null => {
+	for (let index = scenes.length - 1; index >= 0; index--) {
+		const scene = scenes[index];
+		if (scene?.activity === "closing") {
+			return scene.route.key;
+		}
+	}
+
+	return routes[focusedIndex]?.key ?? null;
+};
+
+export const resolvePreviousHandoffReceiver = ({
+	focusedIndex,
+	routes,
+	scenes,
+}: ResolveActiveHandoffReceiverParams): string | null => {
+	for (let index = scenes.length - 1; index >= 0; index--) {
+		if (scenes[index]?.activity !== "closing") {
+			continue;
+		}
+
+		for (let previousIndex = index - 1; previousIndex >= 0; previousIndex--) {
+			const previousScene = scenes[previousIndex];
+			if (previousScene?.activity !== "closing") {
+				return previousScene?.route.key ?? null;
+			}
+		}
+	}
+
+	return routes[focusedIndex]?.key ?? null;
+};
+
+export const resolveHandoffAttachmentCandidate = ({
+	activeReceiverClosing,
+	activeReceiverScreenKey,
+	attachedReceiverScreenKey,
+	hasActiveCloseFinished,
+	interpolatorReady,
+	pairChangedDuringClose = false,
+	pairDestinationScreenKey,
+	previousReceiverScreenKey,
+}: {
+	activeReceiverClosing: boolean;
+	activeReceiverScreenKey: string | null;
+	attachedReceiverScreenKey: string;
+	hasActiveCloseFinished: boolean;
+	interpolatorReady: boolean;
+	pairChangedDuringClose?: boolean;
+	pairDestinationScreenKey: string | null;
+	previousReceiverScreenKey: string | null;
+}) => {
+	"worklet";
+
+	if (
+		activeReceiverClosing &&
+		interpolatorReady &&
+		pairDestinationScreenKey &&
+		pairChangedDuringClose
+	) {
+		return pairDestinationScreenKey;
+	}
+
+	if (
+		hasActiveCloseFinished &&
+		attachedReceiverScreenKey === activeReceiverScreenKey
+	) {
+		return previousReceiverScreenKey;
+	}
+
+	if (hasActiveCloseFinished) {
+		return attachedReceiverScreenKey;
+	}
+
+	if (
+		activeReceiverClosing &&
+		attachedReceiverScreenKey !== activeReceiverScreenKey &&
+		interpolatorReady &&
+		pairDestinationScreenKey
+	) {
+		return pairDestinationScreenKey;
+	}
+
+	return activeReceiverScreenKey;
+};