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

package/src/shared/providers/screen/gestures/behaviors/strategies/pinch.strategy.ts

@@ -1,73 +0,0 @@
-import { clamp } from "react-native-reanimated";
-import {
-	getPinchReleaseHandoffVelocity,
-	normalizePinchScale,
-	shouldDismissFromPinch,
-} from "../../helpers/gesture-physics";
-import type { PinchBehaviorStrategy } from "../../types";
-
-export const PinchStrategy: PinchBehaviorStrategy = {
-	primeStart(_runtime) {
-		"worklet";
-	},
-
-	resolveProgress(runtime, track) {
-		"worklet";
-		const { policy, gestureProgressBaseline } = runtime;
-		const { normScale } = track;
-
-		const progressDelta =
-			(normScale < 0 && policy.pinchInEnabled) ||
-			(normScale > 0 && policy.pinchOutEnabled)
-				? Math.abs(normScale)
-				: 0;
-
-		return clamp(
-			gestureProgressBaseline.get() - progressDelta,
-			0,
-			gestureProgressBaseline.get(),
-		);
-	},
-
-	resolveRelease(event, runtime) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			gestureProgressBaseline,
-			stores: { animations },
-		} = runtime;
-		const normalizedScale = clamp(normalizePinchScale(event.scale), -1, 1);
-		const currentProgress = animations.progress.get();
-		const shouldDismiss =
-			participation.canDismiss &&
-			shouldDismissFromPinch(
-				normalizedScale,
-				policy.pinchInEnabled,
-				policy.pinchOutEnabled,
-			);
-		const target = shouldDismiss ? 0 : gestureProgressBaseline.get();
-		const progressDirection = Math.sign(target - currentProgress);
-		const initialVelocity =
-			progressDirection === 0
-				? 0
-				: progressDirection *
-					Math.abs(
-						getPinchReleaseHandoffVelocity(
-							event.velocity,
-							policy.gestureReleaseVelocityScale,
-							policy.gestureReleaseVelocityMax,
-						),
-					);
-
-		return {
-			target,
-			shouldDismiss,
-			initialVelocity,
-			transitionSpec: policy.transitionSpec,
-			resetSpec: shouldDismiss
-				? policy.transitionSpec?.close
-				: policy.transitionSpec?.open,
-		};
-	},
-};

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

