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

package/src/shared/providers/gestures/helpers/register-direction-claims.ts

@@ -1,84 +0,0 @@
-import { useEffect } from "react";
-import { GestureStore } from "../../../stores/gesture.store";
-import {
-	type ClaimedDirections,
-	DIRECTIONS,
-	type Direction,
-} from "../../../types/ownership.types";
-import type { GestureContextType } from "../types";
-
-/**
- * Registers direction claims on ancestors that this screen shadows.
- * Only registers claims when this screen is the current (topmost) route
- * in its navigator, preventing unfocused screens from blocking gestures.
- */
-export function useRegisterDirectionClaims(
-	ancestorContext: GestureContextType | null | undefined,
-	claimedDirections: ClaimedDirections,
-	routeKey: string,
-	isIsolated: boolean,
-	isCurrentRoute: boolean,
-) {
-	useEffect(() => {
-		// Only register claims when this screen is the current route
-		if (!isCurrentRoute || !ancestorContext) {
-			return;
-		}
-
-		const gestureValues = GestureStore.getBag(routeKey);
-		const isDismissing = gestureValues.dismissing;
-
-		const claimedAncestors: Array<{
-			ancestor: GestureContextType;
-			directions: Direction[];
-		}> = [];
-
-		let ancestor: GestureContextType | null = ancestorContext;
-		while (ancestor) {
-			if (ancestor.isIsolated !== isIsolated) break;
-
-			const shadowedDirections: Direction[] = [];
-			for (const dir of DIRECTIONS) {
-				if (claimedDirections[dir] && ancestor.claimedDirections?.[dir]) {
-					shadowedDirections.push(dir);
-				}
-			}
-
-			if (shadowedDirections.length > 0) {
-				claimedAncestors.push({ ancestor, directions: shadowedDirections });
-				const newClaims = { ...ancestor.childDirectionClaims.value };
-				for (const dir of shadowedDirections) {
-					newClaims[dir] = { routeKey, isDismissing };
-				}
-				ancestor.childDirectionClaims.value = newClaims;
-			}
-
-			ancestor = ancestor.ancestorContext;
-		}
-
-		return () => {
-			for (const { ancestor, directions } of claimedAncestors) {
-				const currentClaims = ancestor.childDirectionClaims.value;
-				const newClaims = { ...currentClaims };
-				let needsUpdate = false;
-
-				for (const dir of directions) {
-					if (currentClaims[dir]?.routeKey === routeKey) {
-						newClaims[dir] = null;
-						needsUpdate = true;
-					}
-				}
-
-				if (needsUpdate) {
-					ancestor.childDirectionClaims.value = newClaims;
-				}
-			}
-		};
-	}, [
-		ancestorContext,
-		claimedDirections,
-		routeKey,
-		isIsolated,
-		isCurrentRoute,
-	]);
-}

package/src/shared/providers/gestures/types.ts

@@ -1,45 +0,0 @@
-import type { GestureType } from "react-native-gesture-handler";
-import type { SharedValue } from "react-native-reanimated";
-import type { GestureStoreMap } from "../../stores/gesture.store";
-import type { ClaimedDirections } from "../../types/ownership.types";
-
-export type ScrollConfig = {
-	x: number;
-	y: number;
-	contentHeight: number;
-	contentWidth: number;
-	layoutHeight: number;
-	layoutWidth: number;
-	isTouched: boolean;
-};
-
-export type DirectionClaim = {
-	routeKey: string;
-	isDismissing: SharedValue<number>;
-} | null;
-
-export type DirectionClaimMap = {
-	vertical: DirectionClaim;
-	"vertical-inverted": DirectionClaim;
-	horizontal: DirectionClaim;
-	"horizontal-inverted": DirectionClaim;
-};
-
-export const NO_CLAIMS: DirectionClaimMap = {
-	vertical: null,
-	"vertical-inverted": null,
-	horizontal: null,
-	"horizontal-inverted": null,
-};
-
-export interface GestureContextType {
-	panGesture: GestureType;
-	panGestureRef: React.MutableRefObject<GestureType | undefined>;
-	scrollConfig: SharedValue<ScrollConfig | null>;
-	gestureAnimationValues: GestureStoreMap;
-	ancestorContext: GestureContextType | null;
-	gestureEnabled: boolean;
-	isIsolated: boolean;
-	claimedDirections: ClaimedDirections;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
-}

package/src/shared/providers/gestures/use-build-gestures.ts

