react-native-screen-transitions 3.9.0 → 4.0.0-alpha.0

package/src/shared/providers/register-bounds.provider.tsx

@@ -1,402 +0,0 @@
-import { useFocusEffect } from "@react-navigation/native";
-import { type ReactNode, useCallback, useMemo, useRef } from "react";
-import type { View } from "react-native";
-import {
-	type AnimatedRef,
-	measure,
-	runOnJS,
-	runOnUI,
-	type StyleProps,
-	useAnimatedReaction,
-	useSharedValue,
-} from "react-native-reanimated";
-import type { SharedValue } from "react-native-reanimated/lib/typescript/commonTypes";
-import useStableCallback from "../hooks/use-stable-callback";
-import useStableCallbackValue from "../hooks/use-stable-callback-value";
-import { AnimationStore } from "../stores/animation.store";
-import {
-	createPendingPairKey,
-	createScreenPairKey,
-} from "../stores/bounds/helpers/link-pairs.helpers";
-import { getEntry } from "../stores/bounds/internals/entries";
-import { getDestination, getSource } from "../stores/bounds/internals/links";
-import { prepareStyleForBounds } from "../utils/bounds/helpers/styles/styles";
-import createProvider from "../utils/create-provider";
-import { applyMeasuredBoundsWrites } from "./helpers/measured-bounds-writes";
-import { useDescriptorDerivations, useDescriptors } from "./screen/descriptors";
-
-/**
- * @deprecated Internal legacy provider for the old shared-bound-tag registration
- * path. Do not build new boundary behavior here; use the Transition.Boundary
- * measurement pipeline instead.
- */
-interface MaybeMeasureAndStoreParams {
-	onPress?: ((...args: unknown[]) => void) | undefined;
-	shouldSetSource?: boolean;
-	shouldSetDestination?: boolean;
-}
-
-interface RegisterBoundsRenderProps {
-	handleInitialLayout: () => void;
-	captureActiveOnPress: () => void;
-}
-
-interface RegisterBoundsProviderProps {
-	sharedBoundTag?: string;
-	animatedRef: AnimatedRef<View>;
-	style: StyleProps;
-	onPress?: ((...args: unknown[]) => void) | undefined;
-	remeasureOnFocus?: boolean;
-	children: (props: RegisterBoundsRenderProps) => ReactNode;
-}
-
-interface RegisterBoundsContextValue {
-	updateSignal: SharedValue<number>;
-}
-
-const getRouteParamId = (
-	route: { params?: object } | undefined,
-): string | null => {
-	const params = route?.params as Record<string, unknown> | undefined;
-	const rawId = params?.id;
-	return typeof rawId === "string" ? rawId : null;
-};
-
-const matchesSelectionTag = (
-	tag: string | undefined,
-	selectedId: string | null,
-): boolean => {
-	"worklet";
-	if (!tag || !selectedId) return false;
-	if (tag === selectedId) return true;
-	if (tag.endsWith(`:${selectedId}`)) return true;
-	if (tag.endsWith(`-${selectedId}`)) return true;
-	return false;
-};
-
-/**
- * Handles initial layout measurement for destination elements.
- * Only measures if an animation is in progress (local or parent).
- */
-const useInitialLayoutHandler = (params: {
-	sharedBoundTag?: string;
-	currentScreenKey: string;
-	ancestorKeys: string[];
-	maybeMeasureAndStore: (options: MaybeMeasureAndStoreParams) => void;
-}) => {
-	const {
-		sharedBoundTag,
-		currentScreenKey,
-		ancestorKeys,
-		maybeMeasureAndStore,
-	} = params;
-
-	const isAnimating = AnimationStore.getValue(
-		currentScreenKey,
-		"progressAnimating",
-	);
-
-	// Check if any ancestor is animating
-	const ancestorAnimations = ancestorKeys.map((key) =>
-		AnimationStore.getValue(key, "progressAnimating"),
-	);
-
-	const hasMeasuredOnLayout = useSharedValue(false);
-
-	return useCallback(() => {
-		"worklet";
-		if (!sharedBoundTag || hasMeasuredOnLayout.get()) return;
-
-		// Check if current or any ancestor is animating
-		let isAnyAnimating = isAnimating.get();
-		for (let i = 0; i < ancestorAnimations.length; i++) {
-			if (ancestorAnimations[i].get()) {
-				isAnyAnimating = 1;
-				break;
-			}
-		}
-
-		if (!isAnyAnimating) return;
-
-		maybeMeasureAndStore({
-			shouldSetSource: false,
-			shouldSetDestination: true,
-		});
-
-		hasMeasuredOnLayout.set(true);
-	}, [
-		sharedBoundTag,
-		hasMeasuredOnLayout,
-		isAnimating,
-		ancestorAnimations,
-		maybeMeasureAndStore,
-	]);
-};
-
-/**
- * Measures non-pressable elements when screen becomes blurred.
- * Captures bounds right before transition starts.
- */
-const useBlurMeasurement = (params: {
-	enabled: boolean;
-	sharedBoundTag?: string;
-	selectedRouteId: string | null;
-	ancestorKeys: string[];
-	maybeMeasureAndStore: (options: MaybeMeasureAndStoreParams) => void;
-}) => {
-	const { current } = useDescriptors();
-	const {
-		enabled,
-		sharedBoundTag,
-		selectedRouteId,
-		ancestorKeys,
-		maybeMeasureAndStore,
-	} = params;
-	const hasCapturedSource = useRef(false);
-
-	const ancestorClosing = [current.route.key, ...ancestorKeys].map((key) =>
-		AnimationStore.getValue(key, "closing"),
-	);
-
-	const maybeMeasureOnBlur = useStableCallbackValue(() => {
-		"worklet";
-		if (!enabled) return;
-		if (!matchesSelectionTag(sharedBoundTag, selectedRouteId)) return;
-
-		//.some doesnt work here apparently... :-(
-		for (const closing of ancestorClosing) {
-			if (closing.get()) return;
-		}
-
-		maybeMeasureAndStore({ shouldSetSource: true });
-	});
-
-	useFocusEffect(
-		useCallback(() => {
-			hasCapturedSource.current = false;
-
-			if (!enabled) {
-				return;
-			}
-
-			return () => {
-				if (!sharedBoundTag || hasCapturedSource.current) return;
-				runOnUI(maybeMeasureOnBlur)();
-			};
-		}, [enabled, sharedBoundTag, maybeMeasureOnBlur]),
-	);
-
-	return {
-		markSourceCaptured: () => {
-			hasCapturedSource.current = true;
-		},
-	};
-};
-
-/**
- * Syncs child measurements when parent updates.
- */
-const useParentSyncReaction = (params: {
-	parentContext: RegisterBoundsContextValue | null;
-	maybeMeasureAndStore: (options?: MaybeMeasureAndStoreParams) => void;
-}) => {
-	const { parentContext, maybeMeasureAndStore } = params;
-
-	useAnimatedReaction(
-		() => parentContext?.updateSignal.get(),
-		(value) => {
-			"worklet";
-			if (value === 0 || value === undefined) return;
-			maybeMeasureAndStore();
-		},
-	);
-};
-
-let useRegisterBoundsContext: () => RegisterBoundsContextValue | null;
-
-const registerBoundsBundle = createProvider("RegisterBounds", {
-	guarded: false,
-})<RegisterBoundsProviderProps, RegisterBoundsContextValue>(
-	({ style, onPress, sharedBoundTag, animatedRef, children }) => {
-		const { current, next } = useDescriptors();
-		const { ancestorKeys, previousScreenKey } = useDescriptorDerivations();
-		const currentScreenKey = current.route.key;
-		const selectedNextRouteId = getRouteParamId(next?.route);
-
-		// Context & signals
-		const parentContext = useRegisterBoundsContext();
-
-		const ownSignal = useSharedValue(0);
-		const updateSignal: SharedValue<number> =
-			parentContext?.updateSignal ?? ownSignal;
-
-		const isAnimating = AnimationStore.getValue(
-			currentScreenKey,
-			"progressAnimating",
-		);
-		const preparedStyles = useMemo(() => prepareStyleForBounds(style), [style]);
-
-		const emitUpdate = useStableCallbackValue(() => {
-			"worklet";
-			const isRoot = !parentContext;
-			if (isRoot) updateSignal.set(updateSignal.get() + 1);
-		});
-
-		const maybeMeasureAndStore = useStableCallbackValue(
-			({
-				onPress,
-				shouldSetSource,
-				shouldSetDestination,
-			}: MaybeMeasureAndStoreParams = {}) => {
-				"worklet";
-				if (!sharedBoundTag) {
-					if (onPress) runOnJS(onPress)();
-					return;
-				}
-
-				const sourcePairKey = createPendingPairKey(currentScreenKey);
-				const destinationPairKey = previousScreenKey
-					? createScreenPairKey(previousScreenKey, currentScreenKey)
-					: undefined;
-				const pendingSourcePairKey = previousScreenKey
-					? createPendingPairKey(previousScreenKey)
-					: undefined;
-
-				if (shouldSetSource && isAnimating.get()) {
-					const existing = getEntry(sharedBoundTag, currentScreenKey);
-					if (existing?.bounds) {
-						applyMeasuredBoundsWrites({
-							entryTag: sharedBoundTag,
-							linkId: sharedBoundTag,
-							currentScreenKey,
-							measured: existing.bounds,
-							preparedStyles,
-							linkWrite: {
-								type: "source",
-								pairKey: sourcePairKey,
-							},
-						});
-					}
-
-					if (onPress) runOnJS(onPress)();
-					return;
-				}
-
-				const hasPendingSource = pendingSourcePairKey
-					? getSource(pendingSourcePairKey, sharedBoundTag) !== null
-					: false;
-				const hasSource =
-					getSource(sourcePairKey, sharedBoundTag) !== null ||
-					(destinationPairKey
-						? getSource(destinationPairKey, sharedBoundTag) !== null
-						: false);
-				const hasDestination = destinationPairKey
-					? getDestination(destinationPairKey, sharedBoundTag) !== null
-					: false;
-
-				const wantsSetSource = !!shouldSetSource;
-				const wantsSetDestination = !!shouldSetDestination;
-				const wantsSnapshotOnly = !wantsSetSource && !wantsSetDestination;
-
-				const canSetSource = wantsSetSource;
-				const canSetDestination =
-					wantsSetDestination && (hasPendingSource || hasSource);
-				const canSnapshotOnly =
-					wantsSnapshotOnly &&
-					(hasPendingSource || hasSource || hasDestination);
-
-				if (!canSetSource && !canSetDestination && !canSnapshotOnly) {
-					if (onPress) runOnJS(onPress)();
-					return;
-				}
-
-				const measured = measure(animatedRef);
-				if (!measured) {
-					if (onPress) runOnJS(onPress)();
-					return;
-				}
-
-				emitUpdate();
-
-				applyMeasuredBoundsWrites({
-					entryTag: sharedBoundTag,
-					linkId: sharedBoundTag,
-					currentScreenKey,
-					measured,
-					preparedStyles,
-					linkWrite: canSetSource
-						? {
-								type: "source",
-								pairKey: sourcePairKey,
-							}
-						: canSetDestination && destinationPairKey
-							? {
-									type: "destination",
-									pairKey: destinationPairKey,
-								}
-							: undefined,
-				});
-
-				if (canSetSource && canSetDestination && destinationPairKey) {
-					applyMeasuredBoundsWrites({
-						entryTag: sharedBoundTag,
-						linkId: sharedBoundTag,
-						currentScreenKey,
-						measured,
-						preparedStyles,
-						linkWrite: {
-							type: "destination",
-							pairKey: destinationPairKey,
-						},
-					});
-				}
-
-				if (onPress) runOnJS(onPress)();
-			},
-		);
-
-		const handleInitialLayout = useInitialLayoutHandler({
-			sharedBoundTag,
-			currentScreenKey,
-			ancestorKeys,
-			maybeMeasureAndStore,
-		});
-
-		// Side effects
-		const { markSourceCaptured } = useBlurMeasurement({
-			enabled: !onPress,
-			sharedBoundTag,
-			selectedRouteId: selectedNextRouteId,
-			maybeMeasureAndStore,
-			ancestorKeys,
-		});
-
-		useParentSyncReaction({ parentContext, maybeMeasureAndStore });
-
-		const captureActiveOnPress = useStableCallback(() => {
-			if (!sharedBoundTag) {
-				onPress?.();
-				return;
-			}
-			runOnUI(maybeMeasureAndStore)({ onPress, shouldSetSource: true });
-			markSourceCaptured();
-		});
-
-		return {
-			value: { updateSignal },
-			children: <>{children({ handleInitialLayout, captureActiveOnPress })}</>,
-		};
-	},
-);
-
-/**
- * Legacy bounds registration provider used by transition-aware components.
- *
- * @deprecated Prefer the newer bounds system (`Transition.Boundary`, `bounds()`,
- * and navigation-style bounds helpers) for new code. This provider remains only
- * for backwards compatibility with the older shared-bound-tag registration path.
- */
-const RegisterBoundsProvider = registerBoundsBundle.RegisterBoundsProvider;
-useRegisterBoundsContext = registerBoundsBundle.useRegisterBoundsContext;
-
-export { RegisterBoundsProvider };

