react-native-screen-transitions 3.4.0-alpha.6 → 3.4.0-beta.0

package/src/shared/components/create-boundary-component/hooks/helpers/measurement-rules.ts

@@ -10,7 +10,6 @@ export type MeasurementIntentFlags = {
 	completeDestination: boolean;
 	refreshSource: boolean;
 	refreshDestination: boolean;
-	snapshotOnly: boolean;
 };
 
 export type MeasurementWritePlan = {
@@ -18,7 +17,6 @@ export type MeasurementWritePlan = {
 	completeDestination: boolean;
 	refreshSource: boolean;
 	refreshDestination: boolean;
-	registerSnapshot: boolean;
 	writesAny: boolean;
 	wantsDestinationWrite: boolean;
 };
@@ -37,7 +35,6 @@ export const getMeasurementIntentFlags = (
 		completeDestination: false,
 		refreshSource: false,
 		refreshDestination: false,
-		snapshotOnly: false,
 	};
 
 	if (!intent) {
@@ -60,9 +57,6 @@ export const getMeasurementIntentFlags = (
 			case "refresh-destination":
 				flags.refreshDestination = true;
 				break;
-			case "snapshot-only":
-				flags.snapshotOnly = true;
-				break;
 		}
 	}
 
@@ -74,68 +68,99 @@ export const resolveMeasurementWritePlan = (params: {
 	hasPendingLink: boolean;
 	hasSourceLink: boolean;
 	hasDestinationLink: boolean;
+	hasAttachableSourceLink: boolean;
 }): MeasurementWritePlan => {
 	"worklet";
-	const { intents, hasPendingLink, hasSourceLink, hasDestinationLink } = params;
+	const {
+		intents,
+		hasPendingLink,
+		hasSourceLink,
+		hasDestinationLink,
+		hasAttachableSourceLink,
+	} = params;
 
 	const captureSource = intents.captureSource;
-	const completeDestination = intents.completeDestination && hasPendingLink;
+	const completeDestination =
+		intents.completeDestination && (hasPendingLink || hasAttachableSourceLink);
 	const refreshSource = intents.refreshSource && hasSourceLink;
 	const refreshDestination =
-		intents.refreshDestination && (hasDestinationLink || hasPendingLink);
-	const registerSnapshot = intents.snapshotOnly || intents.refreshSource;
+		intents.refreshDestination &&
+		(hasDestinationLink || hasPendingLink || hasAttachableSourceLink);
 	const writesAny =
-		registerSnapshot ||
-		captureSource ||
-		completeDestination ||
-		refreshSource ||
-		refreshDestination;
+		captureSource || completeDestination || refreshSource || refreshDestination;
 
 	return {
 		captureSource,
 		completeDestination,
 		refreshSource,
 		refreshDestination,
-		registerSnapshot,
 		writesAny,
 		wantsDestinationWrite: completeDestination || refreshDestination,
 	};
 };
 
+/**
+ * Temporarily removed destination-match gating for auto source capture.
+ *
+ * For now, any enabled boundary on a source screen will eagerly capture when a
+ * next screen exists, even if no matching destination boundary has registered
+ * presence yet. The previous behavior waited for an explicit destination match
+ * before allowing source capture.
+ */
 export const resolveAutoSourceCaptureSignal = (params: {
 	enabled: boolean;
 	nextScreenKey?: string;
 	tagPresence?: Record<string, PresenceLikeEntry>;
 }): string | 0 => {
 	"worklet";
-	const { enabled, nextScreenKey, tagPresence } = params;
+	const { enabled, nextScreenKey } = params;
 	if (!enabled) return 0;
 	if (!nextScreenKey) return 0;
-	if (!tagPresence) return 0;
-
-	const direct = tagPresence[nextScreenKey];
-	if (direct && direct.count > 0) return nextScreenKey;
 
-	for (const screenKey in tagPresence) {
-		const entry = tagPresence[screenKey];
-		if (entry.ancestorKeys?.includes(nextScreenKey)) {
-			return nextScreenKey;
-		}
-	}
+	/**
+	 * Temporarily removed destination-match gating for auto source capture.
+	 *
+	 * For now, any enabled boundary on a source screen will eagerly capture when
+	 * a next screen exists, even if no matching destination boundary has
+	 * registered presence yet. The previous behavior waited for an explicit
+	 * destination match before allowing source capture.
+	 */
+	// const tagPresence = params.tagPresence;
+	// if (!tagPresence) return 0;
+	//
+	// const direct = tagPresence[nextScreenKey];
+	// if (direct && direct.count > 0) return nextScreenKey;
+	//
+	// for (const screenKey in tagPresence) {
+	// 	const entry = tagPresence[screenKey];
+	// 	if (entry.ancestorKeys?.includes(nextScreenKey)) {
+	// 		return nextScreenKey;
+	// 	}
+	// }
+	//
+	// return 0;
 
-	return 0;
+	return nextScreenKey;
 };
 
 export const resolvePendingDestinationCaptureSignal = (params: {
 	enabled: boolean;
 	resolvedSourceKey?: string | null;
-	hasPendingLinkFromSource: boolean;
+	hasAttachableSourceLink: boolean;
+	hasDestinationLink: boolean;
 }): string | 0 => {
 	"worklet";
-	const { enabled, resolvedSourceKey, hasPendingLinkFromSource } = params;
+	const {
+		enabled,
+		resolvedSourceKey,
+		hasAttachableSourceLink,
+		hasDestinationLink,
+	} = params;
 	if (!enabled) return 0;
 	if (!resolvedSourceKey) return 0;
-	return hasPendingLinkFromSource ? resolvedSourceKey : 0;
+	if (!hasAttachableSourceLink) return 0;
+	if (hasDestinationLink) return 0;
+	return resolvedSourceKey;
 };
 
 export const resolvePendingDestinationRetrySignal = (params: {
@@ -148,7 +173,7 @@ export const resolvePendingDestinationRetrySignal = (params: {
 	retryProgressMax: number;
 	retryProgressBuckets: number;
 	resolvedSourceKey?: string | null;
-	hasPendingLinkFromSource: boolean;
+	hasAttachableSourceLink: boolean;
 }): number => {
 	"worklet";
 	const {
@@ -161,7 +186,7 @@ export const resolvePendingDestinationRetrySignal = (params: {
 		retryProgressMax,
 		retryProgressBuckets,
 		resolvedSourceKey,
-		hasPendingLinkFromSource,
+		hasAttachableSourceLink,
 	} = params;
 
 	if (!enabled) return 0;
@@ -170,39 +195,23 @@ export const resolvePendingDestinationRetrySignal = (params: {
 	if (hasDestinationLink) return 0;
 	if (progress <= 0 || progress >= retryProgressMax) return 0;
 	if (!resolvedSourceKey) return 0;
-	if (!hasPendingLinkFromSource) return 0;
+	if (!hasAttachableSourceLink) return 0;
 
 	return Math.floor(progress * retryProgressBuckets) + 1;
 };
 
-export const resolveInitialLayoutMeasurementIntent = (params: {
-	enabled: boolean;
-	hasSharedBoundTag: boolean;
-	hasMeasuredOnLayout: boolean;
-	isAnyAnimating: boolean;
-	hasPendingLinkFromSource: boolean;
-}): MeasurementIntent | readonly MeasurementIntent[] | null => {
+export const resolvePrepareSourceMeasurementIntent = (params: {
+	hasSourceLink: boolean;
+}): MeasurementIntent | null => {
 	"worklet";
-	const {
-		enabled,
-		hasSharedBoundTag,
-		hasMeasuredOnLayout,
-		isAnyAnimating,
-		hasPendingLinkFromSource,
-	} = params;
-
-	if (!enabled) return null;
-	if (!hasSharedBoundTag || hasMeasuredOnLayout) return null;
-
-	if (!isAnyAnimating) {
-		return "snapshot-only";
-	}
-
-	return hasPendingLinkFromSource
-		? ["snapshot-only", "complete-destination"]
-		: "snapshot-only";
+	return params.hasSourceLink ? null : "capture-source";
 };
 
+export const PREPARE_DESTINATION_MEASUREMENT_INTENT = [
+	"complete-destination",
+	"refresh-destination",
+] as const satisfies readonly MeasurementIntent[];
+
 export const resolveGroupActiveMeasurementAction = (params: {
 	enabled: boolean;
 	isEligible: boolean;

package/src/shared/components/create-boundary-component/hooks/use-auto-source-measurement.ts

@@ -1,16 +1,24 @@
 import { useAnimatedReaction } from "react-native-reanimated";
 import { BoundStore } from "../../../stores/bounds";
-import type { MaybeMeasureAndStoreParams } from "../types";
+import type { BoundaryId, MaybeMeasureAndStoreParams } from "../types";
 import { resolveAutoSourceCaptureSignal } from "./helpers/measurement-rules";
 
 export const useAutoSourceMeasurement = (params: {
 	enabled: boolean;
 	sharedBoundTag: string;
+	id: BoundaryId;
+	group?: string;
 	nextScreenKey?: string;
 	maybeMeasureAndStore: (options: MaybeMeasureAndStoreParams) => void;
 }) => {
-	const { enabled, sharedBoundTag, nextScreenKey, maybeMeasureAndStore } =
-		params;
+	const {
+		enabled,
+		sharedBoundTag,
+		id,
+		group,
+		nextScreenKey,
+		maybeMeasureAndStore,
+	} = params;
 	const boundaryPresence = BoundStore.getBoundaryPresence();
 
 	useAnimatedReaction(
@@ -27,10 +35,18 @@ export const useAutoSourceMeasurement = (params: {
 			if (!enabled) return;
 			if (!nextScreenKey) return;
 			if (!captureSignal || captureSignal === previousCaptureSignal) return;
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+			if (group && currentGroupActiveId !== String(id)) {
+				return;
+			}
 			maybeMeasureAndStore({ intent: "capture-source" });
 		},
 		[
 			enabled,
+			id,
+			group,
 			nextScreenKey,
 			sharedBoundTag,
 			boundaryPresence,

package/src/shared/components/create-boundary-component/hooks/use-boundary-measure-and-store.ts

@@ -3,10 +3,10 @@ import {
 	type AnimatedRef,
 	type MeasuredDimensions,
 	measure,
-	type SharedValue,
 	type StyleProps,
 } from "react-native-reanimated";
 import useStableCallbackValue from "../../../hooks/use-stable-callback-value";
+import { useLayoutAnchorContext } from "../../../providers/layout-anchor.provider";
 import { BoundStore } from "../../../stores/bounds";
 import { applyMeasuredBoundsWrites } from "../../../stores/bounds/helpers/apply-measured-bounds-writes";
 import { resolvePendingSourceKey } from "../helpers/resolve-pending-source-key";
@@ -16,11 +16,6 @@ import {
 	resolveMeasurementWritePlan,
 } from "./helpers/measurement-rules";
 
-type LayoutAnchor = {
-	correctMeasurement: (measured: MeasuredDimensions) => MeasuredDimensions;
-	isMeasurementInViewport?: (measured: MeasuredDimensions) => boolean;
-} | null;
-
 const SNAPSHOT_EPSILON = 0.5;
 
 const areMeasurementsEqual = (
@@ -47,10 +42,8 @@ export const useBoundaryMeasureAndStore = (params: {
 	ancestorKeys: string[];
 	navigatorKey?: string;
 	ancestorNavigatorKeys?: string[];
-	isAnimating: SharedValue<number>;
 	preparedStyles: StyleProps;
-	animatedRef: AnimatedRef<View>;
-	layoutAnchor: LayoutAnchor;
+	measuredAnimatedRef: AnimatedRef<View>;
 }) => {
 	const {
 		enabled,
@@ -60,12 +53,12 @@ export const useBoundaryMeasureAndStore = (params: {
 		ancestorKeys,
 		navigatorKey,
 		ancestorNavigatorKeys,
-		isAnimating,
 		preparedStyles,
-		animatedRef,
-		layoutAnchor,
+		measuredAnimatedRef,
 	} = params;
 
+	const layoutAnchor = useLayoutAnchorContext();
+
 	return useStableCallbackValue(
 		({ intent }: MaybeMeasureAndStoreParams = {}) => {
 			"worklet";
@@ -77,36 +70,15 @@ export const useBoundaryMeasureAndStore = (params: {
 				resolvePendingSourceKey(sharedBoundTag, preferredSourceScreenKey) ||
 				undefined;
 
-			if (intents.captureSource && isAnimating.get()) {
-				const existing = BoundStore.getSnapshot(
-					sharedBoundTag,
-					currentScreenKey,
-				);
-				if (existing) {
-					applyMeasuredBoundsWrites({
-						sharedBoundTag,
-						ancestorKeys,
-						navigatorKey,
-						ancestorNavigatorKeys,
-						currentScreenKey,
-						measured: existing.bounds,
-						preparedStyles,
-						shouldSetSource: true,
-					});
-					return;
-				}
-
-				// No cached snapshot while animating.
-				// Fall through to a live measurement so rapid retargeting still
-				// captures a valid source link.
-			}
-
 			const hasPendingLink = expectedSourceScreenKey
 				? BoundStore.hasPendingLinkFromSource(
 						sharedBoundTag,
 						expectedSourceScreenKey,
 					)
 				: BoundStore.hasPendingLink(sharedBoundTag);
+			const hasAttachableSourceLink = expectedSourceScreenKey
+				? BoundStore.hasSourceLink(sharedBoundTag, expectedSourceScreenKey)
+				: false;
 			const hasSourceLink = BoundStore.hasSourceLink(
 				sharedBoundTag,
 				currentScreenKey,
@@ -121,13 +93,14 @@ export const useBoundaryMeasureAndStore = (params: {
 				hasPendingLink,
 				hasSourceLink,
 				hasDestinationLink,
+				hasAttachableSourceLink,
 			});
 
 			if (!writePlan.writesAny) {
 				return;
 			}
 
-			const measured = measure(animatedRef);
+			const measured = measure(measuredAnimatedRef);
 			if (!measured) return;
 
 			const correctedMeasured = layoutAnchor
@@ -155,13 +128,7 @@ export const useBoundaryMeasureAndStore = (params: {
 			const hasSnapshotChanged =
 				!existingSnapshot ||
 				!areMeasurementsEqual(existingSnapshot.bounds, correctedMeasured);
-			const shouldWriteSnapshot =
-				hasSnapshotChanged &&
-				(writePlan.registerSnapshot ||
-					writePlan.captureSource ||
-					writePlan.completeDestination ||
-					writePlan.refreshSource ||
-					writePlan.refreshDestination);
+			const shouldWriteSnapshot = hasSnapshotChanged;
 
 			applyMeasuredBoundsWrites({
 				sharedBoundTag,

package/src/shared/components/create-boundary-component/hooks/use-pending-destination-measurement.ts

@@ -1,25 +1,102 @@
-import { useAnimatedReaction } from "react-native-reanimated";
+import { useLayoutEffect } from "react";
+import {
+	runOnUI,
+	type SharedValue,
+	useAnimatedReaction,
+	useSharedValue,
+} from "react-native-reanimated";
+import { AnimationStore } from "../../../stores/animation.store";
 import { BoundStore } from "../../../stores/bounds";
 import { resolvePendingSourceKey } from "../helpers/resolve-pending-source-key";
-import type { MaybeMeasureAndStoreParams } from "../types";
-import { resolvePendingDestinationCaptureSignal } from "./helpers/measurement-rules";
+import type { BoundaryId, MaybeMeasureAndStoreParams } from "../types";
+import {
+	resolvePendingDestinationCaptureSignal,
+	resolvePendingDestinationRetrySignal,
+} from "./helpers/measurement-rules";
 
 export const usePendingDestinationMeasurement = (params: {
 	sharedBoundTag: string;
 	enabled: boolean;
+	id: BoundaryId;
+	group?: string;
+	currentScreenKey: string;
 	expectedSourceScreenKey?: string;
+	animating: SharedValue<number>;
 	maybeMeasureAndStore: (options: MaybeMeasureAndStoreParams) => void;
 }) => {
 	const {
 		sharedBoundTag,
 		enabled,
+		id,
+		group,
+		currentScreenKey,
 		expectedSourceScreenKey,
+		animating,
 		maybeMeasureAndStore,
 	} = params;
 
+	const progress = AnimationStore.getValue(currentScreenKey, "progress");
+	const closing = AnimationStore.getValue(currentScreenKey, "closing");
+
+	const retryCount = useSharedValue(0);
+	const MAX_RETRIES = 4;
+	const RETRY_PROGRESS_BUCKETS = 8;
+	const RETRY_PROGRESS_MAX = 1.05;
+
+	useLayoutEffect(() => {
+		if (!enabled) return;
+
+		runOnUI(() => {
+			"worklet";
+			if (closing.get()) {
+				return;
+			}
+
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+			if (group && currentGroupActiveId !== String(id)) {
+				return;
+			}
+
+			const resolvedSourceKey = resolvePendingSourceKey(
+				sharedBoundTag,
+				expectedSourceScreenKey,
+			);
+			const hasAttachableSourceLink = resolvedSourceKey
+				? BoundStore.hasPendingLinkFromSource(
+						sharedBoundTag,
+						resolvedSourceKey,
+					) || BoundStore.hasSourceLink(sharedBoundTag, resolvedSourceKey)
+				: false;
+
+			if (!hasAttachableSourceLink) {
+				return;
+			}
+
+			if (BoundStore.hasDestinationLink(sharedBoundTag, currentScreenKey)) {
+				return;
+			}
+
+			maybeMeasureAndStore({ intent: "complete-destination" });
+		})();
+	}, [
+		enabled,
+		id,
+		group,
+		sharedBoundTag,
+		currentScreenKey,
+		expectedSourceScreenKey,
+		closing,
+		maybeMeasureAndStore,
+	]);
+
 	useAnimatedReaction(
 		() => {
 			"worklet";
+			if (closing.get()) {
+				return 0;
+			}
 			const resolvedSourceKey = resolvePendingSourceKey(
 				sharedBoundTag,
 				expectedSourceScreenKey,
@@ -27,12 +104,16 @@ export const usePendingDestinationMeasurement = (params: {
 			return resolvePendingDestinationCaptureSignal({
 				enabled,
 				resolvedSourceKey,
-				hasPendingLinkFromSource: resolvedSourceKey
+				hasAttachableSourceLink: resolvedSourceKey
 					? BoundStore.hasPendingLinkFromSource(
 							sharedBoundTag,
 							resolvedSourceKey,
-						)
+						) || BoundStore.hasSourceLink(sharedBoundTag, resolvedSourceKey)
 					: false,
+				hasDestinationLink: BoundStore.hasDestinationLink(
+					sharedBoundTag,
+					currentScreenKey,
+				),
 			});
 		},
 		(captureSignal, previousCaptureSignal) => {
@@ -41,9 +122,87 @@ export const usePendingDestinationMeasurement = (params: {
 			if (!captureSignal || captureSignal === previousCaptureSignal) {
 				return;
 			}
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+			if (group && currentGroupActiveId !== String(id)) {
+				return;
+			}
+
+			maybeMeasureAndStore({ intent: "complete-destination" });
+		},
+		[
+			enabled,
+			id,
+			group,
+			sharedBoundTag,
+			expectedSourceScreenKey,
+			closing,
+			maybeMeasureAndStore,
+		],
+	);
+
+	useAnimatedReaction(
+		() => {
+			"worklet";
+			if (closing.get()) {
+				return 0;
+			}
+			const resolvedSourceKey = resolvePendingSourceKey(
+				sharedBoundTag,
+				expectedSourceScreenKey,
+			);
+			return resolvePendingDestinationRetrySignal({
+				enabled,
+				retryCount: retryCount.get(),
+				maxRetries: MAX_RETRIES,
+				isAnimating: !!animating.get(),
+				hasDestinationLink: BoundStore.hasDestinationLink(
+					sharedBoundTag,
+					currentScreenKey,
+				),
+				progress: progress.get(),
+				retryProgressMax: RETRY_PROGRESS_MAX,
+				retryProgressBuckets: RETRY_PROGRESS_BUCKETS,
+				resolvedSourceKey,
+				hasAttachableSourceLink: resolvedSourceKey
+					? BoundStore.hasPendingLinkFromSource(
+							sharedBoundTag,
+							resolvedSourceKey,
+						) || BoundStore.hasSourceLink(sharedBoundTag, resolvedSourceKey)
+					: false,
+			});
+		},
+		(captureSignal) => {
+			"worklet";
+			if (!enabled) return;
+			if (!captureSignal) {
+				retryCount.set(0);
+				return;
+			}
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+			if (group && currentGroupActiveId !== String(id)) {
+				return;
+			}
 
+			if (retryCount.get() >= MAX_RETRIES) return;
+			retryCount.set(retryCount.get() + 1);
 			maybeMeasureAndStore({ intent: "complete-destination" });
 		},
-		[enabled, sharedBoundTag, expectedSourceScreenKey, maybeMeasureAndStore],
+		[
+			enabled,
+			id,
+			group,
+			sharedBoundTag,
+			currentScreenKey,
+			expectedSourceScreenKey,
+			progress,
+			animating,
+			closing,
+			maybeMeasureAndStore,
+			retryCount,
+		],
 	);
 };