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

package/src/shared/hooks/reanimated/use-animated-debounce.ts

@@ -1,53 +0,0 @@
-import {
-	cancelAnimation,
-	useAnimatedReaction,
-	useSharedValue,
-	withDelay,
-	withTiming,
-} from "react-native-reanimated";
-
-const SCROLL_SETTLE_DELAY_MS = 25;
-
-interface AnimatedDebounceControls {
-	trigger: () => void;
-	cancel: () => void;
-}
-
-/**
- * Debounces a UI-thread callback using Reanimated timing primitives.
- *
- * Call `trigger()` from a worklet to reset the debounce window. When no new
- * trigger arrives within `delayMs`, `onDebounced` fires once on the UI thread.
- */
-export function useAnimatedDebounce(
-	onDebounced: () => void,
-	delayMs: number = SCROLL_SETTLE_DELAY_MS,
-): AnimatedDebounceControls {
-	const token = useSharedValue(0);
-
-	const trigger = () => {
-		"worklet";
-		cancelAnimation(token);
-		token.set(withDelay(delayMs, withTiming(token.get() + 1, { duration: 0 })));
-	};
-
-	const cancel = () => {
-		"worklet";
-		cancelAnimation(token);
-	};
-
-	useAnimatedReaction(
-		() => token.get(),
-		(nextToken, previousToken) => {
-			"worklet";
-			if (nextToken === 0 || nextToken === previousToken) {
-				return;
-			}
-
-			onDebounced();
-		},
-		[delayMs, onDebounced],
-	);
-
-	return { trigger, cancel };
-}

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

