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

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-physics.ts

@@ -1,214 +0,0 @@
-import type {
-	GestureStateChangeEvent,
-	PanGestureHandlerEventPayload,
-} from "react-native-gesture-handler";
-import { clamp } from "react-native-reanimated";
-import {
-	ANIMATION_SNAP_THRESHOLD,
-	DEFAULT_GESTURE_RELEASE_VELOCITY_MAX,
-	EPSILON,
-} from "../../../constants";
-import type { AnimationStoreMap } from "../../../stores/animation.store";
-import type { GestureDirections } from "../../../types/gesture.types";
-
-interface CalculateProgressProps {
-	animations: AnimationStoreMap;
-	shouldDismiss: boolean;
-	event: GestureStateChangeEvent<PanGestureHandlerEventPayload>;
-	dimensions: { width: number; height: number };
-	directions: GestureDirections;
-}
-
-type GestureAxisCandidate = {
-	progressContribution: number;
-	velocityContribution: number;
-};
-
-/**
- * Converts velocity from pixels/second to normalized units/second (0-1 range)
- * and caps the result for stability
- */
-export const normalizeVelocity = (
-	velocityPixelsPerSecond: number,
-	screenSize: number,
-	maxMagnitude?: number,
-) => {
-	"worklet";
-	const resolvedMaxMagnitude =
-		maxMagnitude ?? DEFAULT_GESTURE_RELEASE_VELOCITY_MAX;
-	const max = Math.max(0, Math.abs(resolvedMaxMagnitude));
-	return clamp(velocityPixelsPerSecond / Math.max(1, screenSize), -max, max);
-};
-
-/**
- * Normalizes translation to -1...1 range (for gesture tracking).
- * Used to convert pixel translation to normalized gesture values.
- */
-export const normalizeGestureTranslation = (
-	translation: number,
-	dimension: number,
-) => {
-	"worklet";
-	return clamp(translation / Math.max(1, dimension), -1, 1);
-};
-
-/**
- * Calculates a normalized velocity that moves the current value toward zero.
- * Used for spring-back animations when dismissing gestures.
- */
-export const calculateRestoreVelocityTowardZero = (
-	currentValueNormalized: number,
-	baseVelocityNormalized: number,
-) => {
-	"worklet";
-
-	if (Math.abs(currentValueNormalized) < ANIMATION_SNAP_THRESHOLD) return 0;
-
-	const directionTowardZero = Math.sign(currentValueNormalized) || 1;
-	const clampedVelocity = Math.min(Math.abs(baseVelocityNormalized), 1);
-
-	return -directionTowardZero * clampedVelocity;
-};
-
-export const calculateProgressSpringVelocity = ({
-	animations,
-	shouldDismiss,
-	event,
-	dimensions,
-	directions,
-}: CalculateProgressProps) => {
-	"worklet";
-
-	const currentProgress = animations.progress.value;
-	const targetProgress = shouldDismiss ? 0 : 1;
-	const progressDelta = targetProgress - currentProgress;
-
-	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: normalizeVelocity(
-				event.velocityX,
-				dimensions.width,
-			),
-		});
-	}
-
-	if (directions.horizontalInverted && event.translationX < 0) {
-		candidates.push({
-			progressContribution: -event.translationX / Math.max(1, dimensions.width),
-			velocityContribution: normalizeVelocity(
-				-event.velocityX,
-				dimensions.width,
-			),
-		});
-	}
-
-	if (directions.vertical && event.translationY > 0) {
-		candidates.push({
-			progressContribution: event.translationY / Math.max(1, dimensions.height),
-			velocityContribution: normalizeVelocity(
-				event.velocityY,
-				dimensions.height,
-			),
-		});
-	}
-
-	if (directions.verticalInverted && event.translationY < 0) {
-		candidates.push({
-			progressContribution:
-				-event.translationY / Math.max(1, dimensions.height),
-			velocityContribution: normalizeVelocity(
-				-event.velocityY,
-				dimensions.height,
-			),
-		});
-	}
-
-	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 = normalizeVelocity(
-			event.velocityX,
-			dimensions.width,
-		);
-		const normalizedVelocityY = normalizeVelocity(
-			event.velocityY,
-			dimensions.height,
-		);
-		progressVelocityMagnitude = Math.max(
-			Math.abs(normalizedVelocityX),
-			Math.abs(normalizedVelocityY),
-		);
-	}
-
-	// Apply direction and clamp to prevent overly energetic springs
-	return (
-		progressDirection *
-		clamp(progressVelocityMagnitude, 0, DEFAULT_GESTURE_RELEASE_VELOCITY_MAX)
-	);
-};
-
-/**
- * Determines if a gesture should trigger dismissal based on combined
- * translation and velocity in normalized screen units (0-1 range).
- *
- * Formula: |translation/screen + clamp(velocity/screen, ±1) * velocityWeight| > 0.5
- */
-export const shouldDismissFromTranslationAndVelocity = (
-	translationPixels: number,
-	velocityPixelsPerSecond: number,
-	screenSize: number,
-	velocityWeight: number,
-) => {
-	"worklet";
-
-	const normalizedTranslation = translationPixels / Math.max(1, screenSize);
-
-	// If translation is essentially zero, velocity alone shouldn't trigger dismissal.
-	// User must have meaningfully moved in the dismiss direction.
-	if (Math.abs(normalizedTranslation) < EPSILON) {
-		return false;
-	}
-
-	const normalizedVelocity = normalizeVelocity(
-		velocityPixelsPerSecond,
-		screenSize,
-	);
-
-	const projectedNormalizedPosition =
-		normalizedTranslation + normalizedVelocity * velocityWeight;
-
-	// The dismiss direction is determined by the sign of the translation.
-	// Multiplying by this sign normalizes the projection so "toward dismiss" is always positive.
-	// This prevents dismissal when the user drags back (opposing velocity flips projection negative).
-	const dismissSign = Math.sign(translationPixels);
-	const projectedInDismissDirection = projectedNormalizedPosition * dismissSign;
-	const exceedsThreshold = projectedInDismissDirection > 0.5;
-
-	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));
-};

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/gesture-snap-points.ts

