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

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,
-	};
-};

package/src/shared/providers/screen/gestures/ownership/should-defer-to-child-claim.ts

@@ -1,15 +0,0 @@
-import type { DirectionClaim } from "../types";
-
-/**
- * Returns true when the current screen should fail and defer to a child claim.
- */
-export function shouldDeferToChildClaim(
-	childClaim: DirectionClaim,
-	selfRouteKey: string,
-): boolean {
-	"worklet";
-	if (!childClaim) return false;
-	if (childClaim.routeKey === selfRouteKey) return false;
-	if (childClaim.isDismissing.get()) return false;
-	return true;
-}

package/src/shared/providers/scroll-settle.provider.tsx

@@ -1,24 +0,0 @@
-import type { ReactNode } from "react";
-import type { SharedValue } from "react-native-reanimated";
-import createProvider from "../utils/create-provider";
-
-interface ScrollSettleProviderProps {
-	settledSignal: SharedValue<number>;
-	children: ReactNode;
-}
-
-interface ScrollSettleContextValue {
-	settledSignal: SharedValue<number>;
-}
-
-const { ScrollSettleProvider, useScrollSettleContext } = createProvider(
-	"ScrollSettle",
-	{ guarded: false },
-)<ScrollSettleProviderProps, ScrollSettleContextValue>(
-	({ settledSignal, children }) => ({
-		value: { settledSignal },
-		children,
-	}),
-);
-
-export { ScrollSettleProvider, useScrollSettleContext };