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

package/src/shared/providers/screen/descriptors/descriptors.provider.tsx

@@ -5,7 +5,6 @@ import createProvider from "../../../utils/create-provider";
 import type { DescriptorDerivations } from "./helpers/derive-descriptor-derivations";
 import { deriveDescriptorDerivations } from "./helpers/derive-descriptor-derivations";
 import { getAncestorKeys } from "./helpers/get-ancestor-keys";
-import { getAncestorNavigatorKeys } from "./helpers/get-ancestor-navigator-keys";
 
 /**
  * Base descriptor interface - minimal contract for all stack types.
@@ -58,10 +57,6 @@ const {
 	DescriptorDerivationsContextValue
 >(({ previous, current, next, children }) => {
 	const ancestorKeys = useMemo(() => getAncestorKeys(current), [current]);
-	const ancestorNavigatorKeys = useMemo(
-		() => getAncestorNavigatorKeys(current),
-		[current],
-	);
 
 	const value = useMemo(
 		() =>
@@ -70,9 +65,8 @@ const {
 				current,
 				next,
 				ancestorKeys,
-				ancestorNavigatorKeys,
 			}),
-		[previous, current, next, ancestorKeys, ancestorNavigatorKeys],
+		[previous, current, next, ancestorKeys],
 	);
 
 	return {

package/src/shared/providers/screen/descriptors/helpers/derive-descriptor-derivations.ts

@@ -8,11 +8,7 @@ export interface DescriptorDerivations {
 	isFirstKey: boolean;
 	isTopMostScreen: boolean;
 	ancestorKeys: string[];
-	navigatorKey: string;
-	ancestorNavigatorKeys: string[];
 	hasConfiguredInterpolator: boolean;
-	isBranchScreen: boolean;
-	branchNavigatorKey?: string;
 }
 
 interface Params {
@@ -20,7 +16,6 @@ interface Params {
 	current: BaseStackDescriptor;
 	next?: BaseStackDescriptor;
 	ancestorKeys: string[];
-	ancestorNavigatorKeys: string[];
 }
 
 export function deriveDescriptorDerivations({
@@ -28,14 +23,12 @@ export function deriveDescriptorDerivations({
 	current,
 	next,
 	ancestorKeys,
-	ancestorNavigatorKeys,
 }: Params): DescriptorDerivations {
 	const previousScreenKey = previous?.route.key;
 	const currentScreenKey = current.route.key;
 	const nextScreenKey = next?.route.key;
 
 	const navigationState = current.navigation.getState();
-	const navigatorKey = navigationState?.key ?? "";
 	const routes = navigationState?.routes ?? [];
 	const isFirstKey =
 		routes.findIndex((route) => route.key === current.route.key) === 0;
@@ -44,14 +37,6 @@ export function deriveDescriptorDerivations({
 		!!current.options.screenStyleInterpolator ||
 		!!next?.options?.screenStyleInterpolator;
 
-	const currentRoute = routes.find((route) => route.key === current.route.key);
-	const hasBranchState = !!currentRoute && "state" in currentRoute;
-	const nestedState = hasBranchState
-		? (currentRoute as { state?: { key?: unknown } }).state
-		: undefined;
-	const branchNavigatorKey =
-		typeof nestedState?.key === "string" ? nestedState.key : undefined;
-
 	return {
 		previousScreenKey,
 		currentScreenKey,
@@ -60,10 +45,6 @@ export function deriveDescriptorDerivations({
 		isFirstKey,
 		isTopMostScreen,
 		ancestorKeys,
-		navigatorKey,
-		ancestorNavigatorKeys,
 		hasConfiguredInterpolator,
-		isBranchScreen: hasBranchState,
-		branchNavigatorKey,
 	};
 }

package/src/shared/providers/screen/gestures/gestures.provider.tsx

@@ -4,14 +4,14 @@ import { useSharedValue } from "react-native-reanimated";
 import { ScrollStore } from "../../../stores/scroll.store";
 import createProvider from "../../../utils/create-provider";
 import { useDescriptorDerivations } from "../descriptors";
-import { useBuildPanGesture } from "./builders/use-build-pan-gesture";
-import { useBuildPinchGesture } from "./builders/use-build-pinch-gesture";
 import { useScreenGestureConfig } from "./hooks/use-screen-gesture-config";
 import { useWalkUpAndRegisterShadowingClaims } from "./ownership/use-walk-up-and-register-shadowing-claims";
+import { useBuildPanGesture } from "./pan/build-pan-gesture";
+import { useBuildPinchGesture } from "./pinch/build-pinch-gesture";
 import {
 	type DirectionClaimMap,
 	type GestureContextType,
-	NO_CLAIMS,
+	NO_DIRECTION_CLAIMS,
 } from "./types";
 
 interface ScreenGestureProviderProps {
@@ -33,7 +33,8 @@ export const {
 
 	// Ancestors read this before activating. If a nested screen claims the same
 	// direction, it writes here so the ancestor can fail and let it take priority.
-	const childDirectionClaims = useSharedValue<DirectionClaimMap>(NO_CLAIMS);
+	const childDirectionClaims =
+		useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
 
 	const panGesture = useBuildPanGesture({
 		scrollState,

package/src/shared/providers/screen/gestures/hooks/use-gesture-builder-state.ts

@@ -1,4 +1,3 @@
-import { useMemo } from "react";
 import { useSharedValue } from "react-native-reanimated";
 import type { ScreenGestureParticipation } from "../types";
 
@@ -7,12 +6,12 @@ import type { ScreenGestureParticipation } from "../types";
  * recognizer is active.
  *
  * `gestureProgressBaseline` is set to the current animation progress when a
- * gesture starts. Strategies use it as the stable baseline for cumulative
+ * gesture starts. Lifecycle handlers use it as the stable baseline for cumulative
  * pan/pinch deltas so progress can be recalculated from the gesture event
  * instead of repeatedly accumulating into the current animated value.
  *
  * `lockedSnapPoint` is the current snap point chosen when a snap gesture starts.
- * Snap strategies set it during `primeStart`: snap-locked gestures use the
+ * Snap release primers set it on start: snap-locked gestures use the
  * nearest resolved snap point, while unlocked snap gestures use the resolved max
  * snap point. The value stays stable through the active gesture and is used as a
  * progress bound/release target.
@@ -25,11 +24,8 @@ export const useGestureBuilderState = (
 		participation.effectiveSnapPoints.maxSnapPoint,
 	);
 
-	return useMemo(
-		() => ({
-			gestureProgressBaseline,
-			lockedSnapPoint,
-		}),
-		[gestureProgressBaseline, lockedSnapPoint],
-	);
+	return {
+		gestureProgressBaseline,
+		lockedSnapPoint,
+	};
 };

package/src/shared/providers/screen/gestures/hooks/use-gesture-sensitivity.ts

@@ -5,7 +5,7 @@ import type { ScreenOptionsContextValue } from "../../options";
 import {
 	applyGestureSensitivity,
 	normalizePinchScale,
-} from "../helpers/gesture-physics";
+} from "../shared/physics";
 import type { PanGestureEvent, PinchGestureEvent } from "../types";
 
 export interface GestureSensitivityRawChangeState {

package/src/shared/providers/screen/gestures/hooks/use-screen-gesture-config.ts

@@ -1,113 +1,8 @@
 import { useMemo } from "react";
-import {
-	DEFAULT_GESTURE_ACTIVATION_AREA,
-	DEFAULT_GESTURE_DIRECTION,
-	DEFAULT_GESTURE_DRIVES_PROGRESS,
-	DEFAULT_GESTURE_RELEASE_VELOCITY_MAX,
-	DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
-	DEFAULT_GESTURE_SENSITIVITY,
-	DEFAULT_GESTURE_SNAP_LOCKED,
-	DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
-	DEFAULT_GESTURE_VELOCITY_IMPACT,
-} from "../../../../constants";
-import type { ScreenTransitionConfig } from "../../../../types";
-import { resolveSheetScrollGestureBehavior } from "../../../../utils/resolve-screen-transition-options";
 import { useDescriptorDerivations, useDescriptors } from "../../descriptors";
 import { useGestureContext } from "../gestures.provider";
-import {
-	getPanActivationDirections,
-	getPanGestureDirections,
-	getPanSnapAxisDirections,
-	getPinchGestureDirections,
-	getSnapPinchDirectionConfig,
-} from "../helpers/gesture-directions";
-import { resolveCanTrackGesture } from "../helpers/resolve-can-track-gesture";
-import { validateSnapPoints } from "../helpers/validate-snap-points";
-import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
-import { resolveOwnership } from "../ownership/resolve-ownership";
-import type {
-	PanGesturePolicy,
-	PinchGesturePolicy,
-	ScreenGestureConfig,
-	ScreenGestureParticipation,
-} from "../types";
-
-function resolvePanPolicy(
-	options: ScreenTransitionConfig,
-	hasSnapPoints: boolean,
-): PanGesturePolicy {
-	const gestureDirection =
-		options.gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
-	const hasPanDirection = getPanGestureDirections(gestureDirection).length > 0;
-
-	return {
-		enabled: hasPanDirection,
-		gestureDirection,
-		panActivationDirections: getPanActivationDirections({
-			gestureDirection,
-			hasSnapPoints,
-		}),
-		snapAxisDirections: getPanSnapAxisDirections(gestureDirection),
-		gestureDrivesProgress:
-			options.gestureDrivesProgress ?? DEFAULT_GESTURE_DRIVES_PROGRESS,
-		gestureSensitivity:
-			options.gestureSensitivity ?? DEFAULT_GESTURE_SENSITIVITY,
-		gestureVelocityImpact:
-			options.gestureVelocityImpact ?? DEFAULT_GESTURE_VELOCITY_IMPACT,
-		gestureSnapVelocityImpact:
-			options.gestureSnapVelocityImpact ?? DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
-		gestureReleaseVelocityScale:
-			options.gestureReleaseVelocityScale ??
-			DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
-		gestureReleaseVelocityMax:
-			options.gestureReleaseVelocityMax ?? DEFAULT_GESTURE_RELEASE_VELOCITY_MAX,
-		gestureActivationArea:
-			options.gestureActivationArea ?? DEFAULT_GESTURE_ACTIVATION_AREA,
-		gestureSnapLocked: options.gestureSnapLocked ?? DEFAULT_GESTURE_SNAP_LOCKED,
-		sheetScrollGestureBehavior: resolveSheetScrollGestureBehavior(options),
-		gestureResponseDistance: options.gestureResponseDistance,
-		transitionSpec: options.transitionSpec,
-	};
-}
-
-function resolvePinchPolicy(
-	options: ScreenTransitionConfig,
-	hasSnapPoints: boolean,
-): PinchGesturePolicy {
-	const gestureDirection =
-		options.gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
-	const pinchDirections = getPinchGestureDirections(gestureDirection);
-	const snapDirections = hasSnapPoints
-		? getSnapPinchDirectionConfig(gestureDirection)
-		: null;
-	const pinchInEnabled = snapDirections
-		? true
-		: pinchDirections.includes("pinch-in");
-	const pinchOutEnabled = snapDirections
-		? true
-		: pinchDirections.includes("pinch-out");
-
-	return {
-		enabled: pinchInEnabled || pinchOutEnabled,
-		gestureDirection,
-		snapDirections,
-		pinchInEnabled,
-		pinchOutEnabled,
-		gestureDrivesProgress:
-			options.gestureDrivesProgress ?? DEFAULT_GESTURE_DRIVES_PROGRESS,
-		gestureSensitivity:
-			options.gestureSensitivity ?? DEFAULT_GESTURE_SENSITIVITY,
-		gestureSnapVelocityImpact:
-			options.gestureSnapVelocityImpact ?? DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
-		gestureSnapLocked: options.gestureSnapLocked ?? DEFAULT_GESTURE_SNAP_LOCKED,
-		gestureReleaseVelocityScale:
-			options.gestureReleaseVelocityScale ??
-			DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
-		gestureReleaseVelocityMax:
-			options.gestureReleaseVelocityMax ?? DEFAULT_GESTURE_RELEASE_VELOCITY_MAX,
-		transitionSpec: options.transitionSpec,
-	};
-}
+import { resolveScreenGestureConfig } from "../shared/policy";
+import type { ScreenGestureConfig } from "../types";
 
 export function useScreenGestureConfig(): ScreenGestureConfig {
 	const gestureContext = useGestureContext();
@@ -117,44 +12,13 @@ export function useScreenGestureConfig(): ScreenGestureConfig {
 
 	const { isFirstKey } = useDescriptorDerivations();
 
-	return useMemo(() => {
-		const canDismiss = Boolean(isFirstKey ? false : options.gestureEnabled);
-		// NOTE: The first screen still does not track gestures by default. Even if
-		// gesture-driven animations are broadly available, initial-route gesture
-		// animation should stay behind experimental_animateOnInitialMount until we
-		// have feedback on whether that behavior is useful.
-		const effectiveSnapPoints = validateSnapPoints({
-			snapPoints: options.snapPoints,
-			canDismiss,
-		});
-		const canTrackGesture = resolveCanTrackGesture({
-			isFirstKey,
-			canDismiss,
-			hasSnapPoints: effectiveSnapPoints.hasSnapPoints,
-			allowDisabledGestureTracking:
-				options.experimental_allowDisabledGestureTracking,
-		});
-		const canClaimDirections = canTrackGesture;
-
-		const claimedDirections = computeClaimedDirections(
-			canClaimDirections,
-			options.gestureDirection,
-			effectiveSnapPoints.hasSnapPoints,
-		);
-
-		const participation: ScreenGestureParticipation = {
-			isFirstKey,
-			canDismiss,
-			canTrackGesture,
-			effectiveSnapPoints,
-			claimedDirections,
-			ownershipStatus: resolveOwnership(claimedDirections, gestureContext),
-		};
-
-		return {
-			participation,
-			pan: resolvePanPolicy(options, effectiveSnapPoints.hasSnapPoints),
-			pinch: resolvePinchPolicy(options, effectiveSnapPoints.hasSnapPoints),
-		};
-	}, [isFirstKey, options, gestureContext]);
+	return useMemo(
+		() =>
+			resolveScreenGestureConfig({
+				options,
+				isFirstKey,
+				gestureContext,
+			}),
+		[isFirstKey, options, gestureContext],
+	);
 }

package/src/shared/providers/screen/gestures/hooks/use-screen-gesture.ts

@@ -3,7 +3,7 @@ import {
 	resolveChainTarget,
 } from "../../../../utils/resolve-chain-target";
 import { useGestureContext } from "../gestures.provider";
-import { walkGestureAncestors } from "../helpers/walk-gesture-ancestors";
+import { walkGestureAncestors } from "../shared/ancestors";
 
 export type ScreenGestureTarget = ChainTarget;
 
@@ -23,10 +23,6 @@ export type ScreenGestureTarget = ChainTarget;
 export const useScreenGesture = (target?: ScreenGestureTarget) => {
 	const ctx = useGestureContext();
 
-	if (!target || target === "self") {
-		return ctx?.panGesture ?? null;
-	}
-
 	return (
 		resolveChainTarget({
 			target,

package/src/shared/providers/screen/gestures/hooks/use-stable-runtime-config.ts

@@ -4,22 +4,16 @@ import { AnimationStore } from "../../../../stores/animation.store";
 import { GestureStore } from "../../../../stores/gesture.store";
 import { SystemStore } from "../../../../stores/system.store";
 import { useDescriptorDerivations } from "../../descriptors";
-import type { PanGestureRuntime, PinchGestureRuntime } from "../types";
+import type { GesturePolicy, GestureRuntime } from "../types";
 
-type StableRuntimeConfig = PanGestureRuntime | PinchGestureRuntime;
-type PanRuntimeConfigInput = Omit<PanGestureRuntime, "stores">;
-type PinchRuntimeConfigInput = Omit<PinchGestureRuntime, "stores">;
-type StableRuntimeConfigInput = PanRuntimeConfigInput | PinchRuntimeConfigInput;
+type RuntimeConfigInput<TPolicy extends GesturePolicy> = Omit<
+	GestureRuntime<TPolicy>,
+	"stores"
+>;
 
-export function useStableRuntimeConfig(
-	runtimeConfigInput: PanRuntimeConfigInput,
-): SharedValue<PanGestureRuntime>;
-export function useStableRuntimeConfig(
-	runtimeConfigInput: PinchRuntimeConfigInput,
-): SharedValue<PinchGestureRuntime>;
-export function useStableRuntimeConfig(
-	runtimeConfigInput: StableRuntimeConfigInput,
-): SharedValue<PanGestureRuntime> | SharedValue<PinchGestureRuntime> {
+export function useStableRuntimeConfig<TPolicy extends GesturePolicy>(
+	runtimeConfigInput: RuntimeConfigInput<TPolicy>,
+): SharedValue<GestureRuntime<TPolicy>> {
 	const { currentScreenKey } = useDescriptorDerivations();
 	const { participation, policy, gestureProgressBaseline, lockedSnapPoint } =
 		runtimeConfigInput;
@@ -32,14 +26,14 @@ export function useStableRuntimeConfig(
 		};
 	}, [currentScreenKey]);
 
-	const runtimeConfig = useMemo<StableRuntimeConfig>(() => {
+	const runtimeConfig = useMemo<GestureRuntime<TPolicy>>(() => {
 		return {
 			participation,
 			policy,
 			stores,
 			gestureProgressBaseline,
 			lockedSnapPoint,
-		} as StableRuntimeConfig;
+		};
 	}, [participation, policy, stores, gestureProgressBaseline, lockedSnapPoint]);
 	const stableRuntimeConfig = useSharedValue(runtimeConfig);
 
@@ -47,7 +41,5 @@ export function useStableRuntimeConfig(
 		stableRuntimeConfig.set(runtimeConfig);
 	}, [stableRuntimeConfig, runtimeConfig]);
 
-	return stableRuntimeConfig as
-		| SharedValue<PanGestureRuntime>
-		| SharedValue<PinchGestureRuntime>;
+	return stableRuntimeConfig;
 }

package/src/shared/providers/screen/gestures/ownership/compute-claimed-directions.ts

@@ -9,6 +9,54 @@ import {
 	NO_CLAIMS,
 } from "../../../../types/ownership.types";
 
+const createClaimSet = (): ClaimedDirections => ({
+	vertical: false,
+	"vertical-inverted": false,
+	horizontal: false,
+	"horizontal-inverted": false,
+});
+
+const normalizePanGestureDirections = (
+	gestureDirection: GestureDirection | GestureDirection[] | undefined,
+): PanGestureDirection[] => {
+	const direction = gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
+
+	return (Array.isArray(direction) ? direction : [direction]).filter(
+		(dir): dir is PanGestureDirection =>
+			dir !== "pinch-in" && dir !== "pinch-out",
+	);
+};
+
+const claimPanDirection = (
+	claims: ClaimedDirections,
+	direction: PanGestureDirection,
+) => {
+	if (direction === "bidirectional") {
+		claims.vertical = true;
+		claims["vertical-inverted"] = true;
+		claims.horizontal = true;
+		claims["horizontal-inverted"] = true;
+		return;
+	}
+
+	claims[direction as Direction] = true;
+};
+
+const expandSnapPointAxisClaims = (claims: ClaimedDirections) => {
+	const hasVerticalAxis = claims.vertical || claims["vertical-inverted"];
+	const hasHorizontalAxis = claims.horizontal || claims["horizontal-inverted"];
+
+	if (hasVerticalAxis) {
+		claims.vertical = true;
+		claims["vertical-inverted"] = true;
+	}
+
+	if (hasHorizontalAxis) {
+		claims.horizontal = true;
+		claims["horizontal-inverted"] = true;
+	}
+};
+
 /**
  * Computes which directions a screen claims ownership of.
  *
@@ -33,56 +81,20 @@ export function computeClaimedDirections(
 		return NO_CLAIMS;
 	}
 
-	const direction = gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
-
-	// Normalize to array
-	const directions: PanGestureDirection[] = (
-		Array.isArray(direction) ? direction : [direction]
-	).filter(
-		(dir): dir is PanGestureDirection =>
-			dir !== "pinch-in" && dir !== "pinch-out",
-	);
+	const directions = normalizePanGestureDirections(gestureDirection);
 
 	if (directions.length === 0) {
 		return NO_CLAIMS;
 	}
 
-	// Start with no claims
-	const claims: ClaimedDirections = {
-		vertical: false,
-		"vertical-inverted": false,
-		horizontal: false,
-		"horizontal-inverted": false,
-	};
+	const claims = createClaimSet();
 
-	// Process each direction
 	for (const dir of directions) {
-		if (dir === "bidirectional") {
-			// Bidirectional claims all four directions
-			claims.vertical = true;
-			claims["vertical-inverted"] = true;
-			claims.horizontal = true;
-			claims["horizontal-inverted"] = true;
-		} else {
-			// Claim the specific direction
-			claims[dir as Direction] = true;
-		}
+		claimPanDirection(claims, dir);
 	}
 
-	// Snap points own both directions on every configured pan axis.
 	if (hasSnapPoints) {
-		const hasVerticalAxis = claims.vertical || claims["vertical-inverted"];
-		const hasHorizontalAxis =
-			claims.horizontal || claims["horizontal-inverted"];
-
-		if (hasVerticalAxis) {
-			claims.vertical = true;
-			claims["vertical-inverted"] = true;
-		}
-		if (hasHorizontalAxis) {
-			claims.horizontal = true;
-			claims["horizontal-inverted"] = true;
-		}
+		expandSnapPointAxisClaims(claims);
 	}
 
 	return claims;

package/src/shared/providers/screen/gestures/ownership/resolve-ownership.ts

@@ -8,6 +8,7 @@ import {
 	NO_OWNERSHIP,
 	type OwnershipStatus,
 } from "../../../../types/ownership.types";
+import type { DirectionClaim } from "../types";
 
 /**
  * Minimal interface for ancestor context needed for ownership resolution.
@@ -75,3 +76,17 @@ function resolveDirectionOwnership(
 	// No one claims this direction
 	return "none";
 }
+
+/**
+ * Returns true when the current screen should fail and defer to a child claim.
+ */
+export function shouldDeferToChildClaim(
+	childClaim: DirectionClaim,
+	selfRouteKey: string,
+): boolean {
+	"worklet";
+	if (!childClaim) return false;
+	if (childClaim.routeKey === selfRouteKey) return false;
+	if (childClaim.isDismissing.get()) return false;
+	return true;
+}