react-native-screen-transitions 3.5.2 → 3.6.0-alpha.1

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

@@ -1,10 +1,5 @@
 import type { MeasureIntent } from "../../types";
 
-type PresenceLikeEntry = {
-	count: number;
-	ancestorKeys?: string[];
-};
-
 export type MeasureIntentFlags = {
 	captureSource: boolean;
 	completeDestination: boolean;
@@ -21,10 +16,16 @@ export type MeasureWritePlan = {
 	wantsDestinationWrite: boolean;
 };
 
-export type DeferredMeasurementAction =
-	| "clear-pending"
-	| "queue-or-flush"
-	| "noop";
+export const shouldBlockInitialDestinationMeasurement = (params: {
+	enabled: boolean;
+	hasDestinationLink: boolean;
+	hasAttachableSourceLink: boolean;
+}): boolean => {
+	"worklet";
+	const { enabled, hasDestinationLink, hasAttachableSourceLink } = params;
+
+	return enabled && hasAttachableSourceLink && !hasDestinationLink;
+};
 
 export const getMeasureIntentFlags = (
 	intent?: MeasureIntent | readonly MeasureIntent[],
@@ -63,7 +64,7 @@ export const getMeasureIntentFlags = (
 	return flags;
 };
 
-export const resolveMeasureWritePlan = (params: {
+export const buildMeasurementWritePlan = (params: {
 	intents: MeasureIntentFlags;
 	hasPendingLink: boolean;
 	hasSourceLink: boolean;
@@ -98,175 +99,3 @@ export const resolveMeasureWritePlan = (params: {
 		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 } = params;
-	if (!enabled) return 0;
-	if (!nextScreenKey) return 0;
-
-	/**
-	 * 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 nextScreenKey;
-};
-
-export const resolvePendingDestinationCaptureSignal = (params: {
-	enabled: boolean;
-	resolvedSourceKey?: string | null;
-	hasAttachableSourceLink: boolean;
-	hasDestinationLink: boolean;
-}): string | 0 => {
-	"worklet";
-	const {
-		enabled,
-		resolvedSourceKey,
-		hasAttachableSourceLink,
-		hasDestinationLink,
-	} = params;
-	if (!enabled) return 0;
-	if (!resolvedSourceKey) return 0;
-	if (!hasAttachableSourceLink) return 0;
-	if (hasDestinationLink) return 0;
-	return resolvedSourceKey;
-};
-
-export const resolvePendingDestinationRetrySignal = (params: {
-	enabled: boolean;
-	retryCount: number;
-	maxRetries: number;
-	isAnimating: boolean;
-	hasDestinationLink: boolean;
-	progress: number;
-	retryProgressMax: number;
-	retryProgressBuckets: number;
-	resolvedSourceKey?: string | null;
-	hasAttachableSourceLink: boolean;
-}): number => {
-	"worklet";
-	const {
-		enabled,
-		retryCount,
-		maxRetries,
-		isAnimating,
-		hasDestinationLink,
-		progress,
-		retryProgressMax,
-		retryProgressBuckets,
-		resolvedSourceKey,
-		hasAttachableSourceLink,
-	} = params;
-
-	if (!enabled) return 0;
-	if (retryCount >= maxRetries) return 0;
-	if (!isAnimating) return 0;
-	if (hasDestinationLink) return 0;
-	if (progress <= 0 || progress >= retryProgressMax) return 0;
-	if (!resolvedSourceKey) return 0;
-	if (!hasAttachableSourceLink) return 0;
-
-	return Math.floor(progress * retryProgressBuckets) + 1;
-};
-
-export const resolvePrepareSourceMeasurementIntent = (params: {
-	hasSourceLink: boolean;
-	shouldRefreshExistingSource: boolean;
-}): MeasureIntent | null => {
-	"worklet";
-	if (!params.hasSourceLink) {
-		return "capture-source";
-	}
-
-	return params.shouldRefreshExistingSource ? "refresh-source" : null;
-};
-
-export const PREPARE_DESTINATION_MEASUREMENT_INTENT = [
-	"complete-destination",
-	"refresh-destination",
-] as const satisfies readonly MeasureIntent[];
-
-export const resolveGroupActiveMeasurementAction = (params: {
-	enabled: boolean;
-	isEligible: boolean;
-	memberId: string;
-	activeId: string | null;
-	previousActiveId: string | null;
-}): DeferredMeasurementAction => {
-	"worklet";
-	const { enabled, isEligible, memberId, activeId, previousActiveId } = params;
-
-	if (!enabled || !isEligible) return "noop";
-	if (activeId !== memberId) return "clear-pending";
-	if (activeId === memberId && activeId !== previousActiveId) {
-		return "queue-or-flush";
-	}
-	return "noop";
-};
-
-export const canFlushGroupActiveMeasurement = (params: {
-	enabled: boolean;
-	isEligible: boolean;
-	memberId: string;
-	activeId: string | null;
-}): boolean => {
-	"worklet";
-	const { enabled, isEligible, memberId, activeId } = params;
-	if (!enabled || !isEligible) return false;
-	return activeId === memberId;
-};
-
-export const shouldTriggerScrollSettledRefresh = (params: {
-	enabled: boolean;
-	group: string | undefined;
-	hasNextScreen: boolean;
-	hasSettledSignal: boolean;
-	signal: number;
-	previousSignal: number | null;
-}): boolean => {
-	"worklet";
-	const {
-		enabled,
-		group,
-		hasNextScreen,
-		hasSettledSignal,
-		signal,
-		previousSignal,
-	} = params;
-
-	if (!enabled) return false;
-	if (!group || !hasNextScreen || !hasSettledSignal) return false;
-	if (signal === 0 || signal === previousSignal) return false;
-	return true;
-};

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

@@ -1,23 +1,5 @@
 import type { MeasuredDimensions } from "react-native-reanimated";
 
-export const SNAPSHOT_EPSILON = 0.5;
-
-export const areMeasurementsEqual = (
-	a: MeasuredDimensions,
-	b: MeasuredDimensions,
-): boolean => {
-	"worklet";
-
-	return (
-		Math.abs(a.x - b.x) <= SNAPSHOT_EPSILON &&
-		Math.abs(a.y - b.y) <= SNAPSHOT_EPSILON &&
-		Math.abs(a.pageX - b.pageX) <= SNAPSHOT_EPSILON &&
-		Math.abs(a.pageY - b.pageY) <= SNAPSHOT_EPSILON &&
-		Math.abs(a.width - b.width) <= SNAPSHOT_EPSILON &&
-		Math.abs(a.height - b.height) <= SNAPSHOT_EPSILON
-	);
-};
-
 export const isMeasurementInViewport = (
 	measured: MeasuredDimensions,
 	viewportWidth: number,

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

@@ -0,0 +1,58 @@
+import type { View } from "react-native";
+import {
+	type AnimatedRef,
+	type MeasuredDimensions,
+	measure,
+} from "react-native-reanimated";
+import type {
+	ScrollGestureAxisState,
+	ScrollGestureState,
+} from "../../../../types/gesture.types";
+
+const SCROLL_MEASUREMENT_EPSILON = 1;
+
+const getOverscrollDelta = (axisState: ScrollGestureAxisState): number => {
+	"worklet";
+	const maxOffset = Math.max(0, axisState.contentSize - axisState.layoutSize);
+	const clampedOffset = Math.min(Math.max(axisState.offset, 0), maxOffset);
+	const delta = axisState.offset - clampedOffset;
+
+	return Math.abs(delta) > SCROLL_MEASUREMENT_EPSILON ? delta : 0;
+};
+
+export const adjustedMeasuredBoundsForOverscrollDeltas = (
+	measured: MeasuredDimensions,
+	scrollState: ScrollGestureState | null,
+): MeasuredDimensions => {
+	"worklet";
+
+	if (!scrollState) {
+		return measured;
+	}
+
+	const deltaX = getOverscrollDelta(scrollState.horizontal);
+	const deltaY = getOverscrollDelta(scrollState.vertical);
+
+	if (deltaX === 0 && deltaY === 0) {
+		return measured;
+	}
+
+	return {
+		...measured,
+		x: measured.x + deltaX,
+		y: measured.y + deltaY,
+		pageX: measured.pageX + deltaX,
+		pageY: measured.pageY + deltaY,
+	};
+};
+
+export const measureWithOverscrollAwareness = (
+	ref: AnimatedRef<View>,
+	scrollState: ScrollGestureState | null,
+): MeasuredDimensions | null => {
+	"worklet";
+	const measured = measure(ref);
+	if (!measured) return null;
+
+	return adjustedMeasuredBoundsForOverscrollDeltas(measured, scrollState);
+};

package/src/shared/components/create-boundary-component/hooks/use-boundary-presence.ts

@@ -3,51 +3,26 @@ import { runOnUI } from "react-native-reanimated";
 import {
 	removeEntry,
 	setEntry,
-} from "../../../stores/bounds/internals/registry";
+} from "../../../stores/bounds/internals/entries";
 import type { BoundaryConfigProps } from "../types";
 
 export const useBoundaryPresence = (params: {
 	enabled: boolean;
 	sharedBoundTag: string;
 	currentScreenKey: string;
-	ancestorKeys: string[];
-	navigatorKey?: string;
-	ancestorNavigatorKeys?: string[];
 	boundaryConfig?: BoundaryConfigProps;
 }) => {
-	const {
-		enabled,
-		sharedBoundTag,
-		currentScreenKey,
-		ancestorKeys,
-		navigatorKey,
-		ancestorNavigatorKeys,
-		boundaryConfig,
-	} = params;
-	const ancestorKeysSignature = ancestorKeys.join("|");
-	const ancestorNavigatorKeysSignature = ancestorNavigatorKeys?.join("|");
+	const { enabled, sharedBoundTag, currentScreenKey, boundaryConfig } = params;
 
-	// biome-ignore lint/correctness/useExhaustiveDependencies: <Depend on the ancestory keys signature>
 	useLayoutEffect(() => {
 		if (!enabled) return;
 
 		runOnUI(setEntry)(sharedBoundTag, currentScreenKey, {
-			ancestorKeys,
 			boundaryConfig,
-			navigatorKey,
-			ancestorNavigatorKeys,
 		});
 
 		return () => {
 			runOnUI(removeEntry)(sharedBoundTag, currentScreenKey);
 		};
-	}, [
-		enabled,
-		sharedBoundTag,
-		currentScreenKey,
-		ancestorKeysSignature,
-		navigatorKey,
-		ancestorNavigatorKeysSignature,
-		boundaryConfig,
-	]);
+	}, [enabled, sharedBoundTag, currentScreenKey, boundaryConfig]);
 };

package/src/shared/components/create-boundary-component/hooks/{use-capture-destination-boundary.ts → use-initial-destination-measurement.ts}

@@ -1,47 +1,40 @@
-import { useLayoutEffect } from "react";
 import {
 	cancelAnimation,
-	runOnUI,
 	useAnimatedReaction,
 	useSharedValue,
 	withDelay,
 	withTiming,
 } from "react-native-reanimated";
 import { AnimationStore } from "../../../stores/animation.store";
-import { getGroupActiveId } from "../../../stores/bounds/internals/groups";
+import { hasDestinationLink } from "../../../stores/bounds/internals/links";
 import {
-	getPendingLink,
-	hasDestinationLink,
-	hasSourceLink,
-} from "../../../stores/bounds/internals/registry";
-import { SystemStore } from "../../../stores/system.store";
-import { resolvePendingSourceKey } from "../helpers/resolve-pending-source-key";
-import type { BoundaryId, MeasureParams } from "../types";
+	LifecycleTransitionRequestKind,
+	SystemStore,
+} from "../../../stores/system.store";
+import type { MeasureParams } from "../types";
+import { createLinkContext } from "./helpers/boundary-link-context";
+import { shouldBlockInitialDestinationMeasurement } from "./helpers/measurement-rules";
 
 const VIEWPORT_RETRY_DELAY_MS = 16;
 
-interface UseCaptureDestinationBoundaryParams {
+interface UseInitialDestinationMeasurementParams {
 	sharedBoundTag: string;
 	enabled: boolean;
-	id: BoundaryId;
-	group?: string;
 	currentScreenKey: string;
-	expectedSourceScreenKey?: string;
+	preferredSourceScreenKey?: string;
 	measureBoundary: (options: MeasureParams) => void;
 }
 
-export const useCaptureDestinationBoundary = ({
+export const useInitialDestinationMeasurement = ({
 	sharedBoundTag,
 	enabled,
-	id,
-	group,
 	currentScreenKey,
-	expectedSourceScreenKey,
+	preferredSourceScreenKey,
 	measureBoundary,
-}: UseCaptureDestinationBoundaryParams) => {
-	const animating = AnimationStore.getValue(currentScreenKey, "animating");
-	const closing = AnimationStore.getValue(currentScreenKey, "closing");
+}: UseInitialDestinationMeasurementParams) => {
+	const progress = AnimationStore.getValue(currentScreenKey, "progress");
 	const system = SystemStore.getBag(currentScreenKey);
+	const { pendingLifecycleRequestKind } = system;
 	const { blockLifecycleStart, unblockLifecycleStart } = system.actions;
 	const isBlockingLifecycleStart = useSharedValue(0);
 	const retryToken = useSharedValue(0);
@@ -84,37 +77,32 @@ export const useCaptureDestinationBoundary = ({
 			"worklet";
 			const retryTick = retryToken.get();
 
-			if (closing.get() || animating.get()) {
+			const hasPendingOpenRequest =
+				pendingLifecycleRequestKind.get() ===
+				LifecycleTransitionRequestKind.Open;
+
+			const isWaitingForOpenToStart = progress.get() <= 0;
+
+			if (!hasPendingOpenRequest || !isWaitingForOpenToStart) {
 				return [0, retryTick] as const;
 			}
 
-			const resolvedSourceKey = resolvePendingSourceKey(
-				sharedBoundTag,
-				expectedSourceScreenKey,
-			);
-			const hasAttachableSourceLink = resolvedSourceKey
-				? getPendingLink(sharedBoundTag, resolvedSourceKey) !== null ||
-					hasSourceLink(sharedBoundTag, resolvedSourceKey)
-				: false;
-			const hasDestination = hasDestinationLink(
+			const linkContext = createLinkContext({
 				sharedBoundTag,
 				currentScreenKey,
-			);
+				preferredSourceScreenKey,
+			});
 
-			const shouldBlock =
-				enabled &&
-				!!resolvedSourceKey &&
-				hasAttachableSourceLink &&
-				!hasDestination;
+			const shouldBlock = shouldBlockInitialDestinationMeasurement({
+				enabled,
+				hasDestinationLink: linkContext.hasDestinationLink,
+				hasAttachableSourceLink: linkContext.hasAttachableSourceLink,
+			});
 
 			if (!shouldBlock) {
 				return [0, retryTick] as const;
 			}
 
-			if (group && getGroupActiveId(group) !== String(id)) {
-				return [0, retryTick] as const;
-			}
-
 			return [1, retryTick] as const;
 		},
 		([shouldBlock]) => {
@@ -135,20 +123,4 @@ export const useCaptureDestinationBoundary = ({
 			scheduleViewportRetry();
 		},
 	);
-
-	useLayoutEffect(() => {
-		return () => {
-			runOnUI(() => {
-				"worklet";
-				cancelAnimation(retryToken);
-
-				if (!isBlockingLifecycleStart.get()) {
-					return;
-				}
-
-				unblockLifecycleStart();
-				isBlockingLifecycleStart.set(0);
-			})();
-		};
-	}, [isBlockingLifecycleStart, retryToken, unblockLifecycleStart]);
 };

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

@@ -0,0 +1,27 @@
+import { useAnimatedReaction } from "react-native-reanimated";
+import type { MeasureParams } from "../types";
+
+export const useInitialSourceMeasurement = (params: {
+	enabled: boolean;
+	nextScreenKey?: string;
+	measureBoundary: (options: MeasureParams) => void;
+}) => {
+	const { enabled, nextScreenKey, measureBoundary } = params;
+
+	useAnimatedReaction(
+		() => {
+			"worklet";
+			if (!enabled || !nextScreenKey) {
+				return 0;
+			}
+
+			return nextScreenKey;
+		},
+		(captureSignal) => {
+			"worklet";
+			if (!enabled || !captureSignal) return;
+
+			measureBoundary({ intent: "capture-source" });
+		},
+	);
+};