react-native-screen-transitions 3.4.0-alpha.7 → 3.4.0-beta.1

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;
+	/**
+	 * 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;
 
-	for (const screenKey in tagPresence) {
-		const entry = tagPresence[screenKey];
-		if (entry.ancestorKeys?.includes(nextScreenKey)) {
-			return nextScreenKey;
-		}
-	}
-
-	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,34 +195,28 @@ 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;
+	shouldRefreshExistingSource: boolean;
+}): MeasurementIntent | null => {
 	"worklet";
-	const {
-		enabled,
-		hasSharedBoundTag,
-		hasMeasuredOnLayout,
-		isAnyAnimating,
-		hasPendingLinkFromSource,
-	} = params;
-
-	if (!enabled) return null;
-	if (!hasSharedBoundTag || hasMeasuredOnLayout) return null;
-	if (!isAnyAnimating) return null;
+	if (!params.hasSourceLink) {
+		return "capture-source";
+	}
 
-	return hasPendingLinkFromSource ? "complete-destination" : null;
+	return params.shouldRefreshExistingSource ? "refresh-source" : null;
 };
 
+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,7 +3,6 @@ import {
 	type AnimatedRef,
 	type MeasuredDimensions,
 	measure,
-	type SharedValue,
 	type StyleProps,
 } from "react-native-reanimated";
 import useStableCallbackValue from "../../../hooks/use-stable-callback-value";
@@ -43,7 +42,6 @@ export const useBoundaryMeasureAndStore = (params: {
 	ancestorKeys: string[];
 	navigatorKey?: string;
 	ancestorNavigatorKeys?: string[];
-	isAnimating: SharedValue<number>;
 	preparedStyles: StyleProps;
 	measuredAnimatedRef: AnimatedRef<View>;
 }) => {
@@ -55,7 +53,6 @@ export const useBoundaryMeasureAndStore = (params: {
 		ancestorKeys,
 		navigatorKey,
 		ancestorNavigatorKeys,
-		isAnimating,
 		preparedStyles,
 		measuredAnimatedRef,
 	} = params;
@@ -73,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,
@@ -117,6 +93,7 @@ export const useBoundaryMeasureAndStore = (params: {
 				hasPendingLink,
 				hasSourceLink,
 				hasDestinationLink,
+				hasAttachableSourceLink,
 			});
 
 			if (!writePlan.writesAny) {
@@ -151,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,127 @@
-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";
 
+/**
+ * The current v3.4 behavior intentionally favors correctness over efficiency:
+ * when destination layout races transition start, this hook may re-measure
+ * multiple times to recover a usable pair for `navigation.zoom()`.
+ *
+ * This works well enough for now, but it is not the ideal architecture. A more
+ * complete v4 solution should allow open-animation deferral and broader
+ * readiness coordination so we can avoid repeated measurement work while still
+ * handling multiple transition scenarios correctly. Until that system exists,
+ * `navigation.zoom()` remains fast in practice, just not as performant as it
+ * could be.
+ *
+ * For now, you may notice a slight stutter towards the end of the animation.
+ */
 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,
