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

package/src/shared/providers/gestures/helpers/gesture-directions.ts

@@ -1,97 +0,0 @@
-import type {
-	GestureDirection,
-	GestureDirections,
-} from "../../../types/gesture.types";
-import type { Direction } from "../../../types/ownership.types";
-import { logger } from "../../../utils/logger";
-
-interface ResolveGestureDirectionsProps {
-	gestureDirection: GestureDirection | GestureDirection[];
-	hasSnapPoints: boolean;
-}
-
-export const warnOnSnapDirectionArray = ({
-	gestureDirection,
-	hasSnapPoints,
-}: ResolveGestureDirectionsProps) => {
-	if (!hasSnapPoints || !Array.isArray(gestureDirection)) return;
-
-	logger.warn(
-		`gestureDirection array is not supported with snapPoints. ` +
-			`Only the first direction "${gestureDirection[0]}" will be used. ` +
-			`Snap points define a single axis of movement, so only one gesture direction is needed.`,
-	);
-};
-
-export const resolveGestureDirections = ({
-	gestureDirection,
-	hasSnapPoints,
-}: ResolveGestureDirectionsProps): GestureDirections => {
-	const effectiveDirection = hasSnapPoints
-		? Array.isArray(gestureDirection)
-			? gestureDirection[0]
-			: gestureDirection
-		: gestureDirection;
-
-	const directionsArray = Array.isArray(effectiveDirection)
-		? effectiveDirection
-		: [effectiveDirection];
-
-	const isBidirectional = directionsArray.includes("bidirectional");
-
-	const hasHorizontalDirection =
-		directionsArray.includes("horizontal") ||
-		directionsArray.includes("horizontal-inverted");
-
-	const isSnapAxisInverted = hasHorizontalDirection
-		? directionsArray.includes("horizontal-inverted") &&
-			!directionsArray.includes("horizontal")
-		: directionsArray.includes("vertical-inverted") &&
-			!directionsArray.includes("vertical");
-
-	const enableBothVertical =
-		isBidirectional || (hasSnapPoints && !hasHorizontalDirection);
-	const enableBothHorizontal =
-		isBidirectional || (hasSnapPoints && hasHorizontalDirection);
-
-	return {
-		vertical: directionsArray.includes("vertical") || enableBothVertical,
-		verticalInverted:
-			directionsArray.includes("vertical-inverted") || enableBothVertical,
-		horizontal: directionsArray.includes("horizontal") || enableBothHorizontal,
-		horizontalInverted:
-			directionsArray.includes("horizontal-inverted") || enableBothHorizontal,
-		snapAxisInverted: hasSnapPoints && isSnapAxisInverted,
-	};
-};
-
-export const getSnapAxis = (
-	directions: GestureDirections,
-): "horizontal" | "vertical" => {
-	return directions.horizontal || directions.horizontalInverted
-		? "horizontal"
-		: "vertical";
-};
-
-export const isExpandGestureForDirection = (
-	swipeDirection: Direction,
-	snapAxis: "horizontal" | "vertical",
-	snapAxisInverted: boolean,
-): boolean => {
-	"worklet";
-	if (snapAxis === "horizontal") {
-		return snapAxisInverted
-			? swipeDirection === "horizontal"
-			: swipeDirection === "horizontal-inverted";
-	}
-
-	return snapAxisInverted
-		? swipeDirection === "vertical"
-		: swipeDirection === "vertical-inverted";
-};
-
-export const clampVelocity = (value: number, maxMagnitude: number) => {
-	"worklet";
-	const max = Math.max(0, Math.abs(maxMagnitude));
-	return Math.max(-max, Math.min(max, value));
-};

package/src/shared/providers/gestures/helpers/gesture-reset.ts

