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

package/src/shared/providers/screen/gestures/activation/use-pan-activation.ts

@@ -1,244 +0,0 @@
-import { useCallback, useMemo } from "react";
-import type {
-	GestureStateManager,
-	GestureTouchEvent,
-} from "react-native-gesture-handler";
-import { type SharedValue, useSharedValue } from "react-native-reanimated";
-import { EPSILON } from "../../../../constants";
-import { GestureStore } from "../../../../stores/gesture.store";
-import { GestureActivationState } from "../../../../types/gesture.types";
-import type { Direction } from "../../../../types/ownership.types";
-import { useDescriptorDerivations } from "../../descriptors";
-import type { ScreenOptionsContextValue } from "../../options";
-import {
-	applyOffsetRules,
-	checkScrollBoundary,
-} from "../helpers/gesture-activation";
-import { getPanSnapAxisConfigForDirection } from "../helpers/gesture-directions";
-import { resolveRuntimeSnapPoints } from "../helpers/gesture-snap-points";
-import { resolvePanRuntime } from "../helpers/runtime-options";
-import { shouldDeferToChildClaim } from "../ownership/should-defer-to-child-claim";
-import type {
-	DirectionClaimMap,
-	GestureDimensions,
-	PanGestureRuntime,
-	ScrollGestureState,
-} from "../types";
-
-interface UsePanActivationProps {
-	scrollState: SharedValue<ScrollGestureState | null>;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
-	runtime: SharedValue<PanGestureRuntime>;
-	screenOptions: ScreenOptionsContextValue;
-	dimensions: GestureDimensions;
-}
-
-export const usePanActivation = ({
-	scrollState,
-	childDirectionClaims,
-	runtime,
-	screenOptions,
-	dimensions,
-}: UsePanActivationProps) => {
-	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
-
-	const ancestorDismissing = useMemo(() => {
-		if (!parentScreenKey) return null;
-		return GestureStore.peekBag(parentScreenKey)?.dismissing ?? null;
-	}, [parentScreenKey]);
-
-	const initialTouch = useSharedValue({ x: 0, y: 0 });
-
-	const gestureActivationState = useSharedValue<GestureActivationState>(
-		GestureActivationState.PENDING,
-	);
-
-	const onTouchesDown = useCallback(
-		(
-			event: GestureTouchEvent,
-			stateManager: GestureStateManager | undefined,
-		) => {
-			"worklet";
-			const { participation, policy } = resolvePanRuntime(
-				runtime.get(),
-				screenOptions.get(),
-			);
-
-			if (
-				!participation.canTrackGesture ||
-				!policy.enabled ||
-				event.numberOfTouches !== 1
-			) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager?.fail();
-				return;
-			}
-
-			const firstTouch = event.changedTouches[0];
-			initialTouch.set({ x: firstTouch.x, y: firstTouch.y });
-			gestureActivationState.set(GestureActivationState.PENDING);
-		},
-		[gestureActivationState, initialTouch, runtime, screenOptions],
-	);
-
-	const onTouchesMove = useCallback(
-		(event: GestureTouchEvent, stateManager: GestureStateManager) => {
-			"worklet";
-
-			if (event.numberOfTouches !== 1) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			if (ancestorDismissing?.get()) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			const {
-				participation,
-				policy,
-				stores: { animations, gestures, system },
-			} = resolvePanRuntime(runtime.get(), screenOptions.get());
-			const {
-				hasSnapPoints,
-				hasAutoSnapPoint,
-				snapPoints,
-				minSnapPoint,
-				maxSnapPoint,
-			} = participation.effectiveSnapPoints;
-
-			if (!participation.canTrackGesture || !policy.enabled) {
-				gestureActivationState.set(GestureActivationState.FAILED);
-				stateManager.fail();
-				return;
-			}
-
-			const touch = event.changedTouches[0];
-
-			const { isSwipingDown, isSwipingUp, isSwipingRight, isSwipingLeft } =
-				applyOffsetRules({
-					touch,
-					directions: policy.panActivationDirections,
-					dimensions,
-					gestureActivationState,
-					initialTouch: initialTouch.get(),
-					activationArea: policy.gestureActivationArea,
-					responseDistance: policy.gestureResponseDistance,
-				});
-
-			if (gestureActivationState.get() === GestureActivationState.FAILED) {
-				stateManager.fail();
-				return;
-			}
-
-			if (gestures.dragging.get()) {
-				stateManager.activate();
-				return;
-			}
-
-			let swipeDirection: Direction | null = null;
-			if (isSwipingDown) swipeDirection = "vertical";
-			else if (isSwipingUp) swipeDirection = "vertical-inverted";
-			else if (isSwipingRight) swipeDirection = "horizontal";
-			else if (isSwipingLeft) swipeDirection = "horizontal-inverted";
-
-			if (!swipeDirection) {
-				return;
-			}
-
-			if (participation.ownershipStatus[swipeDirection] !== "self") {
-				stateManager.fail();
-				return;
-			}
-
-			// A nested screen shadowing this direction gets priority while it is active.
-			const childClaim = childDirectionClaims.get()[swipeDirection];
-			if (shouldDeferToChildClaim(childClaim, currentScreenKey)) {
-				stateManager.fail();
-				return;
-			}
-
-			if (gestureActivationState.get() !== GestureActivationState.PASSED) {
-				return;
-			}
-
-			const activeSnapAxis = hasSnapPoints
-				? getPanSnapAxisConfigForDirection(
-						policy.snapAxisDirections,
-						swipeDirection,
-					)
-				: null;
-			const isExpandGesture = activeSnapAxis?.config.expand === swipeDirection;
-
-			if (hasSnapPoints && policy.gestureSnapLocked && isExpandGesture) {
-				stateManager.fail();
-				return;
-			}
-
-			if (!hasSnapPoints && gestures.dismissing.get()) {
-				return;
-			}
-
-			const currentScrollState = scrollState.get();
-			const isTouchingScrollView = currentScrollState?.isTouched ?? false;
-
-			if (isTouchingScrollView) {
-				const atBoundary = checkScrollBoundary(
-					currentScrollState,
-					swipeDirection,
-					activeSnapAxis?.config.inverted,
-				);
-
-				if (!atBoundary) {
-					stateManager.fail();
-					return;
-				}
-
-				if (hasSnapPoints && isExpandGesture) {
-					if (policy.sheetScrollGestureBehavior === "collapse-only") {
-						stateManager.fail();
-						return;
-					}
-
-					const { resolvedMaxSnapPoint } = resolveRuntimeSnapPoints({
-						snapPoints,
-						hasAutoSnapPoint,
-						resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-						minSnapPoint,
-						maxSnapPoint,
-						canDismiss: participation.canDismiss,
-					});
-
-					const canExpandMore =
-						animations.progress.get() < resolvedMaxSnapPoint - EPSILON &&
-						system.targetProgress.get() < resolvedMaxSnapPoint - EPSILON;
-
-					if (!canExpandMore) {
-						stateManager.fail();
-						return;
-					}
-				}
-			}
-
-			gestures.active.set(swipeDirection);
-			gestures.direction.set(swipeDirection);
-			stateManager.activate();
-		},
-		[
-			ancestorDismissing,
-			childDirectionClaims,
-			currentScreenKey,
-			dimensions,
-			gestureActivationState,
-			initialTouch,
-			runtime,
-			screenOptions,
-			scrollState,
-		],
-	);
-
-	return { onTouchesDown, onTouchesMove };
-};