package/src/shared/providers/screen/gestures/pan/behavior/pan-lifecycle.ts

@@ -1,175 +0,0 @@
-import { clamp, runOnJS, type SharedValue } from "react-native-reanimated";
-import { EPSILON, FALSE, TRUE } from "../../../../../constants";
-import { animateToProgress } from "../../../../../utils/animation/animate-to-progress";
-import { emit } from "../../../../../utils/animation/emit";
-import {
-	normalizeGestureTranslation,
-	resolveGestureVelocity,
-} from "../../shared/physics";
-import { snapshotGestureHandoff } from "../../shared/snapshot";
-import {
-	clearFocalPoint,
-	clearPanTrackingValues,
-	clearTransformTrackingValues,
-} from "../../shared/values";
-import type {
-	GestureCompositionOwner,
-	GestureDimensions,
-	PanGestureEvent,
-	PanGestureRuntime,
-	PanReleaseResult,
-	PanTrackState,
-} from "../../types";
-import { buildPanReleasePlan } from "./pan-release";
-import { resetPanGestureValues } from "./pan-reset";
-
-export const startPanBase = (runtime: PanGestureRuntime) => {
-	"worklet";
-	const {
-		stores: { gestures, animations },
-	} = runtime;
-
-	const wasSettling = gestures.settling.get();
-	const hasResidualGesture =
-		Math.abs(gestures.normX.get()) > EPSILON ||
-		Math.abs(gestures.normY.get()) > EPSILON ||
-		Math.abs(gestures.normScale.get()) > EPSILON ||
-		Math.abs(gestures.rotation.get()) > EPSILON;
-
-	if (!wasSettling || !hasResidualGesture) {
-		emit(animations.willAnimate, TRUE, FALSE);
-	}
-
-	gestures.dragging.set(TRUE);
-	gestures.dismissing.set(0);
-	gestures.settling.set(0);
-	clearPanTrackingValues(gestures);
-	clearTransformTrackingValues(gestures);
-	clearFocalPoint(gestures);
-	gestures.internal.progressBaseline.set(animations.transitionProgress.get());
-};
-
-export const trackPanGesture = (
-	event: PanGestureEvent,
-	rawEvent: PanGestureEvent,
-	gestures: PanGestureRuntime["stores"]["gestures"],
-	dimensions: GestureDimensions,
-): PanTrackState => {
-	"worklet";
-	const { translationX: x, translationY: y } = event;
-	const {
-		translationX: rawX,
-		translationY: rawY,
-		velocityX,
-		velocityY,
-	} = rawEvent;
-	const { width, height } = dimensions;
-
-	const normX = clamp(normalizeGestureTranslation(x, width), -1, 1);
-	const normY = clamp(normalizeGestureTranslation(y, height), -1, 1);
-	const rawNormX = clamp(normalizeGestureTranslation(rawX, width), -1, 1);
-	const rawNormY = clamp(normalizeGestureTranslation(rawY, height), -1, 1);
-	const velocity = resolveGestureVelocity(
-		velocityX / Math.max(1, width),
-		velocityY / Math.max(1, height),
-	);
-
-	gestures.x.set(x);
-	gestures.y.set(y);
-	gestures.normX.set(normX);
-	gestures.normY.set(normY);
-	gestures.internal.progressDeltaX.set(normX);
-	gestures.internal.progressDeltaY.set(normY);
-	gestures.velocity.set(velocity);
-	gestures.raw.x.set(rawX);
-	gestures.raw.y.set(rawY);
-	gestures.raw.normX.set(rawNormX);
-	gestures.raw.normY.set(rawNormY);
-
-	return {
-		x,
-		y,
-		normX,
-		normY,
-		velocity,
-	};
-};
-
-export const finalizePanRelease = (
-	release: PanReleaseResult,
-	runtime: PanGestureRuntime,
-	dismissScreen: ((finished: boolean) => void) | undefined,
-	dimensions: GestureDimensions,
-	rawEvent: PanGestureEvent,
-	requestDismiss?: () => void,
-	gestureCompositionOwner?: SharedValue<GestureCompositionOwner>,
-) => {
-	"worklet";
-	const {
-		policy,
-		stores: { gestures, animations, system },
-	} = runtime;
-
-	const canDriveRelease =
-		!gestureCompositionOwner || gestureCompositionOwner.get() === "pan";
-
-	const plan = buildPanReleasePlan(
-		canDriveRelease
-			? release
-			: {
-					target: animations.transitionProgress.get(),
-					shouldDismiss: false,
-					initialVelocity: 0,
-					transitionSpec: undefined,
-					resetSpec: policy.transitionSpec?.open,
-				},
-		runtime,
-		dimensions,
-		rawEvent,
-	);
-
-	if (typeof plan.commitProgress === "number") {
-		animations.transitionProgress.set(plan.commitProgress);
-		system.targetProgress.set(plan.commitProgress);
-	}
-
-	if (canDriveRelease && plan.shouldDismiss) {
-		snapshotGestureHandoff(gestures, {
-			velocity: plan.handoffVelocity,
-		});
-	}
-
-	resetPanGestureValues({
-		plan,
-		gestures,
-		updateLifecycle: canDriveRelease,
-	});
-
-	if (!canDriveRelease) {
-		return;
-	}
-
-	const progressAlreadyAtTarget =
-		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
-
-	if (!plan.shouldDismiss && progressAlreadyAtTarget) {
-		system.targetProgress.set(plan.target);
-		animations.progressAnimating.set(FALSE);
-		return;
-	}
-
-	if (plan.shouldDismiss && requestDismiss) {
-		runOnJS(requestDismiss)();
-	}
-
-	animateToProgress({
-		target: plan.target,
-		onAnimationFinish: plan.shouldDismiss ? dismissScreen : undefined,
-		spec: plan.transitionSpec,
-		emitWillAnimate: false,
-		markEntering: false,
-		targetProgress: system.targetProgress,
-		animations,
-		initialVelocity: plan.progressVelocity,
-	});
-};