@@ -1,112 +0,0 @@
-import type {
-	GestureStateChangeEvent,
-	PanGestureHandlerEventPayload,
-} from "react-native-gesture-handler";
-import {
-	DEFAULT_GESTURE_RELEASE_VELOCITY_MAX,
-	DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
-	FALSE,
-	TRUE,
-} from "../../../constants";
-import type { GestureStoreMap } from "../../../stores/gesture.store";
-import type { AnimationConfig } from "../../../types/animation.types";
-import { animateMany } from "../../../utils/animation/animate-many";
-import {
-	calculateRestoreVelocityTowardZero,
-	normalizeVelocity,
-} from "./gesture-physics";
-
-interface ResetGestureValuesProps {
-	spec?: AnimationConfig;
-	gestures: GestureStoreMap;
-	shouldDismiss: boolean;
-	event: GestureStateChangeEvent<PanGestureHandlerEventPayload>;
-	dimensions: { width: number; height: number };
-	gestureReleaseVelocityScale?: number;
-	gestureReleaseVelocityMax?: number;
-}
-
-export const resetGestureValues = ({
-	spec,
-	gestures,
-	shouldDismiss,
-	event,
-	dimensions,
-	gestureReleaseVelocityScale,
-	gestureReleaseVelocityMax,
-}: ResetGestureValuesProps) => {
-	"worklet";
-	const resolvedGestureReleaseVelocityScale =
-		gestureReleaseVelocityScale ?? DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE;
-	const resolvedGestureReleaseVelocityMax =
-		gestureReleaseVelocityMax ?? DEFAULT_GESTURE_RELEASE_VELOCITY_MAX;
-
-	const effectiveReleaseVelocityMax = Math.max(
-		0,
-		Math.abs(resolvedGestureReleaseVelocityMax),
-	);
-
-	const vxNorm = normalizeVelocity(
-		event.velocityX,
-		dimensions.width,
-		effectiveReleaseVelocityMax,
-	);
-	const vyNorm = normalizeVelocity(
-		event.velocityY,
-		dimensions.height,
-		effectiveReleaseVelocityMax,
-	);
-
-	// Ensure spring starts moving toward zero using normalized gesture values for direction.
-	const nx =
-		gestures.normX.value || event.translationX / Math.max(1, dimensions.width);
-
-	const ny =
-		gestures.normY.value || event.translationY / Math.max(1, dimensions.height);
-
-	const vxTowardZero = calculateRestoreVelocityTowardZero(nx, vxNorm);
-	const vyTowardZero = calculateRestoreVelocityTowardZero(ny, vyNorm);
-
-	// When dismissing, use raw fling velocity (scaled by gestureReleaseVelocityScale)
-	// so the spring carries the gesture's momentum. The spec controls the
-	// spring character — use an underdamped spec (e.g. FlingSpec) for orbit/fling.
-	const resetVX = shouldDismiss
-		? vxNorm * resolvedGestureReleaseVelocityScale
-		: vxTowardZero;
-
-	const resetVY = shouldDismiss
-		? vyNorm * resolvedGestureReleaseVelocityScale
-		: vyTowardZero;
-
-	animateMany({
-		items: [
-			{
-				value: gestures.x,
-				toValue: 0,
-				config: { ...spec, velocity: resetVX },
-			},
-			{
-				value: gestures.y,
-				toValue: 0,
-				config: { ...spec, velocity: resetVY },
-			},
-			{
-				value: gestures.normX,
-				toValue: 0,
-				config: { ...spec, velocity: resetVX },
-			},
-			{
-				value: gestures.normY,
-				toValue: 0,
-				config: { ...spec, velocity: resetVY },
-			},
-		],
-		onAllFinished: () => {
-			"worklet";
-			gestures.direction.value = null;
-		},
-	});
-
-	gestures.dragging.value = FALSE;
-	gestures.dismissing.value = shouldDismiss ? TRUE : FALSE;
-};

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/styles/helpers/resolve-slot-styles.ts