@@ -1,164 +0,0 @@
-import { useCallback, useMemo, useRef } from "react";
-import { Gesture, type GestureType } from "react-native-gesture-handler";
-import type { SharedValue } from "react-native-reanimated";
-import { useNavigationHelpers } from "../../hooks/navigation/use-navigation-helpers";
-import { GestureStore, type GestureStoreMap } from "../../stores/gesture.store";
-import {
-	type ClaimedDirections,
-	DIRECTIONS,
-} from "../../types/ownership.types";
-import { claimsAnyDirection } from "../../utils/gesture/compute-claimed-directions";
-import { resolveOwnership } from "../../utils/gesture/resolve-ownership";
-import { validateSnapPoints } from "../../utils/gesture/validate-snap-points";
-import {
-	useDescriptorDerivations,
-	useDescriptors,
-} from "../screen/descriptors";
-import { useHandlers } from "./handlers/use-handlers";
-import type {
-	DirectionClaimMap,
-	GestureContextType,
-	ScrollConfig,
-} from "./types";
-
-/**
- * Finds ancestor pan gestures that we shadow (claim the same direction).
- * Used to block ancestors when child claims priority.
- */
-function findShadowedAncestorPanGestures(
-	selfClaims: ClaimedDirections,
-	ancestorContext: GestureContextType | null | undefined,
-	isIsolated: boolean,
-): GestureType[] {
-	const shadowedGestures: GestureType[] = [];
-	let ancestor = ancestorContext;
-
-	while (ancestor) {
-		if (ancestor.isIsolated !== isIsolated) break;
-
-		const shadowsAncestor = DIRECTIONS.some(
-			(dir) => selfClaims[dir] && ancestor?.claimedDirections?.[dir],
-		);
-
-		if (shadowsAncestor && ancestor.panGesture) {
-			shadowedGestures.push(ancestor.panGesture);
-		}
-
-		ancestor = ancestor.ancestorContext;
-	}
-
-	return shadowedGestures;
-}
-
-interface BuildGesturesHookProps {
-	scrollConfig: SharedValue<ScrollConfig | null>;
-	ancestorContext?: GestureContextType | null;
-	claimedDirections: ClaimedDirections;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
-	isIsolated: boolean;
-}
-
-/**
- * Builds the Pan gesture for screen dismissal.
- *
- * Handles shadowing: when child claims same direction as ancestor,
- * child's pan blocks ancestor's pan via `blocksExternalGesture()`.
- *
- * ScrollView coordination is handled separately by useScrollRegistry,
- * which creates its own Native gesture per ScrollView.
- */
-export const useBuildGestures = ({
-	scrollConfig,
-	ancestorContext,
-	claimedDirections,
-	childDirectionClaims,
-	isIsolated,
-}: BuildGesturesHookProps): {
-	panGesture: GestureType;
-	panGestureRef: React.MutableRefObject<GestureType | undefined>;
-	gestureAnimationValues: GestureStoreMap;
-} => {
-	const { current } = useDescriptors();
-	const { isFirstKey } = useDescriptorDerivations();
-	const { dismissScreen } = useNavigationHelpers();
-
-	const panGestureRef = useRef<GestureType | undefined>(undefined);
-	const gestureAnimationValues = GestureStore.getBag(current.route.key);
-
-	const { snapPoints: rawSnapPoints } = current.options;
-	const canDismiss = Boolean(
-		isFirstKey ? false : current.options.gestureEnabled,
-	);
-	const effectiveSnapPoints = useMemo(
-		() => validateSnapPoints({ snapPoints: rawSnapPoints, canDismiss }),
-		[rawSnapPoints, canDismiss],
-	);
-	const gestureEnabled = canDismiss || effectiveSnapPoints.hasSnapPoints;
-
-	const ownershipStatus = useMemo(
-		() => resolveOwnership(claimedDirections, ancestorContext ?? null),
-		[claimedDirections, ancestorContext],
-	);
-
-	const selfClaimsAny = claimsAnyDirection(claimedDirections);
-
-	const handleDismiss = useCallback(() => {
-		if (ancestorContext?.gestureAnimationValues.dismissing?.value) return;
-		dismissScreen();
-	}, [ancestorContext, dismissScreen]);
-
-	const { onTouchesDown, onTouchesMove, onStart, onUpdate, onEnd } =
-		useHandlers({
-			scrollConfig,
-			canDismiss,
-			handleDismiss,
-			ownershipStatus,
-			ancestorIsDismissing: ancestorContext?.gestureAnimationValues.dismissing,
-			claimedDirections,
-			ancestorContext,
-			childDirectionClaims,
-			effectiveSnapPoints,
-		});
-
-	return useMemo(() => {
-		const panGesture = Gesture.Pan()
-			.withRef(panGestureRef)
-			.enabled(gestureEnabled)
-			.manualActivation(true)
-			.onTouchesDown(onTouchesDown)
-			.onTouchesMove(onTouchesMove)
-			.onStart(onStart)
-			.onUpdate(onUpdate)
-			.onEnd(onEnd);
-
-		// Block shadowed ancestor pan gestures when we claim same directions
-		if (selfClaimsAny) {
-			const shadowedAncestorGestures = findShadowedAncestorPanGestures(
-				claimedDirections,
-				ancestorContext,
-				isIsolated,
-			);
-			for (const ancestorPan of shadowedAncestorGestures) {
-				panGesture.blocksExternalGesture(ancestorPan);
-			}
-		}
-
-		return {
-			panGesture,
-			panGestureRef,
-			gestureAnimationValues,
-		};
-	}, [
-		gestureEnabled,
-		selfClaimsAny,
-		claimedDirections,
-		onTouchesDown,
-		onTouchesMove,
-		onStart,
-		onUpdate,
-		onEnd,
-		gestureAnimationValues,
-		ancestorContext,
-		isIsolated,
-	]);
-};

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state.ts