package/src/shared/providers/screen/gestures/behaviors/strategies/pan-snap.strategy.ts

@@ -1,195 +0,0 @@
-import { resolveSnapTransitionSpec } from "../../../../../utils/animation/resolve-snap-transition-spec";
-import {
-	getPanSnapAxisConfigForDirection,
-	isResolvedPanGestureDirection,
-} from "../../helpers/gesture-directions";
-import { getPanReleaseHandoffVelocity } from "../../helpers/gesture-physics";
-import {
-	findNearestSnapPoint,
-	resolveRuntimeSnapPoints,
-} from "../../helpers/gesture-snap-points";
-import { determineSnapTarget } from "../../helpers/gesture-targets";
-import type { PanBehaviorStrategy } from "../../types";
-
-export const SnapPanStrategy: PanBehaviorStrategy = {
-	primeStart(runtime) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { animations, system },
-			lockedSnapPoint,
-		} = runtime;
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-
-		const { resolvedSnapPoints, resolvedMaxSnapPoint } =
-			resolveRuntimeSnapPoints({
-				snapPoints,
-				hasAutoSnapPoint,
-				resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-				minSnapPoint,
-				maxSnapPoint,
-				canDismiss: participation.canDismiss,
-			});
-
-		if (policy.gestureSnapLocked) {
-			lockedSnapPoint.set(
-				findNearestSnapPoint(animations.progress.get(), resolvedSnapPoints),
-			);
-			return;
-		}
-
-		lockedSnapPoint.set(resolvedMaxSnapPoint);
-	},
-
-	resolveProgress(runtime, dimensions, track) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { system },
-			gestureProgressBaseline,
-			lockedSnapPoint,
-		} = runtime;
-		const activeGesture = runtime.stores.gestures.active.get();
-		const activeAxis = isResolvedPanGestureDirection(activeGesture)
-			? getPanSnapAxisConfigForDirection(
-					policy.snapAxisDirections,
-					activeGesture,
-				)
-			: null;
-
-		if (!activeAxis) {
-			return gestureProgressBaseline.get();
-		}
-
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-		const { x, y } = track;
-
-		const isHorizontal = activeAxis.axis === "horizontal";
-		const translation = isHorizontal ? x : y;
-		const dimension = isHorizontal ? dimensions.width : dimensions.height;
-		const progressDelta =
-			(activeAxis.config.progressSign * translation) / dimension;
-
-		const { resolvedMinSnapPoint, resolvedMaxSnapPoint } =
-			resolveRuntimeSnapPoints({
-				snapPoints,
-				hasAutoSnapPoint,
-				resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-				minSnapPoint,
-				maxSnapPoint,
-				canDismiss: participation.canDismiss,
-			});
-
-		const maxProgressForGesture = policy.gestureSnapLocked
-			? lockedSnapPoint.get()
-			: resolvedMaxSnapPoint;
-		const minProgressForGesture = policy.gestureSnapLocked
-			? participation.canDismiss
-				? 0
-				: lockedSnapPoint.get()
-			: resolvedMinSnapPoint;
-
-		return Math.max(
-			minProgressForGesture,
-			Math.min(
-				maxProgressForGesture,
-				gestureProgressBaseline.get() + progressDelta,
-			),
-		);
-	},
-
-	resolveRelease(event, runtime, dimensions) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { animations, system },
-			lockedSnapPoint,
-		} = runtime;
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-		const activeGesture = runtime.stores.gestures.active.get();
-		const activeAxis = isResolvedPanGestureDirection(activeGesture)
-			? getPanSnapAxisConfigForDirection(
-					policy.snapAxisDirections,
-					activeGesture,
-				)
-			: null;
-
-		if (!activeAxis) {
-			return {
-				target: animations.progress.get(),
-				shouldDismiss: false,
-				initialVelocity: 0,
-				transitionSpec: policy.transitionSpec,
-				resetSpec: policy.transitionSpec?.open,
-			};
-		}
-
-		const isHorizontal = activeAxis.axis === "horizontal";
-		const axisVelocity = isHorizontal ? event.velocityX : event.velocityY;
-		const axisDimension = isHorizontal ? dimensions.width : dimensions.height;
-		const snapVelocity = activeAxis.config.inverted
-			? -axisVelocity
-			: axisVelocity;
-
-		const { resolvedSnapPoints } = resolveRuntimeSnapPoints({
-			snapPoints,
-			hasAutoSnapPoint,
-			resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-			minSnapPoint,
-			maxSnapPoint,
-			canDismiss: participation.canDismiss,
-		});
-
-		const result = determineSnapTarget({
-			currentProgress: animations.progress.get(),
-			snapPoints: policy.gestureSnapLocked
-				? [lockedSnapPoint.get()]
-				: resolvedSnapPoints,
-			velocity: snapVelocity,
-			dimension: axisDimension,
-			velocityFactor: policy.gestureSnapVelocityImpact,
-			canDismiss: participation.canDismiss,
-		});
-
-		const shouldDismiss = participation.canDismiss && result.shouldDismiss;
-		const target = shouldDismiss ? 0 : result.targetProgress;
-		const isSnapping = !shouldDismiss;
-		const currentProgress = animations.progress.get();
-		const transitionSpec = isSnapping
-			? resolveSnapTransitionSpec(
-					policy.transitionSpec,
-					target < currentProgress ? "collapse" : "expand",
-				)
-			: policy.transitionSpec;
-
-		const snapDirection = Math.sign(target - currentProgress);
-		const initialVelocity =
-			snapDirection === 0
-				? 0
-				: snapDirection *
-					Math.abs(
-						getPanReleaseHandoffVelocity(
-							axisVelocity,
-							axisDimension,
-							policy.gestureReleaseVelocityScale,
-							policy.gestureReleaseVelocityMax,
-						),
-					);
-
-		return {
-			target,
-			shouldDismiss,
-			initialVelocity,
-			transitionSpec,
-			resetSpec: shouldDismiss
-				? policy.transitionSpec?.close
-				: policy.transitionSpec?.open,
-		};
-	},
-};

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