+	]);
+
+	/**
+	 * This exessive retry for groups with {target:"bound"} will have to change in v4.
+	 * .navigation.zoom() is stable and works great for non groups and groups that are non {target: "bound"}.
+	 *
+	 * The retry logic is needed for dst screen when we do an initialScrollIndex, the system is competing with the (i assume) useLayoutEffect
+	 * in the scrollable, causing a race here and giving us wrong measurements. I believe, in simialr fashion to how
+	 * system.store defers the screen from animating, we could possibly do the same here. Registering it up, once we get valid measurements, we can
+	 * un defer? Is that the word? Undefer the screen, removing this block compeltely, avoiding any potential flickers ( which currently happens.)
+	 *
+	 * You can replicate this bug by dismissing dst, as dst reaches its ending tail (0.01->0.10), if we tap again, we notice a flicker.
+	 */
 	useAnimatedReaction(
 		() => {
 			"worklet";
+			if (closing.get()) {
+				return 0;
+			}
 			const resolvedSourceKey = resolvePendingSourceKey(
 				sharedBoundTag,
 				expectedSourceScreenKey,
@@ -27,12 +129,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) => {
@@ -42,8 +148,76 @@ export const usePendingDestinationMeasurement = (params: {
 				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 (!group) return;
+			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],
 	);
 };

package/src/shared/components/create-boundary-component/hooks/use-pre-transition-measurement.ts

@@ -0,0 +1,110 @@
+import { useAnimatedReaction } from "react-native-reanimated";
+import { AnimationStore } from "../../../stores/animation.store";
+import { BoundStore } from "../../../stores/bounds";
+import { GestureStore } from "../../../stores/gesture.store";
+import type { BoundaryId, MaybeMeasureAndStoreParams } from "../types";
+import {
+	PREPARE_DESTINATION_MEASUREMENT_INTENT,
+	resolvePrepareSourceMeasurementIntent,
+} from "./helpers/measurement-rules";
+
+export const usePreTransitionMeasurement = (params: {
+	enabled: boolean;
+	sharedBoundTag: string;
+	id: BoundaryId;
+	group?: string;
+	currentScreenKey: string;
+	nextScreenKey?: string;
+	hasNextScreen: boolean;
+	maybeMeasureAndStore: (options: MaybeMeasureAndStoreParams) => void;
+}) => {
+	const {
+		enabled,
+		sharedBoundTag,
+		id,
+		group,
+		currentScreenKey,
+		nextScreenKey,
+		hasNextScreen,
+		maybeMeasureAndStore,
+	} = params;
+
+	const currentWillAnimate = AnimationStore.getValue(
+		currentScreenKey,
+		"willAnimate",
+	);
+	const currentAnimating = AnimationStore.getValue(
+		currentScreenKey,
+		"animating",
+	);
+	const currentDragging = GestureStore.getValue(currentScreenKey, "dragging");
+	const nextWillAnimate = nextScreenKey
+		? AnimationStore.getValue(nextScreenKey, "willAnimate")
+		: null;
+	const nextAnimating = nextScreenKey
+		? AnimationStore.getValue(nextScreenKey, "animating")
+		: null;
+	const nextDragging = nextScreenKey
+		? GestureStore.getValue(nextScreenKey, "dragging")
+		: null;
+
+	useAnimatedReaction(
+		() => (hasNextScreen ? (nextWillAnimate?.get() ?? 0) : 0),
+		(nextValue, previousValue) => {
+			"worklet";
+			if (!enabled || !hasNextScreen) return;
+			if (nextValue === 0 || nextValue === previousValue) return;
+
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+
+			if (group && currentGroupActiveId !== String(id)) {
+				return;
+			}
+
+			const shouldCancelMeasurement =
+				!!nextAnimating?.get() && !!nextDragging?.get();
+			if (shouldCancelMeasurement) {
+				return;
+			}
+
+			const hasSourceLink = BoundStore.hasSourceLink(
+				sharedBoundTag,
+				currentScreenKey,
+			);
+
+			const intent = resolvePrepareSourceMeasurementIntent({
+				hasSourceLink,
+				shouldRefreshExistingSource: !!group,
+			});
+
+			if (!intent) {
+				return;
+			}
+
+			maybeMeasureAndStore({ intent });
+		},
+	);
+
+	useAnimatedReaction(
+		() => (!hasNextScreen ? currentWillAnimate.get() : 0),
+		(nextValue, previousValue) => {
+			"worklet";
+			if (!enabled || hasNextScreen) return;
+			if (nextValue === 0 || nextValue === previousValue) return;
+			const currentGroupActiveId = group
+				? BoundStore.getGroupActiveId(group)
+				: null;
+			if (group && currentGroupActiveId !== String(id)) return;
+
+			const shouldCancelMeasurement =
+				!!currentAnimating.get() && !!currentDragging.get();
+			if (shouldCancelMeasurement) return;
+
+			maybeMeasureAndStore({
+				intent: PREPARE_DESTINATION_MEASUREMENT_INTENT,
+			});
+		},
+	);
+};