@@ -1,169 +0,0 @@
-import type { SharedValue } from "react-native-reanimated";
-import {
-	ANIMATION_SNAP_THRESHOLD,
-	EPSILON,
-	FALSE,
-	TRUE,
-} from "../../../../constants";
-import type { GestureStoreMap } from "../../../../stores/gesture.store";
-import type { ScreenTransitionState } from "../../../../types/animation.types";
-import type { Layout } from "../../../../types/screen.types";
-import type { BaseStackRoute } from "../../../../types/stack.types";
-
-type BuiltState = {
-	progress: SharedValue<number>;
-	willAnimate: SharedValue<number>;
-	closing: SharedValue<number>;
-	animating: SharedValue<number>;
-	entering: SharedValue<number>;
-	settled: SharedValue<number>;
-	logicallySettled: SharedValue<number>;
-	gesture: GestureStoreMap;
-	route: BaseStackRoute;
-	meta?: Record<string, unknown>;
-	targetProgress: SharedValue<number>;
-	resolvedAutoSnapPoint: SharedValue<number>;
-	measuredContentLayout: SharedValue<Layout | null>;
-	hasAutoSnapPoint: boolean;
-	sortedNumericSnapPoints: number[];
-	unwrapped: ScreenTransitionState;
-};
-
-interface ComputeLogicallySettledParams {
-	progress: number;
-	targetProgress: number;
-	settled: number;
-	dragging: number;
-}
-
-const computeSettled = (params: {
-	animating: number;
-	dismissing: number;
-	closing: number;
-}) => {
-	"worklet";
-	const { animating, dismissing, closing } = params;
-	return animating || dismissing || closing ? FALSE : TRUE;
-};
-
-const computeSnapIndex = (progress: number, snapPoints: number[]): number => {
-	"worklet";
-	if (snapPoints.length === 0) return -1;
-	if (progress <= snapPoints[0]) return 0;
-	if (progress >= snapPoints[snapPoints.length - 1])
-		return snapPoints.length - 1;
-
-	for (let i = 0; i < snapPoints.length - 1; i++) {
-		if (progress <= snapPoints[i + 1]) {
-			const t =
-				(progress - snapPoints[i]) / (snapPoints[i + 1] - snapPoints[i]);
-			return i + t;
-		}
-	}
-	return snapPoints.length - 1;
-};
-
-export const computeLogicallySettled = ({
-	progress,
-	targetProgress,
-	settled,
-	dragging,
-}: ComputeLogicallySettledParams) => {
-	"worklet";
-
-	if (settled) {
-		return TRUE;
-	}
-
-	if (dragging) {
-		return FALSE;
-	}
-
-	return Math.abs(progress - targetProgress) <= ANIMATION_SNAP_THRESHOLD
-		? TRUE
-		: FALSE;
-};
-
-export const hydrateTransitionState = (
-	s: BuiltState,
-	dimensions: Layout,
-): ScreenTransitionState => {
-	"worklet";
-	const out = s.unwrapped;
-	out.progress = s.progress.get();
-	out.willAnimate = s.willAnimate.get();
-	out.closing = s.closing.get();
-	out.entering = s.entering.get();
-	out.gesture.x = s.gesture.x.get();
-	out.gesture.y = s.gesture.y.get();
-	out.gesture.normX = s.gesture.normX.get();
-	out.gesture.normY = s.gesture.normY.get();
-	out.gesture.dismissing = s.gesture.dismissing.get();
-	out.gesture.dragging = s.gesture.dragging.get();
-	out.gesture.direction = s.gesture.direction.get();
-
-	const isGestureSettling =
-		Math.abs(out.gesture.normX) > EPSILON ||
-		Math.abs(out.gesture.normY) > EPSILON;
-
-	out.animating =
-		s.animating.get() || out.gesture.dragging || isGestureSettling ? 1 : 0;
-
-	out.gesture.normalizedX = out.gesture.normX;
-	out.gesture.normalizedY = out.gesture.normY;
-	out.gesture.isDismissing = out.gesture.dismissing;
-	out.gesture.isDragging = out.gesture.dragging;
-
-	out.settled = computeSettled({
-		animating: out.animating,
-		dismissing: out.gesture.dismissing,
-		closing: out.closing,
-	});
-	out.logicallySettled = computeLogicallySettled({
-		progress: out.progress,
-		targetProgress: s.targetProgress.get(),
-		settled: out.settled,
-		dragging: out.gesture.dragging,
-	});
-
-	if (s.settled.get() !== out.settled) {
-		s.settled.set(out.settled);
-	}
-
-	if (s.logicallySettled.get() !== out.logicallySettled) {
-		s.logicallySettled.set(out.logicallySettled);
-	}
-
-	out.meta = s.meta;
-	out.layouts.screen.width = dimensions.width;
-	out.layouts.screen.height = dimensions.height;
-
-	const content = s.measuredContentLayout.get();
-	if (content) {
-		if (!out.layouts.content) {
-			out.layouts.content = {
-				width: content.width,
-				height: content.height,
-			};
-		} else {
-			out.layouts.content.width = content.width;
-			out.layouts.content.height = content.height;
-		}
-	} else {
-		out.layouts.content = undefined;
-	}
-
-	const resolvedAutoSnap =
-		s.hasAutoSnapPoint && s.resolvedAutoSnapPoint.get() > 0
-			? s.resolvedAutoSnapPoint.get()
-			: null;
-
-	const resolvedSnapPoints =
-		resolvedAutoSnap !== null
-			? [...s.sortedNumericSnapPoints, resolvedAutoSnap].sort((a, b) => a - b)
-			: s.sortedNumericSnapPoints;
-
-	out.snapIndex = computeSnapIndex(out.progress, resolvedSnapPoints);
-
-	return out;
-};

