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

package/src/shared/providers/screen/gestures/pinch/pinch-reset.ts

@@ -0,0 +1,65 @@
+import { EPSILON, FALSE, TRUE } from "../../../../constants";
+import type { GestureStoreMap } from "../../../../stores/gesture.store";
+import type { AnimationConfig } from "../../../../types/animation.types";
+import {
+	animateResetValue,
+	clearGestureSettlingIfResting,
+	getGestureResetSpec,
+} from "../shared/reset";
+
+interface ResetPinchGestureValuesProps {
+	spec?: AnimationConfig;
+	gestures: GestureStoreMap;
+	shouldDismiss: boolean;
+	resetValuesImmediately?: boolean;
+}
+
+const clearPinchSettlingIfResting = (gestures: GestureStoreMap) => {
+	"worklet";
+
+	const isResting =
+		!gestures.dragging.get() &&
+		!gestures.dismissing.get() &&
+		Math.abs(gestures.scale.get() - 1) <= EPSILON &&
+		Math.abs(gestures.normScale.get()) <= EPSILON;
+
+	if (isResting) {
+		gestures.focalX.set(0);
+		gestures.focalY.set(0);
+	}
+
+	clearGestureSettlingIfResting(gestures, isResting);
+};
+
+export const resetPinchGestureValues = ({
+	spec,
+	gestures,
+	shouldDismiss,
+	resetValuesImmediately = false,
+}: ResetPinchGestureValuesProps) => {
+	"worklet";
+	const resetSpec = getGestureResetSpec(spec);
+
+	if (!shouldDismiss) {
+		gestures.raw.scale.set(1);
+		gestures.raw.normScale.set(0);
+	}
+
+	gestures.dragging.set(FALSE);
+	gestures.dismissing.set(shouldDismiss ? TRUE : FALSE);
+	gestures.settling.set(shouldDismiss ? FALSE : TRUE);
+
+	if (resetValuesImmediately) {
+		gestures.scale.set(1);
+		gestures.normScale.set(0);
+		clearPinchSettlingIfResting(gestures);
+		return;
+	}
+
+	animateResetValue(gestures.scale, 1, resetSpec, () =>
+		clearPinchSettlingIfResting(gestures),
+	);
+	animateResetValue(gestures.normScale, 0, resetSpec, () =>
+		clearPinchSettlingIfResting(gestures),
+	);
+};

package/src/shared/providers/screen/gestures/{behaviors → pinch}/use-pinch-behavior.ts

@@ -2,30 +2,23 @@ import { useCallback } from "react";
 import type { SharedValue } from "react-native-reanimated";
 import { useNavigationHelpers } from "../../../../hooks/navigation/use-navigation-helpers";
 import type { ScreenOptionsContextValue } from "../../options";
-import {
-	finalizePinchRelease,
-	startPinchBase,
-	trackPinchGesture,
-} from "../helpers/pinch-phases";
-import { resolvePinchRuntime } from "../helpers/runtime-options";
 import { usePinchGestureSensitivity } from "../hooks/use-gesture-sensitivity";
+import { resolvePinchRuntime } from "../shared/runtime";
 import type {
 	PinchBehavior,
-	PinchBehaviorStrategy,
 	PinchGestureEvent,
 	PinchGestureRuntime,
 } from "../types";
-import { PinchStrategy } from "./strategies/pinch.strategy";
-import { SnapPinchStrategy } from "./strategies/pinch-snap.strategy";
-
-const getPinchStrategy = (
-	runtime: PinchGestureRuntime,
-): PinchBehaviorStrategy => {
-	"worklet";
-	return runtime.participation.effectiveSnapPoints.hasSnapPoints
-		? SnapPinchStrategy
-		: PinchStrategy;
-};
+import {
+	finalizePinchRelease,
+	startPinchBase,
+	trackPinchGesture,
+} from "./pinch-lifecycle";
+import {
+	primeSnapPinchRelease,
+	resolvePinchRelease,
+	resolveSnapPinchRelease,
+} from "./pinch-release";
 
 export const usePinchBehavior = (
 	runtime: SharedValue<PinchGestureRuntime>,
@@ -42,8 +35,9 @@ export const usePinchBehavior = (
 				runtime.get(),
 				screenOptions.get(),
 			);
-			const strategy = getPinchStrategy(latestRuntime);
-			strategy.primeStart(latestRuntime);
+			if (latestRuntime.participation.effectiveSnapPoints.hasSnapPoints) {
+				primeSnapPinchRelease(latestRuntime);
+			}
 			startPinchBase(latestRuntime, event);
 			resetSensitivity();
 		},
