react-native-screen-transitions 4.1.0-alpha.0 → 4.1.0-beta.0

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

@@ -1,338 +0,0 @@
-import type { SnapPoint } from "../../../../types/screen.types";
-import type { GesturePolicy, GestureRuntime } from "../types";
-
-const createEmptySnapPoints = (): EffectiveSnapPointsResult => ({
-	hasSnapPoints: false,
-	hasAutoSnapPoint: false,
-	snapPoints: [],
-	minSnapPoint: -1,
-	maxSnapPoint: -1,
-});
-
-const isNumericSnapPoint = (point: SnapPoint): point is number => {
-	"worklet";
-	return typeof point === "number" && Number.isFinite(point);
-};
-
-const canUseSnapPoint = (point: number, canDismiss: boolean) => {
-	"worklet";
-	return canDismiss || point > 0;
-};
-
-/**
- * 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";
-	const normalized: number[] = [];
-
-	for (let i = 0; i < snapPoints.length; i++) {
-		const point = snapPoints[i];
-		if (!isNumericSnapPoint(point) || !canUseSnapPoint(point, canDismiss)) {
-			continue;
-		}
-
-		normalized.push(point);
-	}
-
-	return normalized;
-}
-
-export interface EffectiveSnapPointsResult {
-	hasSnapPoints: boolean;
-	hasAutoSnapPoint: boolean;
-	snapPoints: number[];
-	minSnapPoint: number;
-	maxSnapPoint: number;
-}
-
-interface ResolveRuntimeSnapPointsProps {
-	snapPoints: number[];
-	hasAutoSnapPoint: boolean;
-	resolvedAutoSnapPoint: number;
-	minSnapPoint: number;
-	maxSnapPoint: number;
-	canDismiss: boolean;
-}
-
-interface ResolvedRuntimeSnapPointsResult {
-	resolvedSnapPoints: number[];
-	resolvedMinSnapPoint: number;
-	resolvedMaxSnapPoint: number;
-}
-
-interface ValidateSnapPointsOptions {
-	snapPoints?: SnapPoint[];
-	canDismiss?: boolean;
-}
-
-const hasRuntimeSnapPoints = (snapPoints: SnapPoint[]) => {
-	return snapPoints.length > 0;
-};
-
-const hasResolvedSnapPoints = (
-	snapPoints: number[],
-	hasAutoSnapPoint: boolean,
-) => {
-	return snapPoints.length > 0 || hasAutoSnapPoint;
-};
-
-const getMinSnapPoint = (snapPoints: number[], canDismiss?: boolean) => {
-	return canDismiss ? 0 : (snapPoints[0] ?? -1);
-};
-
-const getMaxSnapPoint = (snapPoints: number[]) => {
-	return snapPoints[snapPoints.length - 1] ?? -1;
-};
-
-const resolveAutoSnapPoint = (
-	hasAutoSnapPoint: boolean,
-	resolvedAutoSnapPoint: number,
-) => {
-	"worklet";
-	return hasAutoSnapPoint && resolvedAutoSnapPoint > 0
-		? resolvedAutoSnapPoint
-		: null;
-};
-
-const addAutoSnapPoint = (
-	snapPoints: number[],
-	resolvedAutoSnapPoint: number | null,
-) => {
-	"worklet";
-	return resolvedAutoSnapPoint === null
-		? snapPoints
-		: [...snapPoints, resolvedAutoSnapPoint].sort((a, b) => a - b);
-};
-
-const resolveMinSnapPoint = ({
-	minSnapPoint,
-	resolvedAutoSnapPoint,
-	canDismiss,
-}: {
-	minSnapPoint: number;
-	resolvedAutoSnapPoint: number | null;
-	canDismiss: boolean;
-}) => {
-	"worklet";
-	if (resolvedAutoSnapPoint === null || canDismiss) {
-		return minSnapPoint;
-	}
-
-	return Math.min(
-		minSnapPoint === -1 ? resolvedAutoSnapPoint : minSnapPoint,
-		resolvedAutoSnapPoint,
-	);
-};
-
-export const validateSnapPoints = ({
-	snapPoints,
-	canDismiss,
-}: ValidateSnapPointsOptions): EffectiveSnapPointsResult => {
-	if (!snapPoints || !hasRuntimeSnapPoints(snapPoints)) {
-		return createEmptySnapPoints();
-	}
-
-	const hasAuto = snapPoints.includes("auto");
-	const normalizedSnaps = sanitizeSnapPoints(snapPoints, canDismiss ?? false);
-
-	if (!hasResolvedSnapPoints(normalizedSnaps, hasAuto)) {
-		return createEmptySnapPoints();
-	}
-
-	const sortedSnaps = normalizedSnaps.sort((a, b) => a - b);
-
-	return {
-		hasSnapPoints: true,
-		hasAutoSnapPoint: hasAuto,
-		snapPoints: sortedSnaps,
-		minSnapPoint: getMinSnapPoint(sortedSnaps, canDismiss),
-		maxSnapPoint: getMaxSnapPoint(sortedSnaps),
-	};
-};
-
-export const resolveRuntimeSnapPoints = ({
-	snapPoints,
-	hasAutoSnapPoint,
-	resolvedAutoSnapPoint,
-	minSnapPoint,
-	maxSnapPoint,
-	canDismiss,
-}: ResolveRuntimeSnapPointsProps): ResolvedRuntimeSnapPointsResult => {
-	"worklet";
-
-	const resolvedAuto = resolveAutoSnapPoint(
-		hasAutoSnapPoint,
-		resolvedAutoSnapPoint,
-	);
-	const resolvedSnapPoints = addAutoSnapPoint(snapPoints, resolvedAuto);
-
-	return {
-		resolvedSnapPoints,
-		resolvedMinSnapPoint: resolveMinSnapPoint({
-			minSnapPoint,
-			resolvedAutoSnapPoint: resolvedAuto,
-			canDismiss,
-		}),
-		resolvedMaxSnapPoint:
-			resolvedSnapPoints[resolvedSnapPoints.length - 1] ?? maxSnapPoint,
-	};
-};
-
-export const resolveRuntimeGestureSnapPoints = (
-	runtime: GestureRuntime<GesturePolicy>,
-): ResolvedRuntimeSnapPointsResult => {
-	"worklet";
-	const {
-		participation,
-		stores: { system },
-	} = runtime;
-	const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-		participation.effectiveSnapPoints;
-
-	return resolveRuntimeSnapPoints({
-		snapPoints,
-		hasAutoSnapPoint,
-		resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-		minSnapPoint,
-		maxSnapPoint,
-		canDismiss: participation.canDismiss,
-	});
-};
-
-export const resolveRuntimeGestureSnapTargets = (
-	runtime: GestureRuntime<GesturePolicy>,
-): number[] => {
-	"worklet";
-	const { resolvedSnapPoints } = resolveRuntimeGestureSnapPoints(runtime);
-	const targets = runtime.participation.canDismiss
-		? [0, ...resolvedSnapPoints]
-		: resolvedSnapPoints;
-
-	return Array.from(new Set(targets)).sort((a, b) => a - b);
-};
-
-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;
-};
-
-const findNearestSnapPointIndex = (
-	progress: number,
-	snapPoints: number[],
-): number => {
-	"worklet";
-	let nearestIndex = 0;
-	let smallestDistance = Math.abs(progress - (snapPoints[0] ?? progress));
-
-	for (let i = 1; i < snapPoints.length; i++) {
-		const distance = Math.abs(progress - snapPoints[i]);
-		if (distance < smallestDistance) {
-			smallestDistance = distance;
-			nearestIndex = i;
-		}
-	}
-
-	return nearestIndex;
-};
-
-interface ResolveStepSnapProps {
-	baseline: number;
-	direction: number;
-	snapPoints: number[];
-}
-
-export const resolveStepSnapTargets = ({
-	baseline,
-	direction,
-	snapPoints,
-}: ResolveStepSnapProps): number[] => {
-	"worklet";
-	if (snapPoints.length === 0) {
-		return [baseline];
-	}
-
-	const baselineIndex = findNearestSnapPointIndex(baseline, snapPoints);
-	const start = snapPoints[baselineIndex] ?? baseline;
-	const adjacentIndex = baselineIndex + Math.sign(direction);
-	const adjacent = snapPoints[adjacentIndex];
-
-	if (direction === 0 || adjacent === undefined) {
-		return [start];
-	}
-
-	return direction < 0 ? [adjacent, start] : [start, adjacent];
-};
-
-export const resolveStepSnapProgress = ({
-	baseline,
-	normalizedDelta,
-	snapPoints,
-}: Omit<ResolveStepSnapProps, "direction"> & {
-	normalizedDelta: number;
-}): number => {
-	"worklet";
-	const targets = resolveStepSnapTargets({
-		baseline,
-		direction: normalizedDelta,
-		snapPoints,
-	});
-	const target = normalizedDelta < 0 ? targets[0] : targets[targets.length - 1];
-	const localProgress = Math.min(1, Math.abs(normalizedDelta));
-
-	return baseline + (target - baseline) * localProgress;
-};
-
-export const getStepSnapProgressVelocityScale = (targets: number[]): number => {
-	"worklet";
-	if (targets.length < 2) {
-		return 0;
-	}
-
-	return Math.abs(targets[targets.length - 1] - targets[0]);
-};
-
-export const primeRuntimeSnapPoint = (
-	runtime: GestureRuntime<GesturePolicy>,
-) => {
-	"worklet";
-	const {
-		policy,
-		stores: { animations, gestures },
-	} = runtime;
-
-	const { resolvedSnapPoints } = resolveRuntimeGestureSnapPoints(runtime);
-
-	if (policy.gestureSnapLocked) {
-		gestures.internal.lockedSnapPoint.set(
-			findNearestSnapPoint(
-				animations.transitionProgress.get(),
-				resolvedSnapPoints,
-			),
-		);
-		return;
-	}
-
-	gestures.internal.lockedSnapPoint.set(null);
-};

package/src/providers/screen/gestures/shared/snapshot.ts

@@ -1,34 +0,0 @@
-import type { GestureStoreMap } from "../../../../stores/gesture.store";
-
-type SnapshotGestureHandoffOptions = {
-	velocity?: number;
-};
-
-export const snapshotGestureHandoff = (
-	gestures: GestureStoreMap,
-	options?: SnapshotGestureHandoffOptions,
-) => {
-	"worklet";
-	const snapshot = gestures.internal.snapshot;
-
-	snapshot.x.set(gestures.x.get());
-	snapshot.y.set(gestures.y.get());
-	snapshot.normX.set(gestures.normX.get());
-	snapshot.normY.set(gestures.normY.get());
-	snapshot.velocity.set(options?.velocity ?? gestures.velocity.get());
-	snapshot.scale.set(gestures.scale.get());
-	snapshot.normScale.set(gestures.normScale.get());
-	snapshot.focalX.set(gestures.focalX.get());
-	snapshot.focalY.set(gestures.focalY.get());
-	snapshot.pinchOriginX.set(gestures.pinchOriginX.get());
-	snapshot.pinchOriginY.set(gestures.pinchOriginY.get());
-	snapshot.rotation.set(gestures.rotation.get());
-	snapshot.raw.x.set(gestures.raw.x.get());
-	snapshot.raw.y.set(gestures.raw.y.get());
-	snapshot.raw.normX.set(gestures.raw.normX.get());
-	snapshot.raw.normY.set(gestures.raw.normY.get());
-	snapshot.raw.scale.set(gestures.raw.scale.get());
-	snapshot.raw.normScale.set(gestures.raw.normScale.get());
-	snapshot.raw.rotation.set(gestures.raw.rotation.get());
-	snapshot.active.set(gestures.initiator.get());
-};

package/src/providers/screen/gestures/shared/targets.ts

@@ -1,202 +0,0 @@
-import { DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT } from "../../../../constants";
-import type { GestureDirections } from "../../../../types/gesture.types";
-import { shouldDismissFromProjection } from "./physics";
-import { sanitizeSnapPoints } from "./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;
-}
-
-const isMovingTowardDismiss = (
-	positiveDirectionEnabled: boolean,
-	negativeDirectionEnabled: boolean,
-	translation: number,
-) => {
-	"worklet";
-	return (
-		(positiveDirectionEnabled && translation > 0) ||
-		(negativeDirectionEnabled && translation < 0)
-	);
-};
-
-const shouldDismissAlongAxis = ({
-	positiveDirectionEnabled,
-	negativeDirectionEnabled,
-	translation,
-	velocity,
-	dimension,
-	gestureVelocityImpact,
-}: {
-	positiveDirectionEnabled: boolean;
-	negativeDirectionEnabled: boolean;
-	translation: number;
-	velocity: number;
-	dimension: number;
-	gestureVelocityImpact: number;
-}) => {
-	"worklet";
-	return (
-		isMovingTowardDismiss(
-			positiveDirectionEnabled,
-			negativeDirectionEnabled,
-			translation,
-		) &&
-		shouldDismissFromProjection(
-			translation,
-			velocity,
-			dimension,
-			gestureVelocityImpact,
-		)
-	);
-};
-
-export const determineDismissal = ({
-	event,
-	directions,
-	dimensions,
-	gestureVelocityImpact,
-}: DetermineDismissalProps) => {
-	"worklet";
-
-	const verticalDismiss = shouldDismissAlongAxis({
-		positiveDirectionEnabled: directions.vertical,
-		negativeDirectionEnabled: directions.verticalInverted,
-		translation: event.translationY,
-		velocity: event.velocityY,
-		dimension: dimensions.height,
-		gestureVelocityImpact,
-	});
-	const horizontalDismiss = shouldDismissAlongAxis({
-		positiveDirectionEnabled: directions.horizontal,
-		negativeDirectionEnabled: directions.horizontalInverted,
-		translation: event.translationX,
-		velocity: event.velocityX,
-		dimension: dimensions.width,
-		gestureVelocityImpact,
-	});
-
-	return { shouldDismiss: verticalDismiss || horizontalDismiss };
-};
-
-const buildSnapTargetList = (snapPoints: number[], canDismiss: boolean) => {
-	"worklet";
-	const sanitizedSnapPoints = sanitizeSnapPoints(snapPoints, canDismiss);
-	const targets = canDismiss
-		? [0, ...sanitizedSnapPoints]
-		: sanitizedSnapPoints;
-
-	return Array.from(new Set(targets)).sort((a, b) => a - b);
-};
-
-const projectSnapProgress = (
-	currentProgress: number,
-	velocity: number,
-	dimension: number,
-	velocityFactor: number,
-) => {
-	"worklet";
-	// Convert velocity to progress units (positive = toward dismiss = decreasing progress)
-	const velocityInProgress = (velocity / dimension) * velocityFactor;
-	return currentProgress - velocityInProgress;
-};
-
-const findTargetForProjectedProgress = (
-	projectedProgress: number,
-	targets: number[],
-) => {
-	"worklet";
-	let targetProgress = targets[0];
-
-	for (let i = 0; i < targets.length; i++) {
-		const current = targets[i];
-		const next = targets[i + 1];
-
-		if (next === undefined) {
-			return current;
-		}
-
-		const midpoint = (current + next) / 2;
-
-		if (projectedProgress < midpoint) {
-			return current;
-		}
-
-		targetProgress = next;
-	}
-
-	return targetProgress;
-};
-
-/**
- * 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;
-	const allTargets = buildSnapTargetList(snapPoints, resolvedCanDismiss);
-
-	if (allTargets.length === 0) {
-		return {
-			targetProgress: currentProgress,
-			shouldDismiss: false,
-		};
-	}
-
-	const targetProgress = findTargetForProjectedProgress(
-		projectSnapProgress(
-			currentProgress,
-			velocity,
-			dimension,
-			resolvedVelocityFactor,
-		),
-		allTargets,
-	);
-
-	return {
-		targetProgress,
-		shouldDismiss: resolvedCanDismiss && targetProgress === 0,
-	};
-}

package/src/providers/screen/gestures/shared/values.ts

@@ -1,54 +0,0 @@
-import type { GestureStoreMap } from "../../../../stores/gesture.store";
-
-export const clearRawPanValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.raw.x.set(0);
-	gestures.raw.y.set(0);
-	gestures.raw.normX.set(0);
-	gestures.raw.normY.set(0);
-};
-
-export const clearPanProgressDeltaValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.internal.progressDeltaX.set(0);
-	gestures.internal.progressDeltaY.set(0);
-};
-
-export const clearPanProgressValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.x.set(0);
-	gestures.y.set(0);
-	gestures.normX.set(0);
-	gestures.normY.set(0);
-	clearPanProgressDeltaValues(gestures);
-};
-
-export const clearPanTrackingValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	clearPanProgressValues(gestures);
-	clearRawPanValues(gestures);
-	gestures.velocity.set(0);
-};
-
-export const clearFocalPoint = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.focalX.set(0);
-	gestures.focalY.set(0);
-	gestures.pinchOriginX.set(0);
-	gestures.pinchOriginY.set(0);
-};
-
-export const clearRawTransformValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.raw.scale.set(1);
-	gestures.raw.normScale.set(0);
-	gestures.raw.rotation.set(0);
-};
-
-export const clearTransformTrackingValues = (gestures: GestureStoreMap) => {
-	"worklet";
-	gestures.scale.set(1);
-	gestures.normScale.set(0);
-	gestures.rotation.set(0);
-	clearRawTransformValues(gestures);
-};