@@ -1,335 +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 {
-	ScreenTransitionOptions,
-	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>;
-	options: ScreenTransitionOptions;
-	navigationMaskEnabled: boolean;
-	targetProgress: SharedValue<number>;
-	resolvedAutoSnapPoint: SharedValue<number>;
-	measuredContentLayout: SharedValue<Layout | null>;
-	contentLayoutSlot: Layout;
-	hasAutoSnapPoint: boolean;
-	sortedNumericSnapPoints: number[];
-	unwrapped: ScreenTransitionState;
-};
-
-interface ComputeLogicallySettledParams {
-	progress: number;
-	targetProgress: number;
-	settled: number;
-	gestureActive: number;
-}
-
-const computeSettled = (
-	animating: number,
-	dismissing: number,
-	closing: number,
-) => {
-	"worklet";
-	return animating || dismissing || closing ? FALSE : TRUE;
-};
-
-const getResolvedSnapPointCount = (
-	snapPoints: number[],
-	resolvedAutoSnap: number | null,
-) => {
-	"worklet";
-	return snapPoints.length + (resolvedAutoSnap !== null ? 1 : 0);
-};
-
-const getAutoSnapPointIndex = (
-	snapPoints: number[],
-	resolvedAutoSnap: number,
-) => {
-	"worklet";
-	let index = 0;
-
-	while (index < snapPoints.length && snapPoints[index] <= resolvedAutoSnap) {
-		index++;
-	}
-
-	return index;
-};
-
-const getResolvedSnapPointAt = (
-	snapPoints: number[],
-	resolvedAutoSnap: number | null,
-	autoSnapPointIndex: number,
-	index: number,
-) => {
-	"worklet";
-	if (resolvedAutoSnap === null) {
-		return snapPoints[index];
-	}
-
-	if (index < autoSnapPointIndex) {
-		return snapPoints[index];
-	}
-
-	if (index === autoSnapPointIndex) {
-		return resolvedAutoSnap;
-	}
-
-	return snapPoints[index - 1];
-};
-
-const computeAnimatedSnapIndex = (
-	progress: number,
-	snapPoints: number[],
-	resolvedAutoSnap: number | null,
-): number => {
-	"worklet";
-	const snapPointCount = getResolvedSnapPointCount(
-		snapPoints,
-		resolvedAutoSnap,
-	);
-
-	if (snapPointCount === 0) return -1;
-
-	const autoSnapPointIndex =
-		resolvedAutoSnap === null
-			? -1
-			: getAutoSnapPointIndex(snapPoints, resolvedAutoSnap);
-	const firstSnapPoint = getResolvedSnapPointAt(
-		snapPoints,
-		resolvedAutoSnap,
-		autoSnapPointIndex,
-		0,
-	);
-	const lastSnapPoint = getResolvedSnapPointAt(
-		snapPoints,
-		resolvedAutoSnap,
-		autoSnapPointIndex,
-		snapPointCount - 1,
-	);
-
-	if (progress <= firstSnapPoint) return 0;
-	if (progress >= lastSnapPoint) return snapPointCount - 1;
-
-	for (let i = 0; i < snapPointCount - 1; i++) {
-		const currentSnapPoint = getResolvedSnapPointAt(
-			snapPoints,
-			resolvedAutoSnap,
-			autoSnapPointIndex,
-			i,
-		);
-		const nextSnapPoint = getResolvedSnapPointAt(
-			snapPoints,
-			resolvedAutoSnap,
-			autoSnapPointIndex,
-			i + 1,
-		);
-
-		if (progress <= nextSnapPoint) {
-			const t =
-				(progress - currentSnapPoint) / (nextSnapPoint - currentSnapPoint);
-			return i + t;
-		}
-	}
-	return snapPointCount - 1;
-};
-
-const computeTargetSnapIndex = (
-	targetProgress: number,
-	snapPoints: number[],
-	resolvedAutoSnap: number | null,
-): number => {
-	"worklet";
-	const snapPointCount = getResolvedSnapPointCount(
-		snapPoints,
-		resolvedAutoSnap,
-	);
-
-	if (snapPointCount === 0) return -1;
-
-	const autoSnapPointIndex =
-		resolvedAutoSnap === null
-			? -1
-			: getAutoSnapPointIndex(snapPoints, resolvedAutoSnap);
-	const firstSnapPoint = getResolvedSnapPointAt(
-		snapPoints,
-		resolvedAutoSnap,
-		autoSnapPointIndex,
-		0,
-	);
-
-	if (targetProgress <= 0 && Math.abs(firstSnapPoint) > EPSILON) {
-		return -1;
-	}
-
-	let nearestIndex = 0;
-	let smallestDistance = Math.abs(targetProgress - firstSnapPoint);
-
-	for (let i = 1; i < snapPointCount; i++) {
-		const snapPoint = getResolvedSnapPointAt(
-			snapPoints,
-			resolvedAutoSnap,
-			autoSnapPointIndex,
-			i,
-		);
-		const distance = Math.abs(targetProgress - snapPoint);
-
-		if (distance < smallestDistance) {
-			smallestDistance = distance;
-			nearestIndex = i;
-		}
-	}
-
-	return nearestIndex;
-};
-
-const computeLogicallySettledValue = (
-	progress: number,
-	targetProgress: number,
-	settled: number,
-	gestureActive: number,
-) => {
-	"worklet";
-
-	if (settled) {
-		return TRUE;
-	}
-
-	if (gestureActive) {
-		return FALSE;
-	}
-
-	return Math.abs(progress - targetProgress) <= ANIMATION_SNAP_THRESHOLD
-		? TRUE
-		: FALSE;
-};
-
-export const computeLogicallySettled = (
-	params: ComputeLogicallySettledParams,
-) => {
-	"worklet";
-	return computeLogicallySettledValue(
-		params.progress,
-		params.targetProgress,
-		params.settled,
-		params.gestureActive,
-	);
-};
-
-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.scale = s.gesture.scale.get();
-	out.gesture.normScale = s.gesture.normScale.get();
-	out.gesture.focalX = s.gesture.focalX.get();
-	out.gesture.focalY = s.gesture.focalY.get();
-	out.gesture.raw.x = s.gesture.raw.x.get();
-	out.gesture.raw.y = s.gesture.raw.y.get();
-	out.gesture.raw.normX = s.gesture.raw.normX.get();
-	out.gesture.raw.normY = s.gesture.raw.normY.get();
-	out.gesture.raw.scale = s.gesture.raw.scale.get();
-	out.gesture.raw.normScale = s.gesture.raw.normScale.get();
-	out.gesture.dismissing = s.gesture.dismissing.get();
-	out.gesture.dragging = s.gesture.dragging.get();
-	out.gesture.settling = s.gesture.settling.get();
-	out.gesture.active = s.gesture.active.get();
-	out.gesture.direction = s.gesture.direction.get();
-
-	const isGestureSettling =
-		Math.abs(out.gesture.normX) > EPSILON ||
-		Math.abs(out.gesture.normY) > EPSILON ||
-		Math.abs(out.gesture.normScale) > EPSILON;
-	const isGestureActive =
-		out.gesture.dragging || out.gesture.settling || isGestureSettling
-			? TRUE
-			: FALSE;
-
-	out.animating = s.animating.get() || isGestureActive ? 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(
-		out.animating,
-		out.gesture.dismissing,
-		out.closing,
-	);
-	const targetProgress = s.targetProgress.get();
-	out.logicallySettled = computeLogicallySettledValue(
-		out.progress,
-		targetProgress,
-		out.settled,
-		isGestureActive,
-	);
-
-	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.options = s.options;
-	out.route = s.route;
-	out.layouts.screen.width = dimensions.width;
-	out.layouts.screen.height = dimensions.height;
-	out.layouts.navigationMaskEnabled = s.navigationMaskEnabled;
-
-	const content = s.measuredContentLayout.get();
-	if (content) {
-		s.contentLayoutSlot.width = content.width;
-		s.contentLayoutSlot.height = content.height;
-		out.layouts.content = s.contentLayoutSlot;
-	} else {
-		out.layouts.content = undefined;
-	}
-
-	const autoSnapPoint = s.resolvedAutoSnapPoint.get();
-	const resolvedAutoSnap =
-		s.hasAutoSnapPoint && autoSnapPoint > 0 ? autoSnapPoint : null;
-
-	out.animatedSnapIndex = computeAnimatedSnapIndex(
-		out.progress,
-		s.sortedNumericSnapPoints,
-		resolvedAutoSnap,
-	);
-	out.snapIndex = computeTargetSnapIndex(
-		targetProgress,
-		s.sortedNumericSnapPoints,
-		resolvedAutoSnap,
-	);
-
-	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;
-}