@@ -1,74 +0,0 @@
-interface ResolveRuntimeSnapPointsProps {
-	snapPoints: number[];
-	hasAutoSnapPoint: boolean;
-	resolvedAutoSnapPoint: number;
-	minSnapPoint: number;
-	maxSnapPoint: number;
-	canDismiss: boolean;
-}
-
-interface ResolvedRuntimeSnapPointsResult {
-	resolvedAutoSnapPoint: number | null;
-	resolvedSnapPoints: number[];
-	resolvedMinSnapPoint: number;
-	resolvedMaxSnapPoint: number;
-}
-
-export const resolveRuntimeSnapPoints = ({
-	snapPoints,
-	hasAutoSnapPoint,
-	resolvedAutoSnapPoint,
-	minSnapPoint,
-	maxSnapPoint,
-	canDismiss,
-}: ResolveRuntimeSnapPointsProps): ResolvedRuntimeSnapPointsResult => {
-	"worklet";
-
-	const nextResolvedAutoSnapPoint =
-		hasAutoSnapPoint && resolvedAutoSnapPoint > 0
-			? resolvedAutoSnapPoint
-			: null;
-
-	const resolvedSnapPoints =
-		nextResolvedAutoSnapPoint === null
-			? snapPoints
-			: [...snapPoints, nextResolvedAutoSnapPoint].sort((a, b) => a - b);
-
-	const resolvedMinSnapPoint =
-		nextResolvedAutoSnapPoint !== null && !canDismiss
-			? Math.min(
-					minSnapPoint === -1 ? nextResolvedAutoSnapPoint : minSnapPoint,
-					nextResolvedAutoSnapPoint,
-				)
-			: minSnapPoint;
-
-	return {
-		resolvedAutoSnapPoint: nextResolvedAutoSnapPoint,
-		resolvedSnapPoints,
-		resolvedMinSnapPoint,
-		resolvedMaxSnapPoint:
-			resolvedSnapPoints[resolvedSnapPoints.length - 1] ?? maxSnapPoint,
-	};
-};
-
-export const findNearestSnapPoint = (
-	progress: number,
-	snapPoints: number[],
-): number => {
-	"worklet";
-
-	let nearest = snapPoints[0] ?? progress;
-	let smallestDistance = Math.abs(progress - nearest);
-
-	for (let i = 1; i < snapPoints.length; i++) {
-		const point = snapPoints[i];
-		const distance = Math.abs(progress - point);
-
-		if (distance < smallestDistance) {
-			smallestDistance = distance;
-			nearest = point;
-		}
-	}
-
-	return nearest;
-};

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