@@ -1,76 +0,0 @@
-import { clamp } from "react-native-reanimated";
-import {
-	getPanReleaseProgressVelocity,
-	mapGestureToProgress,
-} from "../../helpers/gesture-physics";
-import { determineDismissal } from "../../helpers/gesture-targets";
-import type { PanBehaviorStrategy } from "../../types";
-
-export const PanStrategy: PanBehaviorStrategy = {
-	primeStart(_runtime) {
-		"worklet";
-	},
-
-	resolveProgress(runtime, dimensions, track) {
-		"worklet";
-		const { policy, gestureProgressBaseline } = runtime;
-		const { x, y } = track;
-		const { width, height } = dimensions;
-
-		let maxProgress = 0;
-
-		if (policy.panActivationDirections.horizontal && x > 0) {
-			maxProgress = Math.max(maxProgress, mapGestureToProgress(x, width));
-		}
-
-		if (policy.panActivationDirections.horizontalInverted && x < 0) {
-			maxProgress = Math.max(maxProgress, mapGestureToProgress(-x, width));
-		}
-
-		if (policy.panActivationDirections.vertical && y > 0) {
-			maxProgress = Math.max(maxProgress, mapGestureToProgress(y, height));
-		}
-
-		if (policy.panActivationDirections.verticalInverted && y < 0) {
-			maxProgress = Math.max(maxProgress, mapGestureToProgress(-y, height));
-		}
-
-		return clamp(gestureProgressBaseline.get() - maxProgress, 0, 1);
-	},
-
-	resolveRelease(event, runtime, dimensions) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { animations },
-		} = runtime;
-
-		const result = determineDismissal({
-			event,
-			directions: policy.panActivationDirections,
-			dimensions,
-			gestureVelocityImpact: policy.gestureVelocityImpact,
-		});
-
-		const shouldDismiss = participation.canDismiss && result.shouldDismiss;
-
-		return {
-			target: shouldDismiss ? 0 : 1,
-			shouldDismiss,
-			initialVelocity: getPanReleaseProgressVelocity({
-				animations,
-				shouldDismiss,
-				event,
-				dimensions,
-				directions: policy.panActivationDirections,
-				gestureReleaseVelocityScale: policy.gestureReleaseVelocityScale,
-				gestureReleaseVelocityMax: policy.gestureReleaseVelocityMax,
-			}),
-			transitionSpec: policy.transitionSpec,
-			resetSpec: shouldDismiss
-				? policy.transitionSpec?.close
-				: policy.transitionSpec?.open,
-		};
-	},
-};

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