@@ -57,21 +51,8 @@ export const usePinchBehavior = (
 				runtime.get(),
 				screenOptions.get(),
 			);
-			const strategy = getPinchStrategy(latestRuntime);
 			const event = withSensitivity(rawEvent);
-			const track = trackPinchGesture(
-				event,
-				rawEvent,
-				latestRuntime.stores.gestures,
-			);
-
-			if (!latestRuntime.policy.gestureDrivesProgress) {
-				return;
-			}
-
-			latestRuntime.stores.animations.progress.set(
-				strategy.resolveProgress(latestRuntime, track),
-			);
+			trackPinchGesture(event, rawEvent, latestRuntime.stores.gestures);
 		},
 		[runtime, screenOptions, withSensitivity],
 	);
@@ -83,9 +64,11 @@ export const usePinchBehavior = (
 				runtime.get(),
 				screenOptions.get(),
 			);
-			const strategy = getPinchStrategy(latestRuntime);
 			const event = withSensitivity(rawEvent);
-			const release = strategy.resolveRelease(event, latestRuntime);
+			const release = latestRuntime.participation.effectiveSnapPoints
+				.hasSnapPoints
+				? resolveSnapPinchRelease(event, latestRuntime)
+				: resolvePinchRelease(event, latestRuntime);
 			finalizePinchRelease(release, latestRuntime, dismissScreen);
 		},
 		[runtime, screenOptions, dismissScreen, withSensitivity],

package/src/shared/providers/screen/gestures/{hooks/use-scroll-gesture-coordination → scroll-coordination}/update-scroll-gesture-state.ts

@@ -2,7 +2,7 @@ import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
 	ScrollGestureState,
-} from "../../types";
+} from "../types";
 
 const createScrollGestureState = (): ScrollGestureState => {
 	"worklet";

package/src/shared/providers/screen/gestures/{hooks/use-scroll-gesture-coordination → scroll-coordination}/use-scroll-gesture-coordination.ts

@@ -6,15 +6,15 @@ import {
 	useAnimatedScrollHandler,
 	useDerivedValue,
 } from "react-native-reanimated";
-import { useSharedValueState } from "../../../../../hooks/reanimated/use-shared-value-state";
-import useStableCallback from "../../../../../hooks/use-stable-callback";
-import { AnimationStore } from "../../../../../stores/animation.store";
-import { useGestureContext } from "../../gestures.provider";
+import { useSharedValueState } from "../../../../hooks/reanimated/use-shared-value-state";
+import useStableCallback from "../../../../hooks/use-stable-callback";
+import { AnimationStore } from "../../../../stores/animation.store";
+import { useGestureContext } from "../gestures.provider";
 import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
 	ScrollGestureState,
-} from "../../types";
+} from "../types";
 import { updateScrollGestureAxisState } from "./update-scroll-gesture-state";
 import { walkUpScrollGestureCoordination } from "./walk-up-scroll-gesture-coordination";
 

package/src/shared/providers/screen/gestures/{hooks/use-scroll-gesture-coordination → scroll-coordination}/walk-up-scroll-gesture-coordination.ts

@@ -1,13 +1,13 @@
 import type { SharedValue } from "react-native-reanimated";