package/src/shared/providers/screen/animation/helpers/resolve-screen-animation-target.ts

@@ -1,42 +0,0 @@
-import type { ScreenAnimationTarget } from "../types";
-
-type Params<T> = {
-	target: ScreenAnimationTarget | undefined;
-	self: T;
-	ancestors: T[];
-};
-
-const isAncestorTarget = (
-	target: ScreenAnimationTarget,
-): target is { ancestor: number } => {
-	return typeof target === "object" && target !== null && "ancestor" in target;
-};
-
-export function resolveScreenAnimationTarget<T>({
-	target,
-	self,
-	ancestors,
-}: Params<T>): T {
-	if (!target || target === "self") {
-		return self;
-	}
-
-	if (target === "parent") {
-		return ancestors[0] ?? self;
-	}
-
-	if (target === "root") {
-		return ancestors[ancestors.length - 1] ?? self;
-	}
-
-	if (!isAncestorTarget(target)) {
-		return self;
-	}
-
-	const depth = target.ancestor;
-	if (!Number.isInteger(depth) || depth < 1) {
-		return self;
-	}
-
-	return ancestors[depth - 1] ?? self;
-}

package/src/shared/providers/screen/descriptors/helpers/get-ancestor-navigator-keys.ts

@@ -1,29 +0,0 @@
-import type { BaseStackDescriptor } from "../../../../types/stack.types";
-
-/**
- * Builds the parent navigator key chain for nested navigators.
- * Returns keys from immediate parent navigator to root navigator.
- */
-export function getAncestorNavigatorKeys(
-	current: BaseStackDescriptor,
-): string[] {
-	const ancestors: string[] = [];
-	const nav = current.navigation as any;
-
-	if (typeof nav?.getParent !== "function") {
-		return ancestors;
-	}
-
-	let parent = nav.getParent();
-
-	while (parent) {
-		const state = parent.getState?.();
-		const key = state?.key;
-		if (typeof key === "string") {
-			ancestors.push(key);
-		}
-		parent = parent.getParent?.();
-	}
-
-	return ancestors;
-}