@@ -1,175 +0,0 @@
-import { DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT } from "../../../constants";
-import type { GestureDirections } from "../../../types/gesture.types";
-import { sanitizeSnapPoints } from "../../../utils/gesture/validate-snap-points";
-import { shouldDismissFromTranslationAndVelocity } from "./gesture-physics";
-
-interface GetAxisThresholdProps {
-	translation: number;
-	velocity: number;
-	screenSize: number;
-	gestureVelocityImpact: number;
-}
-
-interface DetermineDismissalProps {
-	event: {
-		translationX: number;
-		translationY: number;
-		velocityX: number;
-		velocityY: number;
-	};
-	directions: GestureDirections;
-	dimensions: { width: number; height: number };
-	gestureVelocityImpact: number;
-}
-
-interface DetermineSnapTargetProps {
-	currentProgress: number;
-	snapPoints: number[];
-	/** Velocity along the snap axis (positive = toward dismiss) */
-	velocity: number;
-	/** Screen dimension along the snap axis (width or height) */
-	dimension: number;
-	/**
-	 * How much velocity affects the snap decision.
-	 * Lower values = more deliberate/iOS-like, higher values = more responsive to flicks.
-	 * @default 0.1
-	 */
-	velocityFactor?: number;
-	/** Whether dismiss (progress=0) is allowed. Default true */
-	canDismiss?: boolean;
-}
-
-interface DetermineSnapTargetResult {
-	targetProgress: number;
-	shouldDismiss: boolean;
-}
-
-const getAxisThreshold = ({
-	translation,
-	velocity,
-	screenSize,
-	gestureVelocityImpact,
-}: GetAxisThresholdProps) => {
-	"worklet";
-	return shouldDismissFromTranslationAndVelocity(
-		translation,
-		velocity,
-		screenSize,
-		gestureVelocityImpact,
-	);
-};
-
-export const determineDismissal = ({
-	event,
-	directions,
-	dimensions,
-	gestureVelocityImpact,
-}: DetermineDismissalProps) => {
-	"worklet";
-
-	let shouldDismiss: boolean = false;
-
-	if (
-		(directions.vertical && event.translationY > 0) ||
-		(directions.verticalInverted && event.translationY < 0)
-	) {
-		const dismiss = getAxisThreshold({
-			translation: event.translationY,
-			velocity: event.velocityY,
-			screenSize: dimensions.height,
-			gestureVelocityImpact,
-		});
-		if (dismiss) shouldDismiss = true;
-	}
-
-	if (
-		(directions.horizontal && event.translationX > 0) ||
-		(directions.horizontalInverted && event.translationX < 0)
-	) {
-		const dismiss = getAxisThreshold({
-			translation: event.translationX,
-			velocity: event.velocityX,
-			screenSize: dimensions.width,
-			gestureVelocityImpact,
-		});
-
-		if (dismiss) shouldDismiss = true;
-	}
-
-	return { shouldDismiss };
-};
-
-/**
- * Determines which snap point to animate to based on current progress and velocity.
- *
- * Logic: Snap to whichever point is closest, factoring in velocity.
- * The "zones" between snap points are split at midpoints.
- * Velocity can push you into the next zone.
- */
-export function determineSnapTarget({
-	currentProgress,
-	snapPoints,
-	velocity,
-	dimension,
-	velocityFactor,
-	canDismiss,
-}: DetermineSnapTargetProps): DetermineSnapTargetResult {
-	"worklet";
-	const resolvedVelocityFactor =
-		velocityFactor ?? DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT;
-	const resolvedCanDismiss = canDismiss ?? true;
-
-	// Convert velocity to progress units (positive = toward dismiss = decreasing progress)
-	const velocityInProgress = (velocity / dimension) * resolvedVelocityFactor;
-
-	// Project where we'd end up with velocity
-	const projectedProgress = currentProgress - velocityInProgress;
-
-	const sanitizedSnapPoints = sanitizeSnapPoints(
-		snapPoints,
-		resolvedCanDismiss,
-	);
-
-	// Build all possible targets: dismiss (0) only if allowed, plus all snap points
-	const allTargets = Array.from(
-		new Set(
-			resolvedCanDismiss ? [0, ...sanitizedSnapPoints] : sanitizedSnapPoints,
-		),
-	).sort((a, b) => a - b);
-
-	if (allTargets.length === 0) {
-		return {
-			targetProgress: currentProgress,
-			shouldDismiss: false,
-		};
-	}
-
-	// Find the target whose zone contains the projected progress
-	// Zones are split at midpoints between adjacent targets
-	let targetProgress = allTargets[0];
-
-	for (let i = 0; i < allTargets.length; i++) {
-		const current = allTargets[i];
-		const next = allTargets[i + 1];
-
-		if (next === undefined) {
-			// Last target - if we're above the midpoint to here, snap to it
-			targetProgress = current;
-			break;
-		}
-
-		const midpoint = (current + next) / 2;
-
-		if (projectedProgress < midpoint) {
-			targetProgress = current;
-			break;
-		}
-
-		targetProgress = next;
-	}
-
-	return {
-		targetProgress,
-		shouldDismiss: resolvedCanDismiss && targetProgress === 0,
-	};
-}