-import type { Direction } from "../../../../../types/ownership.types";
-import { walkGestureAncestors } from "../../helpers/walk-gesture-ancestors";
+import type { Direction } from "../../../../types/ownership.types";
+import { walkGestureAncestors } from "../shared/ancestors";
 import type {
 	GestureContextType,
 	PanGesture,
 	PinchGesture,
 	ScrollGestureAxis,
 	ScrollGestureState,
-} from "../../types";
+} from "../types";
 
 /** Walks up the gesture tree until it finds the owner for a specific direction. */
 function findGestureOwnerForDirection(
@@ -21,28 +21,15 @@ function findGestureOwnerForDirection(
 	return null;
 }
 
-interface WalkUpScrollGestureCoordinationResult {
-	panGestures: PanGesture[];
-	pinchGestures: PinchGesture[];
-	scrollStates: SharedValue<ScrollGestureState | null>[];
-	ownerRouteKeys: string[];
-}
-
-export function walkUpScrollGestureCoordination(
-	context: GestureContextType | null,
+const getDirectionsForAxis = (
 	axis: ScrollGestureAxis,
-): WalkUpScrollGestureCoordinationResult {
-	const directions: readonly [Direction, Direction] =
-		axis === "vertical"
-			? ["vertical", "vertical-inverted"]
-			: ["horizontal", "horizontal-inverted"];
+): readonly [Direction, Direction] =>
+	axis === "vertical"
+		? ["vertical", "vertical-inverted"]
+		: ["horizontal", "horizontal-inverted"];
 
-	const seenOwners: GestureContextType[] = [];
-	const panGestures: GestureContextType["panGesture"][] = [];
+const collectAncestorPinchGestures = (ancestors: GestureContextType[]) => {
 	const pinchGestures: GestureContextType["pinchGesture"][] = [];
-	const scrollStates: GestureContextType["scrollState"][] = [];
-	const ownerRouteKeys: string[] = [];
-	const ancestors = walkGestureAncestors(context);
 
 	for (const ancestor of ancestors) {
 		if (!pinchGestures.includes(ancestor.pinchGesture)) {
@@ -50,6 +37,18 @@ export function walkUpScrollGestureCoordination(
 		}
 	}
 
+	return pinchGestures;
+};
+
+const collectAxisOwners = (
+	ancestors: GestureContextType[],
+	directions: readonly [Direction, Direction],
+) => {
+	const seenOwners: GestureContextType[] = [];
+	const panGestures: GestureContextType["panGesture"][] = [];
+	const scrollStates: GestureContextType["scrollState"][] = [];
+	const ownerRouteKeys: string[] = [];
+
 	for (const direction of directions) {
 		const owner = findGestureOwnerForDirection(ancestors, direction);
 
@@ -63,10 +62,27 @@ export function walkUpScrollGestureCoordination(
 		ownerRouteKeys.push(owner.routeKey);
 	}
 
+	return { panGestures, scrollStates, ownerRouteKeys };
+};
+
+interface WalkUpScrollGestureCoordinationResult {
+	panGestures: PanGesture[];
+	pinchGestures: PinchGesture[];
+	scrollStates: SharedValue<ScrollGestureState | null>[];
+	ownerRouteKeys: string[];
+}
+
+export function walkUpScrollGestureCoordination(
+	context: GestureContextType | null,
+	axis: ScrollGestureAxis,
+): WalkUpScrollGestureCoordinationResult {
+	const ancestors = walkGestureAncestors(context);
+	const axisOwners = collectAxisOwners(ancestors, getDirectionsForAxis(axis));
+
 	return {
-		panGestures,
-		pinchGestures,
-		scrollStates,
-		ownerRouteKeys,
+		panGestures: axisOwners.panGestures,
+		pinchGestures: collectAncestorPinchGestures(ancestors),
+		scrollStates: axisOwners.scrollStates,
+		ownerRouteKeys: axisOwners.ownerRouteKeys,
 	};
 }

package/src/shared/providers/screen/gestures/{helpers/gesture-physics.ts → shared/physics.ts}

@@ -11,7 +11,6 @@ interface CalculateProgressProps {
 	dimensions: { width: number; height: number };
 	directions: GestureDirections;
 	gestureReleaseVelocityScale?: number;
-	gestureReleaseVelocityMax?: number;
 }
 
 type GestureAxisCandidate = {
@@ -30,17 +29,6 @@ export const toProgressVelocity = (
 	return velocityPixelsPerSecond / Math.max(1, screenSize);
 };
 
-export const clampReleaseVelocity = (
-	velocity: number,
-	maxMagnitude?: number,
-) => {
-	"worklet";
-	if (maxMagnitude === undefined) return velocity;
-
-	const max = Math.max(0, Math.abs(maxMagnitude));
-	return clamp(velocity, -max, max);
-};
-
 /**
  * Converts pan release velocity into a spring handoff in progress units/second.
  */
@@ -48,14 +36,12 @@ export const getPanReleaseHandoffVelocity = (
 	velocityPixelsPerSecond: number,
 	screenSize: number,
 	gestureReleaseVelocityScale: number = 1,
-	gestureReleaseVelocityMax?: number,
 ) => {
 	"worklet";
-	const velocity =
+	return (
 		toProgressVelocity(velocityPixelsPerSecond, screenSize) *
-		Math.max(0, gestureReleaseVelocityScale);
-
-	return clampReleaseVelocity(velocity, gestureReleaseVelocityMax);
+		Math.max(0, gestureReleaseVelocityScale)
+	);
 };
 
 /**
@@ -64,12 +50,139 @@ export const getPanReleaseHandoffVelocity = (
 export const getPinchReleaseHandoffVelocity = (
 	velocityScalePerSecond: number,
 	gestureReleaseVelocityScale: number = 1,
-	gestureReleaseVelocityMax?: number,
 ) => {
 	"worklet";
-	const velocity =
-		velocityScalePerSecond * Math.max(0, gestureReleaseVelocityScale);
-	return clampReleaseVelocity(velocity, gestureReleaseVelocityMax);
+	return velocityScalePerSecond * Math.max(0, gestureReleaseVelocityScale);
+};
+
+const getPanAxisCandidate = (
+	isEnabled: boolean,
+	translationTowardDismiss: number,
+	velocityTowardDismiss: number,
+	screenSize: number,
+	gestureReleaseVelocityScale?: number,
+): GestureAxisCandidate | null => {
+	"worklet";
+	if (!isEnabled || translationTowardDismiss <= 0) {
+		return null;
+	}
+
+	return {
+		progressContribution: translationTowardDismiss / Math.max(1, screenSize),
+		velocityContribution: getPanReleaseHandoffVelocity(
+			velocityTowardDismiss,
+			screenSize,
+			gestureReleaseVelocityScale,
+		),
+	};
+};
+
+const pushPanAxisCandidate = (
+	candidates: GestureAxisCandidate[],
+	candidate: GestureAxisCandidate | null,
+) => {
+	"worklet";
+	if (candidate) {
+		candidates.push(candidate);
+	}
+};
+
+const collectPanAxisCandidates = ({
+	event,
+	dimensions,
+	directions,
+	gestureReleaseVelocityScale,
+}: Pick<
+	CalculateProgressProps,
+	"event" | "dimensions" | "directions" | "gestureReleaseVelocityScale"
+>) => {
+	"worklet";
+	const candidates: GestureAxisCandidate[] = [];
+
+	pushPanAxisCandidate(
+		candidates,
+		getPanAxisCandidate(
+			directions.horizontal,
+			event.translationX,
+			event.velocityX,
+			dimensions.width,
+			gestureReleaseVelocityScale,
+		),
+	);
+	pushPanAxisCandidate(
+		candidates,
+		getPanAxisCandidate(
+			directions.horizontalInverted,
+			-event.translationX,
+			-event.velocityX,
+			dimensions.width,
+			gestureReleaseVelocityScale,
+		),
+	);
+	pushPanAxisCandidate(
+		candidates,
+		getPanAxisCandidate(
+			directions.vertical,
+			event.translationY,
+			event.velocityY,
+			dimensions.height,
+			gestureReleaseVelocityScale,
+		),
+	);
+	pushPanAxisCandidate(
+		candidates,
+		getPanAxisCandidate(
+			directions.verticalInverted,
+			-event.translationY,
+			-event.velocityY,
+			dimensions.height,
+			gestureReleaseVelocityScale,
+		),
+	);
+
+	return candidates;
+};
+
+const getDominantPanCandidateVelocity = (
+	candidates: GestureAxisCandidate[],
+): number | null => {
+	"worklet";
+	if (candidates.length === 0) {
+		return null;
+	}
+
+	let dominant = candidates[0];
+	for (let i = 1; i < candidates.length; i++) {
+		const candidate = candidates[i];
+		if (candidate.progressContribution > dominant.progressContribution) {
+			dominant = candidate;
+		}
+	}
+
+	return Math.abs(dominant.velocityContribution);
+};
+
+const getFallbackPanReleaseVelocityMagnitude = ({
+	event,
+	dimensions,
+	gestureReleaseVelocityScale,
+}: Pick<
+	CalculateProgressProps,
+	"event" | "dimensions" | "gestureReleaseVelocityScale"
+>) => {
+	"worklet";
+	const normalizedVelocityX = getPanReleaseHandoffVelocity(
+		event.velocityX,
+		dimensions.width,
+		gestureReleaseVelocityScale,
+	);
+	const normalizedVelocityY = getPanReleaseHandoffVelocity(
+		event.velocityY,
+		dimensions.height,
+		gestureReleaseVelocityScale,
+	);
+
+	return Math.max(Math.abs(normalizedVelocityX), Math.abs(normalizedVelocityY));
 };
 
 /**
@@ -95,7 +208,6 @@ export const getPanReleaseProgressVelocity = ({
 	dimensions,
 	directions,
 	gestureReleaseVelocityScale,
-	gestureReleaseVelocityMax,
 }: CalculateProgressProps) => {
 	"worklet";
 
@@ -105,86 +217,21 @@ export const getPanReleaseProgressVelocity = ({
 
 	const progressDirection = progressDelta === 0 ? 0 : Math.sign(progressDelta);
 
-	const candidates: GestureAxisCandidate[] = [];
-
-	if (directions.horizontal && event.translationX > 0) {
-		candidates.push({
-			progressContribution: event.translationX / Math.max(1, dimensions.width),
-			velocityContribution: getPanReleaseHandoffVelocity(
-				event.velocityX,
-				dimensions.width,
-				gestureReleaseVelocityScale,
-				gestureReleaseVelocityMax,
-			),
-		});
-	}
-
-	if (directions.horizontalInverted && event.translationX < 0) {
-		candidates.push({
-			progressContribution: -event.translationX / Math.max(1, dimensions.width),
-			velocityContribution: getPanReleaseHandoffVelocity(
-				-event.velocityX,
-				dimensions.width,
-				gestureReleaseVelocityScale,
-				gestureReleaseVelocityMax,
-			),
-		});
-	}
-
-	if (directions.vertical && event.translationY > 0) {
-		candidates.push({
-			progressContribution: event.translationY / Math.max(1, dimensions.height),
-			velocityContribution: getPanReleaseHandoffVelocity(
-				event.velocityY,
-				dimensions.height,
-				gestureReleaseVelocityScale,
-				gestureReleaseVelocityMax,
-			),
-		});
-	}
-
-	if (directions.verticalInverted && event.translationY < 0) {
-		candidates.push({
-			progressContribution:
-				-event.translationY / Math.max(1, dimensions.height),
-			velocityContribution: getPanReleaseHandoffVelocity(
-				-event.velocityY,
-				dimensions.height,
-				gestureReleaseVelocityScale,
-				gestureReleaseVelocityMax,
-			),
-		});
-	}
-
-	let progressVelocityMagnitude = 0;
-
-	if (candidates.length > 0) {
-		let dominant = candidates[0];
-		for (let i = 1; i < candidates.length; i++) {
-			const candidate = candidates[i];
-			if (candidate.progressContribution > dominant.progressContribution) {
-				dominant = candidate;
-			}
-		}
-		progressVelocityMagnitude = Math.abs(dominant.velocityContribution);
-	} else {
-		const normalizedVelocityX = getPanReleaseHandoffVelocity(
-			event.velocityX,
-			dimensions.width,
+	const dominantVelocity = getDominantPanCandidateVelocity(
+		collectPanAxisCandidates({
+			event,
+			dimensions,
+			directions,
 			gestureReleaseVelocityScale,
-			gestureReleaseVelocityMax,
-		);
-		const normalizedVelocityY = getPanReleaseHandoffVelocity(
-			event.velocityY,
-			dimensions.height,
+		}),
+	);
+	const progressVelocityMagnitude =
+		dominantVelocity ??
+		getFallbackPanReleaseVelocityMagnitude({
+			event,
+			dimensions,
 			gestureReleaseVelocityScale,
-			gestureReleaseVelocityMax,
-		);
-		progressVelocityMagnitude = Math.max(
-			Math.abs(normalizedVelocityX),
-			Math.abs(normalizedVelocityY),
-		);
-	}
+		});
 
 	return progressDirection * progressVelocityMagnitude;
 };
@@ -229,18 +276,6 @@ export const shouldDismissFromProjection = (
 	return exceedsThreshold;
 };
 
-/**
- * Utility function to map raw gesture translation to a progress value.
- */
-export const mapGestureToProgress = (
-	translation: number,
-	dimension: number,
-) => {
-	"worklet";
-	const rawProgress = translation / dimension;
-	return Math.max(0, Math.min(1, rawProgress));
-};
-
 /**
  * Scales live gesture movement before it is applied to transition progress.
  * Lower values reduce sensitivity, higher values increase it.