package/src/shared/providers/screen/gestures/activation/use-pan-activation.ts

@@ -1,244 +0,0 @@
-import { useCallback, useMemo } from "react";
-import type {
-	GestureStateManager,
-	GestureTouchEvent,
-} from "react-native-gesture-handler";
-import { type SharedValue, useSharedValue } from "react-native-reanimated";
-import { EPSILON } from "../../../../constants";
-import { GestureStore } from "../../../../stores/gesture.store";
-import { GestureActivationState } from "../../../../types/gesture.types";
-import type { Direction } from "../../../../types/ownership.types";
-import { useDescriptorDerivations } from "../../descriptors";
-import type { ScreenOptionsContextValue } from "../../options";
-import {
-	applyOffsetRules,
-	checkScrollBoundary,
-} from "../helpers/gesture-activation";
-import { getPanSnapAxisConfigForDirection } from "../helpers/gesture-directions";
-import { resolveRuntimeSnapPoints } from "../helpers/gesture-snap-points";
-import { resolvePanRuntime } from "../helpers/runtime-options";
-import { shouldDeferToChildClaim } from "../ownership/should-defer-to-child-claim";
-import type {
-	DirectionClaimMap,
-	GestureDimensions,
-	PanGestureRuntime,
-	ScrollGestureState,
-} from "../types";
-
-interface UsePanActivationProps {
-	scrollState: SharedValue<ScrollGestureState | null>;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
-	runtime: SharedValue<PanGestureRuntime>;
-	screenOptions: ScreenOptionsContextValue;
-	dimensions: GestureDimensions;
-}
-
-export const usePanActivation = ({
-	scrollState,
-	childDirectionClaims,
-	runtime,
-	screenOptions,
-	dimensions,
-}: UsePanActivationProps) => {
-	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
-
-	const ancestorDismissing = useMemo(() => {
-		if (!parentScreenKey) return null;
-		return GestureStore.peekBag(parentScreenKey)?.dismissing ?? null;
-	}, [parentScreenKey]);
-
-	const initialTouch = useSharedValue({ x: 0, y: 0 });
-
-	const gestureActivationState = useSharedValue<GestureActivationState>(
-		GestureActivationState.PENDING,
-	);
-
-	const onTouchesDown = useCallback(
-		(
-			event: GestureTouchEvent,
-			stateManager: GestureStateManager | undefined,
-		) => {
-			"worklet";
-			const { participation, policy } = resolvePanRuntime(
-				runtime.get(),
-				screenOptions.get(),
-			);
-
-			if (
-				!participation.canTrackGesture ||
-				!policy.enabled ||
-				event.numberOfTouches !== 1
-			) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager?.fail();
-				return;
-			}
-
-			const firstTouch = event.changedTouches[0];
-			initialTouch.set({ x: firstTouch.x, y: firstTouch.y });
-			gestureActivationState.set(GestureActivationState.PENDING);
-		},
-		[gestureActivationState, initialTouch, runtime, screenOptions],
-	);
-
-	const onTouchesMove = useCallback(
-		(event: GestureTouchEvent, stateManager: GestureStateManager) => {
-			"worklet";
-
-			if (event.numberOfTouches !== 1) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			if (ancestorDismissing?.get()) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			const {
-				participation,
-				policy,
-				stores: { animations, gestures, system },
-			} = resolvePanRuntime(runtime.get(), screenOptions.get());
-			const {
-				hasSnapPoints,
-				hasAutoSnapPoint,
-				snapPoints,
-				minSnapPoint,
-				maxSnapPoint,
-			} = participation.effectiveSnapPoints;
-
-			if (!participation.canTrackGesture || !policy.enabled) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			const touch = event.changedTouches[0];
-
-			const { isSwipingDown, isSwipingUp, isSwipingRight, isSwipingLeft } =
-				applyOffsetRules({
-					touch,
-					directions: policy.panActivationDirections,
-					dimensions,
-					gestureActivationState,
-					initialTouch: initialTouch.get(),
-					activationArea: policy.gestureActivationArea,
-					responseDistance: policy.gestureResponseDistance,
-				});
-
-			if (gestureActivationState.get() === GestureActivationState.FAILED) {
-				stateManager.fail();
-				return;
-			}
-
-			if (gestures.dragging.get()) {
-				stateManager.activate();
-				return;
-			}
-
-			let swipeDirection: Direction | null = null;
-			if (isSwipingDown) swipeDirection = "vertical";
-			else if (isSwipingUp) swipeDirection = "vertical-inverted";
-			else if (isSwipingRight) swipeDirection = "horizontal";
-			else if (isSwipingLeft) swipeDirection = "horizontal-inverted";
-
-			if (!swipeDirection) {
-				return;
-			}
-
-			if (participation.ownershipStatus[swipeDirection] !== "self") {
-				stateManager.fail();
-				return;
-			}
-
-			// A nested screen shadowing this direction gets priority while it is active.
-			const childClaim = childDirectionClaims.get()[swipeDirection];
-			if (shouldDeferToChildClaim(childClaim, currentScreenKey)) {
-				stateManager.fail();
-				return;
-			}
-
-			if (gestureActivationState.get() !== GestureActivationState.PASSED) {
-				return;
-			}
-
-			const activeSnapAxis = hasSnapPoints
-				? getPanSnapAxisConfigForDirection(
-						policy.snapAxisDirections,
-						swipeDirection,
-					)
-				: null;
-			const isExpandGesture = activeSnapAxis?.config.expand === swipeDirection;
-
-			if (hasSnapPoints && policy.gestureSnapLocked && isExpandGesture) {
-				stateManager.fail();
-				return;
-			}
-
-			if (!hasSnapPoints && gestures.dismissing.get()) {
-				return;
-			}
-
-			const currentScrollState = scrollState.get();
-			const isTouchingScrollView = currentScrollState?.isTouched ?? false;
-
-			if (isTouchingScrollView) {
-				const atBoundary = checkScrollBoundary(
-					currentScrollState,
-					swipeDirection,
-					activeSnapAxis?.config.inverted,
-				);
-
-				if (!atBoundary) {
-					stateManager.fail();
-					return;
-				}
-
-				if (hasSnapPoints && isExpandGesture) {
-					if (policy.sheetScrollGestureBehavior === "collapse-only") {
-						stateManager.fail();
-						return;
-					}
-
-					const { resolvedMaxSnapPoint } = resolveRuntimeSnapPoints({
-						snapPoints,
-						hasAutoSnapPoint,
-						resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-						minSnapPoint,
-						maxSnapPoint,
-						canDismiss: participation.canDismiss,
-					});
-
-					const canExpandMore =
-						animations.progress.get() < resolvedMaxSnapPoint - EPSILON &&
-						system.targetProgress.get() < resolvedMaxSnapPoint - EPSILON;
-
-					if (!canExpandMore) {
-						stateManager.fail();
-						return;
-					}
-				}
-			}
-
-			gestures.active.set(swipeDirection);
-			gestures.direction.set(swipeDirection);
-			stateManager.activate();
-		},
-		[
-			ancestorDismissing,
-			childDirectionClaims,
-			currentScreenKey,
-			dimensions,
-			gestureActivationState,
-			initialTouch,
-			runtime,
-			screenOptions,
-			scrollState,
-		],
-	);
-
-	return { onTouchesDown, onTouchesMove };
-};