@@ -1,158 +0,0 @@
-import type { SharedValue } from "react-native-reanimated";
-import { EPSILON, FALSE, TRUE } from "../../../../constants";
-import type { GestureStoreMap } from "../../../../stores/gesture.store";
-import type { AnimationConfig } from "../../../../types/animation.types";
-import { animate } from "../../../../utils/animation/animate";
-
-interface ResetGestureValuesProps {
-	spec?: AnimationConfig;
-	gestures: GestureStoreMap;
-	shouldDismiss: boolean;
-	velocityX?: number;
-	velocityY?: number;
-	velocityNormX?: number;
-	velocityNormY?: number;
-}
-
-const getGestureResetSpec = (
-	spec?: AnimationConfig,
-	velocity?: number,
-): AnimationConfig | undefined => {
-	"worklet";
-
-	const isSpring =
-		typeof spec === "object" && !("duration" in spec) && !("easing" in spec);
-
-	if (!isSpring) {
-		return spec;
-	}
-
-	const { velocity: _velocity, ...resetSpec } = spec as AnimationConfig & {
-		velocity?: number;
-	};
-	return (
-		typeof velocity === "number" ? { ...resetSpec, velocity } : resetSpec
-	) as AnimationConfig;
-};
-
-const animateResetValue = (
-	value: SharedValue<number>,
-	toValue: number,
-	config: AnimationConfig | undefined,
-	onFinished: () => void,
-) => {
-	"worklet";
-	value.set(
-		animate(toValue, config, (finished) => {
-			"worklet";
-			if (finished) {
-				onFinished();
-			}
-		}),
-	);
-};
-
-const clearPanSettlingIfResting = (gestures: GestureStoreMap) => {
-	"worklet";
-
-	if (
-		gestures.dragging.get() ||
-		gestures.dismissing.get() ||
-		Math.abs(gestures.x.get()) > EPSILON ||
-		Math.abs(gestures.y.get()) > EPSILON ||
-		Math.abs(gestures.normX.get()) > EPSILON ||
-		Math.abs(gestures.normY.get()) > EPSILON
-	) {
-		return;
-	}
-
-	gestures.active.set(null);
-	gestures.direction.set(null);
-	gestures.settling.set(FALSE);
-};
-
-const clearPinchSettlingIfResting = (gestures: GestureStoreMap) => {
-	"worklet";
-
-	if (
-		gestures.dragging.get() ||
-		gestures.dismissing.get() ||
-		Math.abs(gestures.scale.get() - 1) > EPSILON ||
-		Math.abs(gestures.normScale.get()) > EPSILON
-	) {
-		return;
-	}
-
-	gestures.focalX.set(0);
-	gestures.focalY.set(0);
-	gestures.active.set(null);
-	gestures.direction.set(null);
-	gestures.settling.set(FALSE);
-};
-
-export const resetGestureValues = ({
-	spec,
-	gestures,
-	shouldDismiss,
-	velocityX,
-	velocityY,
-	velocityNormX,
-	velocityNormY,
-}: ResetGestureValuesProps) => {
-	"worklet";
-
-	gestures.raw.x.set(0);
-	gestures.raw.y.set(0);
-	gestures.raw.normX.set(0);
-	gestures.raw.normY.set(0);
-	gestures.dragging.set(FALSE);
-	gestures.dismissing.set(shouldDismiss ? TRUE : FALSE);
-	gestures.settling.set(shouldDismiss ? FALSE : TRUE);
-
-	animateResetValue(gestures.x, 0, getGestureResetSpec(spec, velocityX), () =>
-		clearPanSettlingIfResting(gestures),
-	);
-	animateResetValue(gestures.y, 0, getGestureResetSpec(spec, velocityY), () =>
-		clearPanSettlingIfResting(gestures),
-	);
-	animateResetValue(
-		gestures.normX,
-		0,
-		getGestureResetSpec(spec, velocityNormX),
-		() => clearPanSettlingIfResting(gestures),
-	);
-	animateResetValue(
-		gestures.normY,
-		0,
-		getGestureResetSpec(spec, velocityNormY),
-		() => clearPanSettlingIfResting(gestures),
-	);
-};
-
-interface ResetPinchGestureValuesProps {
-	spec?: AnimationConfig;
-	gestures: GestureStoreMap;
-	shouldDismiss: boolean;
-}
-
-export const resetPinchGestureValues = ({
-	spec,
-	gestures,
-	shouldDismiss,
-}: ResetPinchGestureValuesProps) => {
-	"worklet";
-	const resetSpec = getGestureResetSpec(spec);
-
-	gestures.raw.scale.set(1);
-	gestures.raw.normScale.set(0);
-	gestures.dragging.set(FALSE);
-	gestures.dismissing.set(shouldDismiss ? TRUE : FALSE);
-	gestures.settling.set(shouldDismiss ? FALSE : TRUE);
-
-	animateResetValue(gestures.scale, 1, resetSpec, () =>
-		clearPinchSettlingIfResting(gestures),
-	);
-	animateResetValue(gestures.normScale, 0, resetSpec, () =>
-		clearPinchSettlingIfResting(gestures),
-	);
-};

package/src/shared/providers/screen/gestures/helpers/gesture-snap-points.ts

@@ -1,72 +0,0 @@
-interface ResolveRuntimeSnapPointsProps {
-	snapPoints: number[];
-	hasAutoSnapPoint: boolean;
-	resolvedAutoSnapPoint: number;
-	minSnapPoint: number;
-	maxSnapPoint: number;
-	canDismiss: boolean;
-}
-
-interface ResolvedRuntimeSnapPointsResult {
-	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 {
-		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/screen/gestures/helpers/gesture-targets.ts

@@ -1,153 +0,0 @@
-import { DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT } from "../../../../constants";
-import type { GestureDirections } from "../../../../types/gesture.types";
-import { shouldDismissFromProjection } from "./gesture-physics";
-import { sanitizeSnapPoints } from "./validate-snap-points";
-
-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;
-}
-
-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 = shouldDismissFromProjection(
-			event.translationY,
-			event.velocityY,
-			dimensions.height,
-			gestureVelocityImpact,
-		);
-		if (dismiss) shouldDismiss = true;
-	}
-
-	if (
-		(directions.horizontal && event.translationX > 0) ||
-		(directions.horizontalInverted && event.translationX < 0)
-	) {
-		const dismiss = shouldDismissFromProjection(
-			event.translationX,
-			event.velocityX,
-			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,
-	};
-}

