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

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

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