package/src/shared/providers/screen/gestures/pinch/behavior/pinch-lifecycle.ts

@@ -1,112 +0,0 @@
-import { clamp, runOnJS } from "react-native-reanimated";
-import { EPSILON, FALSE, TRUE } from "../../../../../constants";
-import { animateToProgress } from "../../../../../utils/animation/animate-to-progress";
-import { emit } from "../../../../../utils/animation/emit";
-import { normalizePinchScale } from "../../shared/physics";
-import { snapshotGestureHandoff } from "../../shared/snapshot";
-import { clearTransformTrackingValues } from "../../shared/values";
-import type {
-	PinchGestureEvent,
-	PinchGestureRuntime,
-	PinchReleaseResult,
-	PinchTrackState,
-} from "../../types";
-import { resetPinchGestureValues } from "./pinch-reset";
-
-export const startPinchBase = (runtime: PinchGestureRuntime) => {
-	"worklet";
-	const {
-		stores: { gestures, animations },
-	} = runtime;
-
-	const wasSettling = gestures.settling.get();
-	const hasResidualGesture =
-		Math.abs(gestures.normScale.get()) > EPSILON ||
-		Math.abs(gestures.rotation.get()) > EPSILON;
-
-	if (!wasSettling || !hasResidualGesture) {
-		emit(animations.willAnimate, TRUE, FALSE);
-	}
-
-	gestures.dragging.set(TRUE);
-	gestures.dismissing.set(0);
-	gestures.settling.set(0);
-	gestures.active.set(null);
-	gestures.direction.set(null);
-	gestures.velocity.set(0);
-	clearTransformTrackingValues(gestures);
-	gestures.internal.progressBaseline.set(animations.transitionProgress.get());
-};
-
-export const trackPinchGesture = (
-	event: PinchGestureEvent,
-	rawEvent: PinchGestureEvent,
-	gestures: PinchGestureRuntime["stores"]["gestures"],
-): PinchTrackState => {
-	"worklet";
-	const normScale = clamp(normalizePinchScale(event.scale), -1, 1);
-	const scale = clamp(1 + normScale, 0, 2);
-	const rawNormScale = clamp(normalizePinchScale(rawEvent.scale), -1, 1);
-	const rawScale = clamp(1 + rawNormScale, 0, 2);
-
-	gestures.scale.set(scale);
-	gestures.normScale.set(normScale);
-	gestures.raw.scale.set(rawScale);
-	gestures.raw.normScale.set(rawNormScale);
-
-	if (gestures.active.get() === null) {
-		gestures.active.set(
-			normScale < 0 ? "pinch-in" : normScale > 0 ? "pinch-out" : null,
-		);
-	}
-
-	return {
-		scale,
-		normScale,
-	};
-};
-
-export const finalizePinchRelease = (
-	release: PinchReleaseResult,
-	runtime: PinchGestureRuntime,
-	dismissScreen: ((finished: boolean) => void) | undefined,
-	requestDismiss?: () => void,
-) => {
-	"worklet";
-	const {
-		stores: { gestures, animations, system },
-	} = runtime;
-
-	if (typeof release.commitProgress === "number") {
-		animations.transitionProgress.set(release.commitProgress);
-		system.targetProgress.set(release.commitProgress);
-	}
-
-	if (release.shouldDismiss) {
-		snapshotGestureHandoff(gestures, {
-			velocity: release.handoffVelocity,
-		});
-	}
-
-	resetPinchGestureValues({
-		spec: release.resetSpec,
-		gestures,
-		shouldDismiss: release.shouldDismiss,
-		resetValuesImmediately: release.resetValuesImmediately,
-	});
-
-	if (release.shouldDismiss && requestDismiss) {
-		runOnJS(requestDismiss)();
-	}
-
-	animateToProgress({
-		target: release.target,
-		onAnimationFinish: release.shouldDismiss ? dismissScreen : undefined,
-		spec: release.transitionSpec,
-		emitWillAnimate: false,
-		markEntering: false,
-		animations,
-		targetProgress: system.targetProgress,
-		initialVelocity: release.initialVelocity,
-	});
-};