package/src/shared/providers/screen/gestures/helpers/resolve-can-track-gesture.ts

@@ -1,23 +0,0 @@
-export type GestureTrackingParticipationInput = {
-	isFirstKey: boolean;
-	canDismiss: boolean;
-	hasSnapPoints: boolean;
-	allowDisabledGestureTracking?: boolean;
-};
-
-export function resolveCanTrackGesture({
-	isFirstKey,
-	canDismiss,
-	hasSnapPoints,
-	allowDisabledGestureTracking,
-}: GestureTrackingParticipationInput) {
-	if (isFirstKey) {
-		return false;
-	}
-
-	if (allowDisabledGestureTracking) {
-		return true;
-	}
-
-	return canDismiss || hasSnapPoints;
-}

package/src/shared/providers/screen/gestures/helpers/runtime-options.ts

@@ -1,159 +0,0 @@
-import type { ScreenOptionsSnapshot } from "../../options";
-import type {
-	PanGesturePolicy,
-	PanGestureRuntime,
-	PinchGesturePolicy,
-	PinchGestureRuntime,
-} from "../types";
-import {
-	getPanActivationDirections,
-	getPanGestureDirections,
-	getPanSnapAxisDirections,
-	getPinchGestureDirections,
-	getSnapPinchDirectionConfig,
-} from "./gesture-directions";
-
-export const resolveRuntimeCanTrackGesture = (
-	runtime: PanGestureRuntime | PinchGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-) => {
-	"worklet";
-	const { participation } = runtime;
-
-	if (participation.isFirstKey) {
-		return false;
-	}
-
-	if (screenOptions.experimental_allowDisabledGestureTracking === true) {
-		return true;
-	}
-
-	const gestureEnabled = screenOptions.gestureEnabled;
-	if (gestureEnabled === true) {
-		return true;
-	}
-
-	if (gestureEnabled === false) {
-		return participation.effectiveSnapPoints.hasSnapPoints;
-	}
-
-	return participation.canTrackGesture;
-};
-
-export const resolveRuntimeCanDismiss = (
-	runtime: PanGestureRuntime | PinchGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-) => {
-	"worklet";
-	const { participation } = runtime;
-
-	if (participation.isFirstKey) {
-		return false;
-	}
-
-	const gestureEnabled = screenOptions.gestureEnabled;
-	if (gestureEnabled === false) {
-		return false;
-	}
-
-	if (gestureEnabled === true) {
-		return true;
-	}
-
-	return participation.canDismiss;
-};
-
-export const resolvePanRuntimePolicy = (
-	runtime: PanGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-): PanGesturePolicy => {
-	"worklet";
-	const { policy, participation } = runtime;
-	const gestureDirection = screenOptions.gestureDirection;
-	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;
-
-	return {
-		...policy,
-		enabled: getPanGestureDirections(gestureDirection).length > 0,
-		gestureDirection,
-		panActivationDirections: getPanActivationDirections({
-			gestureDirection,
-			hasSnapPoints,
-		}),
-		snapAxisDirections: getPanSnapAxisDirections(gestureDirection),
-		gestureDrivesProgress: screenOptions.gestureDrivesProgress,
-		gestureSensitivity: screenOptions.gestureSensitivity,
-		gestureVelocityImpact: screenOptions.gestureVelocityImpact,
-		gestureSnapVelocityImpact: screenOptions.gestureSnapVelocityImpact,
-		gestureReleaseVelocityScale: screenOptions.gestureReleaseVelocityScale,
-		gestureResponseDistance: screenOptions.gestureResponseDistance,
-		gestureActivationArea: screenOptions.gestureActivationArea,
-		gestureSnapLocked: screenOptions.gestureSnapLocked,
-		sheetScrollGestureBehavior: screenOptions.sheetScrollGestureBehavior,
-	};
-};
-
-export const resolvePinchRuntimePolicy = (
-	runtime: PinchGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-): PinchGesturePolicy => {
-	"worklet";
-	const { policy, participation } = runtime;
-	const gestureDirection = screenOptions.gestureDirection;
-	const pinchDirections = getPinchGestureDirections(gestureDirection);
-	const snapDirections = participation.effectiveSnapPoints.hasSnapPoints
-		? getSnapPinchDirectionConfig(gestureDirection)
-		: null;
-	const pinchInEnabled = snapDirections
-		? true
-		: pinchDirections.includes("pinch-in");
-	const pinchOutEnabled = snapDirections
-		? true
-		: pinchDirections.includes("pinch-out");
-
-	return {
-		...policy,
-		enabled: pinchInEnabled || pinchOutEnabled,
-		gestureDirection,
-		snapDirections,
-		pinchInEnabled,
-		pinchOutEnabled,
-		gestureDrivesProgress: screenOptions.gestureDrivesProgress,
-		gestureSensitivity: screenOptions.gestureSensitivity,
-		gestureSnapVelocityImpact: screenOptions.gestureSnapVelocityImpact,
-		gestureReleaseVelocityScale: screenOptions.gestureReleaseVelocityScale,
-		gestureSnapLocked: screenOptions.gestureSnapLocked,
-	};
-};
-
-export const resolvePanRuntime = (
-	runtime: PanGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-): PanGestureRuntime => {
-	"worklet";
-	return {
-		...runtime,
-		participation: {
-			...runtime.participation,
-			canDismiss: resolveRuntimeCanDismiss(runtime, screenOptions),
-			canTrackGesture: resolveRuntimeCanTrackGesture(runtime, screenOptions),
-		},
-		policy: resolvePanRuntimePolicy(runtime, screenOptions),
-	};
-};
-
-export const resolvePinchRuntime = (
-	runtime: PinchGestureRuntime,
-	screenOptions: ScreenOptionsSnapshot,
-): PinchGestureRuntime => {
-	"worklet";
-	return {
-		...runtime,
-		participation: {
-			...runtime.participation,
-			canDismiss: resolveRuntimeCanDismiss(runtime, screenOptions),
-			canTrackGesture: resolveRuntimeCanTrackGesture(runtime, screenOptions),
-		},
-		policy: resolvePinchRuntimePolicy(runtime, screenOptions),
-	};
-};