@@ -1,177 +0,0 @@
-import { clamp } from "react-native-reanimated";
-import { resolveSnapTransitionSpec } from "../../../../../utils/animation/resolve-snap-transition-spec";
-import {
-	getPinchReleaseHandoffVelocity,
-	normalizePinchScale,
-} from "../../helpers/gesture-physics";
-import {
-	findNearestSnapPoint,
-	resolveRuntimeSnapPoints,
-} from "../../helpers/gesture-snap-points";
-import { determineSnapTarget } from "../../helpers/gesture-targets";
-import type { PinchBehaviorStrategy } from "../../types";
-
-export const SnapPinchStrategy: PinchBehaviorStrategy = {
-	primeStart(runtime) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { animations, system },
-			lockedSnapPoint,
-		} = runtime;
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-
-		const { resolvedSnapPoints, resolvedMaxSnapPoint } =
-			resolveRuntimeSnapPoints({
-				snapPoints,
-				hasAutoSnapPoint,
-				resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-				minSnapPoint,
-				maxSnapPoint,
-				canDismiss: participation.canDismiss,
-			});
-
-		if (policy.gestureSnapLocked) {
-			lockedSnapPoint.set(
-				findNearestSnapPoint(animations.progress.get(), resolvedSnapPoints),
-			);
-			return;
-		}
-
-		lockedSnapPoint.set(resolvedMaxSnapPoint);
-	},
-
-	resolveProgress(runtime, track) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { system },
-			gestureProgressBaseline,
-			lockedSnapPoint,
-		} = runtime;
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-		const { normScale } = track;
-		const pinchDirection =
-			normScale < 0 ? "pinch-in" : normScale > 0 ? "pinch-out" : null;
-
-		let progressDelta = 0;
-		if (pinchDirection && policy.snapDirections) {
-			progressDelta =
-				policy.snapDirections.collapse === pinchDirection
-					? -Math.abs(normScale)
-					: Math.abs(normScale);
-		}
-
-		const { resolvedMinSnapPoint, resolvedMaxSnapPoint } =
-			resolveRuntimeSnapPoints({
-				snapPoints,
-				hasAutoSnapPoint,
-				resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-				minSnapPoint,
-				maxSnapPoint,
-				canDismiss: participation.canDismiss,
-			});
-
-		const maxProgressForGesture = policy.gestureSnapLocked
-			? lockedSnapPoint.get()
-			: resolvedMaxSnapPoint;
-
-		const minProgressForGesture = policy.gestureSnapLocked
-			? participation.canDismiss
-				? 0
-				: lockedSnapPoint.get()
-			: participation.canDismiss
-				? 0
-				: resolvedMinSnapPoint;
-
-		return clamp(
-			gestureProgressBaseline.get() + progressDelta,
-			minProgressForGesture,
-			maxProgressForGesture,
-		);
-	},
-
-	resolveRelease(event, runtime) {
-		"worklet";
-		const {
-			participation,
-			policy,
-			stores: { animations, system },
-			lockedSnapPoint,
-		} = runtime;
-		const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
-			participation.effectiveSnapPoints;
-		const normalizedScale = clamp(normalizePinchScale(event.scale), -1, 1);
-		const currentProgress = animations.progress.get();
-		const pinchDirection =
-			normalizedScale < 0
-				? "pinch-in"
-				: normalizedScale > 0
-					? "pinch-out"
-					: null;
-
-		const { resolvedSnapPoints } = resolveRuntimeSnapPoints({
-			snapPoints,
-			hasAutoSnapPoint,
-			resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
-			minSnapPoint,
-			maxSnapPoint,
-			canDismiss: participation.canDismiss,
-		});
-
-		let snapVelocity = 0;
-		if (pinchDirection && policy.snapDirections) {
-			snapVelocity =
-				policy.snapDirections.collapse === pinchDirection
-					? Math.abs(event.velocity)
-					: -Math.abs(event.velocity);
-		}
-
-		const result = determineSnapTarget({
-			currentProgress,
-			snapPoints: policy.gestureSnapLocked
-				? [lockedSnapPoint.get()]
-				: resolvedSnapPoints,
-			velocity: snapVelocity,
-			dimension: 1,
-			velocityFactor: policy.gestureSnapVelocityImpact,
-			canDismiss: participation.canDismiss,
-		});
-
-		const shouldDismiss = participation.canDismiss && result.shouldDismiss;
-		const target = shouldDismiss ? 0 : result.targetProgress;
-		const isSnapping = !shouldDismiss;
-		const transitionSpec = isSnapping
-			? resolveSnapTransitionSpec(
-					policy.transitionSpec,
-					target < currentProgress ? "collapse" : "expand",
-				)
-			: policy.transitionSpec;
-		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,
-			resetSpec: shouldDismiss
-				? policy.transitionSpec?.close
-				: policy.transitionSpec?.open,
-		};
-	},
-};