@@ -1,190 +0,0 @@
-import type {
-	NormalizedTransitionInterpolatedStyle,
-	NormalizedTransitionSlotStyle,
-} from "../../../../types/animation.types";
-import {
-	ALWAYS_RESET_STYLE_VALUES,
-	IDENTITY_TRANSFORM,
-	shouldSlotInherit,
-} from "../constants";
-
-export type ResettableStyleState = {
-	hasTransform: boolean;
-	hasOpacity: boolean;
-	hasZIndex: boolean;
-	hasElevation: boolean;
-};
-
-export type ResettableStyleStatesBySlot = Record<string, ResettableStyleState>;
-
-const EMPTY_RESETTABLE_STYLE_STATE = Object.freeze({
-	hasTransform: false,
-	hasOpacity: false,
-	hasZIndex: false,
-	hasElevation: false,
-}) as ResettableStyleState;
-
-export const resolveSlotStyles = ({
-	currentStylesMap,
-	ancestorStylesMap,
-	previousStyleStatesBySlot,
-}: {
-	currentStylesMap: NormalizedTransitionInterpolatedStyle;
-	ancestorStylesMap: NormalizedTransitionInterpolatedStyle;
-	previousStyleStatesBySlot: ResettableStyleStatesBySlot;
-}) => {
-	"worklet";
-	const resolvedStylesMap: NormalizedTransitionInterpolatedStyle = {};
-	const nextPreviousStyleStatesBySlot: ResettableStyleStatesBySlot = {};
-
-	const appendResolvedSlot = (slotId: string) => {
-		"worklet";
-
-		const slot =
-			currentStylesMap[slotId] ??
-			(shouldSlotInherit(slotId) ? ancestorStylesMap[slotId] : undefined);
-
-		const baseStyle = slot?.style as Record<string, unknown> | undefined;
-
-		let hasAnyStyleKeys = false;
-		let hasTransform = false;
-		let hasOpacity = false;
-		let hasZIndex = false;
-		let hasElevation = false;
-
-		if (baseStyle) {
-			for (const key in baseStyle) {
-				hasAnyStyleKeys = true;
-
-				if (key === "transform") {
-					hasTransform = true;
-					continue;
-				}
-
-				if (key === "opacity") {
-					hasOpacity = true;
-					continue;
-				}
-
-				if (key === "zIndex") {
-					hasZIndex = true;
-					continue;
-				}
-
-				if (key === "elevation") {
-					hasElevation = true;
-				}
-			}
-		}
-
-		const previousState =
-			previousStyleStatesBySlot[slotId] ?? EMPTY_RESETTABLE_STYLE_STATE;
-		const shouldResetTransform = previousState.hasTransform && !hasTransform;
-		const shouldResetOpacity = previousState.hasOpacity && !hasOpacity;
-		const shouldResetZIndex = previousState.hasZIndex && !hasZIndex;
-		const shouldResetElevation = previousState.hasElevation && !hasElevation;
-		const hasResetPatch =
-			shouldResetTransform ||
-			shouldResetOpacity ||
-			shouldResetZIndex ||
-			shouldResetElevation;
-		const hasProps = slot?.props !== undefined;
-
-		if (hasTransform || hasOpacity || hasZIndex || hasElevation) {
-			nextPreviousStyleStatesBySlot[slotId] = {
-				hasTransform,
-				hasOpacity,
-				hasZIndex,
-				hasElevation,
-			};
-		}
-
-		if (!slot && !hasResetPatch) {
-			return;
-		}
-
-		if (!hasResetPatch && slot) {
-			if (hasAnyStyleKeys || hasProps) {
-				resolvedStylesMap[slotId] = slot;
-			}
-			return;
-		}
-
-		if (!hasAnyStyleKeys && !hasResetPatch && !hasProps) {
-			return;
-		}
-
-		const resolvedSlot = {} as NormalizedTransitionSlotStyle;
-
-		if (hasAnyStyleKeys || hasResetPatch) {
-			const resolvedStyle: Record<string, any> = {};
-
-			if (shouldResetTransform) {
-				resolvedStyle.transform = IDENTITY_TRANSFORM;
-			}
-
-			if (shouldResetOpacity) {
-				resolvedStyle.opacity = ALWAYS_RESET_STYLE_VALUES.opacity;
-			}
-
-			if (shouldResetZIndex) {
-				resolvedStyle.zIndex = ALWAYS_RESET_STYLE_VALUES.zIndex;
-			}
-
-			if (shouldResetElevation) {
-				resolvedStyle.elevation = ALWAYS_RESET_STYLE_VALUES.elevation;
-			}
-
-			if (baseStyle) {
-				for (const key in baseStyle) {
-					resolvedStyle[key] = baseStyle[key];
-				}
-			}
-
-			resolvedSlot.style = resolvedStyle;
-		}
-
-		if (hasProps) {
-			resolvedSlot.props = slot?.props;
-		}
-
-		if (!resolvedSlot.style && !resolvedSlot.props) {
-			return;
-		}
-
-		resolvedStylesMap[slotId] = resolvedSlot;
-	};
-
-	for (const slotId in currentStylesMap) {
-		appendResolvedSlot(slotId);
-	}
-
-	for (const slotId in ancestorStylesMap) {
-		if (!shouldSlotInherit(slotId)) {
-			continue;
-		}
-
-		if (currentStylesMap[slotId] !== undefined) {
-			continue;
-		}
-
-		appendResolvedSlot(slotId);
-	}
-
-	for (const slotId in previousStyleStatesBySlot) {
-		if (currentStylesMap[slotId] !== undefined) {
-			continue;
-		}
-
-		if (shouldSlotInherit(slotId) && ancestorStylesMap[slotId] !== undefined) {
-			continue;
-		}
-
-		appendResolvedSlot(slotId);
-	}
-
-	return {
-		resolvedStylesMap,
-		nextPreviousStyleStatesBySlot,
-	};
-};