package/src/shared/providers/screen/gestures/helpers/validate-snap-points.ts

@@ -1,74 +0,0 @@
-import type { SnapPoint } from "../../../../types/screen.types";
-
-/**
- * Filters snap points to only valid, finite numeric values.
- * Excludes zero (dismiss) when canDismiss is false.
- */
-export function sanitizeSnapPoints(
-	snapPoints: SnapPoint[],
-	canDismiss: boolean,
-): number[] {
-	"worklet";
-	return snapPoints.filter(
-		(point): point is number =>
-			typeof point === "number" &&
-			(canDismiss
-				? Number.isFinite(point)
-				: Number.isFinite(point) && point > 0),
-	);
-}
-
-export interface EffectiveSnapPointsResult {
-	hasSnapPoints: boolean;
-	hasAutoSnapPoint: boolean;
-	snapPoints: number[];
-	minSnapPoint: number;
-	maxSnapPoint: number;
-}
-
-interface ValidateSnapPointsOptions {
-	snapPoints?: SnapPoint[];
-	canDismiss?: boolean;
-}
-
-export const validateSnapPoints = ({
-	snapPoints,
-	canDismiss,
-}: ValidateSnapPointsOptions): EffectiveSnapPointsResult => {
-	if (!snapPoints || snapPoints.length === 0) {
-		return {
-			hasSnapPoints: false,
-			hasAutoSnapPoint: false,
-			snapPoints: [],
-			minSnapPoint: -1,
-			maxSnapPoint: -1,
-		};
-	}
-
-	const hasAuto = snapPoints.includes("auto");
-	const normalizedSnaps = sanitizeSnapPoints(snapPoints, canDismiss ?? false);
-
-	// hasSnapPoints is true if there are valid numeric points OR an 'auto' point
-	if (normalizedSnaps.length === 0 && !hasAuto) {
-		return {
-			hasSnapPoints: false,
-			hasAutoSnapPoint: false,
-			snapPoints: [],
-			minSnapPoint: -1,
-			maxSnapPoint: -1,
-		};
-	}
-
-	const sortedSnaps = normalizedSnaps.slice().sort((a, b) => a - b);
-	// Clamp to snap point bounds (dismiss at 0 only if allowed)
-	const minProgress = canDismiss ? 0 : (sortedSnaps[0] ?? -1);
-	const maxProgress = sortedSnaps[sortedSnaps.length - 1] ?? -1;
-
-	return {
-		hasSnapPoints: true,
-		hasAutoSnapPoint: hasAuto,
-		snapPoints: sortedSnaps,
-		minSnapPoint: minProgress,
-		maxSnapPoint: maxProgress,
-	};
-};