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

package/src/shared/providers/screen/gestures/{helpers/pan-phases.ts → pan/pan-lifecycle.ts}

@@ -2,6 +2,10 @@ import { clamp } from "react-native-reanimated";
 import { EPSILON, FALSE, TRUE } from "../../../../constants";
 import { animateToProgress } from "../../../../utils/animation/animate-to-progress";
 import { emit } from "../../../../utils/animation/emit";
+import {
+	normalizeGestureTranslation,
+	resolveGestureVelocity,
+} from "../shared/physics";
 import type {
 	GestureDimensions,
 	PanGestureEvent,
@@ -9,8 +13,8 @@ import type {
 	PanReleaseResult,
 	PanTrackState,
 } from "../types";
-import { normalizeGestureTranslation } from "./gesture-physics";
-import { resetGestureValues } from "./gesture-reset";
+import { buildPanReleasePlan } from "./pan-release";
+import { resetPanGestureValues } from "./pan-reset";
 
 export const startPanBase = (runtime: PanGestureRuntime) => {
 	"worklet";
@@ -35,6 +39,7 @@ export const startPanBase = (runtime: PanGestureRuntime) => {
 	gestures.y.set(0);
 	gestures.normX.set(0);
 	gestures.normY.set(0);
+	gestures.velocity.set(0);
 	gestures.raw.x.set(0);
 	gestures.raw.y.set(0);
 	gestures.raw.normX.set(0);
@@ -50,18 +55,28 @@ export const trackPanGesture = (
 ): PanTrackState => {
 	"worklet";
 	const { translationX: x, translationY: y } = event;
-	const { translationX: rawX, translationY: rawY } = rawEvent;
+	const {
+		translationX: rawX,
+		translationY: rawY,
+		velocityX,
+		velocityY,
+	} = rawEvent;
 	const { width, height } = dimensions;
 
 	const normX = clamp(normalizeGestureTranslation(x, width), -1, 1);
 	const normY = clamp(normalizeGestureTranslation(y, height), -1, 1);
 	const rawNormX = clamp(normalizeGestureTranslation(rawX, width), -1, 1);
 	const rawNormY = clamp(normalizeGestureTranslation(rawY, height), -1, 1);
+	const velocity = resolveGestureVelocity(
+		velocityX / Math.max(1, width),
+		velocityY / Math.max(1, height),
+	);
 
 	gestures.x.set(x);
 	gestures.y.set(y);
 	gestures.normX.set(normX);
 	gestures.normY.set(normY);
+	gestures.velocity.set(velocity);
 	gestures.raw.x.set(rawX);
 	gestures.raw.y.set(rawY);
 	gestures.raw.normX.set(rawNormX);
@@ -72,6 +87,7 @@ export const trackPanGesture = (
 		y,
 		normX,
 		normY,
+		velocity,
 	};
 };
 
@@ -84,41 +100,46 @@ export const finalizePanRelease = (
 ) => {
 	"worklet";
 	const {
-		policy,
 		stores: { gestures, animations, system },
 	} = runtime;
-	const { width, height } = dimensions;
-	const releaseVelocityScale = Math.max(0, policy.gestureReleaseVelocityScale);
-	const resetVelocityX = rawEvent.velocityX * releaseVelocityScale;
-	const resetVelocityY = rawEvent.velocityY * releaseVelocityScale;
+	const plan = buildPanReleasePlan(release, runtime, dimensions, rawEvent);
+
+	if (typeof plan.commitProgress === "number") {
+		animations.progress.set(plan.commitProgress);
+		system.targetProgress.set(plan.commitProgress);
+	}
 
-	resetGestureValues({
-		spec: release.resetSpec,
+	resetPanGestureValues({
+		spec: plan.resetSpec,
 		gestures,
-		shouldDismiss: release.shouldDismiss,
-		velocityX: resetVelocityX,
-		velocityY: resetVelocityY,
-		velocityNormX: resetVelocityX / Math.max(1, width),
-		velocityNormY: resetVelocityY / Math.max(1, height),
+		shouldDismiss: plan.shouldDismiss,
+		velocityX: plan.resetVelocityX,
+		velocityY: plan.resetVelocityY,
+		velocityNormX: plan.resetVelocityNormX,
+		velocityNormY: plan.resetVelocityNormY,
+		releaseVelocity: plan.releaseVelocity,
+		resetNormalizedValues: plan.resetNormalizedValues,
+		resetNormalizedValuesImmediately: plan.resetNormalizedValuesImmediately,
+		preserveRawValues: plan.preserveRawValues,
 	});
 
 	const progressAlreadyAtTarget =
-		Math.abs(animations.progress.get() - release.target) <= EPSILON;
+		Math.abs(animations.progress.get() - plan.target) <= EPSILON;
 
-	if (!release.shouldDismiss && progressAlreadyAtTarget) {
-		system.targetProgress.set(release.target);
-		animations.animating.set(FALSE);
+	if (!plan.shouldDismiss && progressAlreadyAtTarget) {
+		system.targetProgress.set(plan.target);
+		animations.progressAnimating.set(FALSE);
 		return;
 	}
 
 	animateToProgress({
-		target: release.target,
-		onAnimationFinish: release.shouldDismiss ? dismissScreen : undefined,
-		spec: release.transitionSpec,
+		target: plan.target,
+		onAnimationFinish: plan.shouldDismiss ? dismissScreen : undefined,
+		spec: plan.transitionSpec,
 		emitWillAnimate: false,
 		markEntering: false,
 		targetProgress: system.targetProgress,
 		animations,
-		initialVelocity: release.initialVelocity,
+		initialVelocity: plan.progressVelocity,
 	});
 };

package/src/shared/providers/screen/gestures/pan/pan-release.ts

@@ -0,0 +1,279 @@
+import { clamp } from "react-native-reanimated";
+import {
+	getPanSnapAxisConfigForDirection,
+	isResolvedPanGestureDirection,
+} from "../shared/directions";
+import {
+	getPanReleaseHandoffVelocity,
+	getPanReleaseProgressVelocity,
+	resolveGestureVelocity,
+} from "../shared/physics";
+import {
+	getProgressVelocityTowardTarget,
+	resolveGestureSnapTransitionSpec,
+} from "../shared/release";
+import {
+	primeRuntimeSnapPoint,
+	resolveRuntimeGestureSnapPoints,
+} from "../shared/snap-points";
+import { determineDismissal, determineSnapTarget } from "../shared/targets";
+import type {
+	GestureDimensions,
+	PanGestureEvent,
+	PanGestureRuntime,
+	PanReleasePlan,
+	PanReleaseResult,
+} from "../types";
+
+const resolvePanReleaseVelocity = (
+	runtime: PanGestureRuntime,
+	velocityNormX: number,
+	velocityNormY: number,
+) => {
+	"worklet";
+	const activeGesture = runtime.stores.gestures.active.get();
+
+	switch (activeGesture) {
+		case "horizontal":
+		case "horizontal-inverted":
+			return resolveGestureVelocity(velocityNormX, 0);
+		case "vertical":
+		case "vertical-inverted":
+			return resolveGestureVelocity(0, velocityNormY);
+		default:
+			return resolveGestureVelocity(velocityNormX, velocityNormY);
+	}
+};
+
+const resolveActivePanSnapAxis = (runtime: PanGestureRuntime) => {
+	"worklet";
+	const activeGesture = runtime.stores.gestures.active.get();
+
+	return isResolvedPanGestureDirection(activeGesture)
+		? getPanSnapAxisConfigForDirection(
+				runtime.policy.snapAxisDirections,
+				activeGesture,
+			)
+		: null;
+};
+
+const getPanSnapAxisMotion = (
+	event: PanGestureEvent,
+	dimensions: GestureDimensions,
+	activeAxis: NonNullable<ReturnType<typeof resolveActivePanSnapAxis>>,
+) => {
+	"worklet";
+	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;
+
+	return { axisVelocity, axisDimension, snapVelocity };
+};
+
+const getPanSnapReleaseProgress = ({
+	runtime,
+	event,
+	dimensions,
+	activeAxis,
+	minSnapPoint,
+	maxSnapPoint,
+}: {
+	runtime: PanGestureRuntime;
+	event: PanGestureEvent;
+	dimensions: GestureDimensions;
+	activeAxis: NonNullable<ReturnType<typeof resolveActivePanSnapAxis>>;
+	minSnapPoint: number;
+	maxSnapPoint: number;
+}) => {
+	"worklet";
+	const isHorizontal = activeAxis.axis === "horizontal";
+	const axisTranslation = isHorizontal
+		? event.translationX
+		: event.translationY;
+	const axisDimension = isHorizontal ? dimensions.width : dimensions.height;
+	const axisProgress = axisTranslation / Math.max(1, axisDimension);
+	const progress =
+		runtime.gestureProgressBaseline.get() +
+		activeAxis.config.progressSign * axisProgress;
+
+	return clamp(progress, minSnapPoint, maxSnapPoint);
+};
+
+const buildInactivePanSnapRelease = (
+	runtime: PanGestureRuntime,
+): PanReleaseResult => {
+	"worklet";
+	const { policy, stores } = runtime;
+
+	return {
+		target: stores.animations.progress.get(),
+		shouldDismiss: false,
+		initialVelocity: 0,
+		transitionSpec: policy.transitionSpec,
+		resetSpec: policy.transitionSpec?.open,
+	};
+};
+
+export const primeSnapPanRelease = (runtime: PanGestureRuntime) => {
+	"worklet";
+	primeRuntimeSnapPoint(runtime);
+};
+
+export const resolvePanRelease = (
+	event: PanGestureEvent,
+	runtime: PanGestureRuntime,
+	dimensions: GestureDimensions,
+): PanReleaseResult => {
+	"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,
+		}),
+		transitionSpec: policy.transitionSpec,
+		resetSpec: shouldDismiss
+			? policy.transitionSpec?.close
+			: policy.transitionSpec?.open,
+	};
+};
+
+export const resolveSnapPanRelease = (
+	event: PanGestureEvent,
+	runtime: PanGestureRuntime,
+	dimensions: GestureDimensions,
+): PanReleaseResult => {
+	"worklet";
+	const { participation, policy, lockedSnapPoint } = runtime;
+	const activeAxis = resolveActivePanSnapAxis(runtime);
+
+	if (!activeAxis) {
+		return buildInactivePanSnapRelease(runtime);
+	}
+
+	const { axisVelocity, axisDimension, snapVelocity } = getPanSnapAxisMotion(
+		event,
+		dimensions,
+		activeAxis,
+	);
+	const { resolvedSnapPoints, resolvedMinSnapPoint, resolvedMaxSnapPoint } =
+		resolveRuntimeGestureSnapPoints(runtime);
+	const currentProgress = getPanSnapReleaseProgress({
+		runtime,
+		event,
+		dimensions,
+		activeAxis,
+		minSnapPoint: resolvedMinSnapPoint,
+		maxSnapPoint: resolvedMaxSnapPoint,
+	});
+	const result = determineSnapTarget({
+		currentProgress,
+		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;
+
+	return {
+		target,
+		shouldDismiss,
+		initialVelocity: getProgressVelocityTowardTarget({
+			handoffVelocity: getPanReleaseHandoffVelocity(
+				axisVelocity,
+				axisDimension,
+				policy.gestureReleaseVelocityScale,
+			),
+			target,
+			currentProgress,
+		}),
+		commitProgress: currentProgress,
+		resetNormalizedValuesImmediately:
+			policy.gestureProgressMode === "progress-driven",
+		transitionSpec: resolveGestureSnapTransitionSpec({
+			transitionSpec: policy.transitionSpec,
+			shouldDismiss,
+			target,
+			currentProgress,
+		}),
+		resetSpec: shouldDismiss
+			? policy.transitionSpec?.close
+			: policy.transitionSpec?.open,
+	};
+};
+
+export const buildPanReleasePlan = (
+	release: PanReleaseResult,
+	runtime: PanGestureRuntime,
+	dimensions: GestureDimensions,
+	rawEvent: PanGestureEvent,
+): PanReleasePlan => {
+	"worklet";
+	const { policy } = runtime;
+	const progressDriven = policy.gestureProgressMode === "progress-driven";
+	const releaseVelocityScale = Math.max(0, policy.gestureReleaseVelocityScale);
+	const resetUsesReleaseVelocity = !release.shouldDismiss || !progressDriven;
+	const resetVelocityFactor = resetUsesReleaseVelocity ? 1 : 0;
+	const resetVelocityScale = releaseVelocityScale * resetVelocityFactor;
+	const resetVelocityX =
+		resetVelocityScale === 0 ? 0 : rawEvent.velocityX * resetVelocityScale;
+	const resetVelocityY =
+		resetVelocityScale === 0 ? 0 : rawEvent.velocityY * resetVelocityScale;
+	const releaseVelocityNormX =
+		rawEvent.velocityX / Math.max(1, dimensions.width);
+	const releaseVelocityNormY =
+		rawEvent.velocityY / Math.max(1, dimensions.height);
+	const releaseVelocity = release.shouldDismiss
+		? resolvePanReleaseVelocity(
+				runtime,
+				releaseVelocityNormX,
+				releaseVelocityNormY,
+			)
+		: 0;
+
+	return {
+		target: release.target,
+		shouldDismiss: release.shouldDismiss,
+		progressVelocity: progressDriven ? release.initialVelocity : 0,
+		resetVelocityX,
+		resetVelocityY,
+		resetVelocityNormX: resetVelocityX / Math.max(1, dimensions.width),
+		resetVelocityNormY: resetVelocityY / Math.max(1, dimensions.height),
+		releaseVelocity,
+		resetNormalizedValues: !release.shouldDismiss || progressDriven,
+		resetNormalizedValuesImmediately:
+			release.resetNormalizedValuesImmediately === true,
+		preserveRawValues: release.shouldDismiss,
+		commitProgress: release.commitProgress,
+		transitionSpec: release.transitionSpec,
+		resetSpec: release.resetSpec,
+	};
+};

package/src/shared/providers/screen/gestures/pan/pan-reset.ts

@@ -0,0 +1,95 @@
+import { EPSILON, FALSE, TRUE } from "../../../../constants";
+import type { GestureStoreMap } from "../../../../stores/gesture.store";
+import type { AnimationConfig } from "../../../../types/animation.types";
+import {
+	animateResetValue,
+	clearGestureSettlingIfResting,
+	getGestureResetSpec,
+} from "../shared/reset";
+
+interface ResetPanGestureValuesProps {
+	spec?: AnimationConfig;
+	gestures: GestureStoreMap;
+	shouldDismiss: boolean;
+	velocityX?: number;
+	velocityY?: number;
+	velocityNormX?: number;
+	velocityNormY?: number;
+	releaseVelocity?: number;
+	resetNormalizedValues?: boolean;
+	resetNormalizedValuesImmediately?: boolean;
+	preserveRawValues?: boolean;
+}
+
+const clearPanSettlingIfResting = (gestures: GestureStoreMap) => {
+	"worklet";
+
+	clearGestureSettlingIfResting(
+		gestures,
+		!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,
+	);
+};
+
+export const resetPanGestureValues = ({
+	spec,
+	gestures,
+	shouldDismiss,
+	velocityX,
+	velocityY,
+	velocityNormX,
+	velocityNormY,
+	releaseVelocity,
+	resetNormalizedValues = true,
+	resetNormalizedValuesImmediately = false,
+	preserveRawValues = shouldDismiss,
+}: ResetPanGestureValuesProps) => {
+	"worklet";
+
+	if (!preserveRawValues) {
+		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);
+	gestures.velocity.set(shouldDismiss ? (releaseVelocity ?? 0) : 0);
+
+	animateResetValue(gestures.x, 0, getGestureResetSpec(spec, velocityX), () =>
+		clearPanSettlingIfResting(gestures),
+	);
+	animateResetValue(gestures.y, 0, getGestureResetSpec(spec, velocityY), () =>
+		clearPanSettlingIfResting(gestures),
+	);
+
+	if (!resetNormalizedValues) {
+		return;
+	}
+
+	if (resetNormalizedValuesImmediately) {
+		gestures.normX.set(0);
+		gestures.normY.set(0);
+		clearPanSettlingIfResting(gestures);
+		return;
+	}
+
+	animateResetValue(
+		gestures.normX,
+		0,
+		getGestureResetSpec(spec, velocityNormX),
+		() => clearPanSettlingIfResting(gestures),
+	);
+	animateResetValue(
+		gestures.normY,
+		0,
+		getGestureResetSpec(spec, velocityNormY),
+		() => clearPanSettlingIfResting(gestures),
+	);
+};

package/src/shared/providers/screen/gestures/{behaviors → pan}/use-pan-behavior.ts

@@ -1,30 +1,25 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import type { SharedValue } from "react-native-reanimated";
 import { useNavigationHelpers } from "../../../../hooks/navigation/use-navigation-helpers";
 import type { ScreenOptionsContextValue } from "../../options";
-import {
-	finalizePanRelease,
-	startPanBase,
-	trackPanGesture,
-} from "../helpers/pan-phases";
-import { resolvePanRuntime } from "../helpers/runtime-options";
 import { usePanGestureSensitivity } from "../hooks/use-gesture-sensitivity";
+import { resolvePanRuntime } from "../shared/runtime";
 import type {
 	GestureDimensions,
 	PanBehavior,
-	PanBehaviorStrategy,
 	PanGestureEvent,
 	PanGestureRuntime,
 } from "../types";
-import { PanStrategy } from "./strategies/pan.strategy";
-import { SnapPanStrategy } from "./strategies/pan-snap.strategy";
-
-const getPanStrategy = (runtime: PanGestureRuntime): PanBehaviorStrategy => {
-	"worklet";
-	return runtime.participation.effectiveSnapPoints.hasSnapPoints
-		? SnapPanStrategy
-		: PanStrategy;
-};
+import {
+	finalizePanRelease,
+	startPanBase,
+	trackPanGesture,
+} from "./pan-lifecycle";
+import {
+	primeSnapPanRelease,
+	resolvePanRelease,
+	resolveSnapPanRelease,
+} from "./pan-release";
 
 export const usePanBehavior = (
 	runtime: SharedValue<PanGestureRuntime>,
@@ -38,8 +33,9 @@ export const usePanBehavior = (
 	const onStart = useCallback(() => {
 		"worklet";
 		const latestRuntime = resolvePanRuntime(runtime.get(), screenOptions.get());
-		const strategy = getPanStrategy(latestRuntime);
-		strategy.primeStart(latestRuntime);
+		if (latestRuntime.participation.effectiveSnapPoints.hasSnapPoints) {
+			primeSnapPanRelease(latestRuntime);
+		}
 		startPanBase(latestRuntime);
 		resetSensitivity();
 	}, [runtime, screenOptions, resetSensitivity]);
@@ -51,22 +47,13 @@ export const usePanBehavior = (
 				runtime.get(),
 				screenOptions.get(),
 			);
-			const strategy = getPanStrategy(latestRuntime);
 			const event = withSensitivity(rawEvent);
-			const track = trackPanGesture(
+			trackPanGesture(
 				event,
 				rawEvent,
 				latestRuntime.stores.gestures,
 				dimensions,
 			);
-
-			if (!latestRuntime.policy.gestureDrivesProgress) {
-				return;
-			}
-
-			latestRuntime.stores.animations.progress.set(
-				strategy.resolveProgress(latestRuntime, dimensions, track),
-			);
 		},
 		[runtime, screenOptions, dimensions, withSensitivity],
 	);
@@ -78,9 +65,11 @@ export const usePanBehavior = (
 				runtime.get(),
 				screenOptions.get(),
 			);
-			const strategy = getPanStrategy(latestRuntime);
 			const event = withSensitivity(rawEvent);
-			const release = strategy.resolveRelease(event, latestRuntime, dimensions);
+			const release = latestRuntime.participation.effectiveSnapPoints
+				.hasSnapPoints
+				? resolveSnapPanRelease(event, latestRuntime, dimensions)
+				: resolvePanRelease(event, latestRuntime, dimensions);
 			finalizePanRelease(
 				release,
 				latestRuntime,
@@ -92,9 +81,12 @@ export const usePanBehavior = (
 		[runtime, screenOptions, dimensions, dismissScreen, withSensitivity],
 	);
 
-	return {
-		onStart,
-		onUpdate,
-		onEnd,
-	};
+	return useMemo(
+		() => ({
+			onStart,
+			onUpdate,
+			onEnd,
+		}),
+		[onStart, onUpdate, onEnd],
+	);
 };

package/src/shared/providers/screen/gestures/{builders/use-build-pinch-gesture.ts → pinch/build-pinch-gesture.ts}

@@ -1,11 +1,11 @@
 import { useMemo } from "react";
 import { Gesture } from "react-native-gesture-handler";
 import { useScreenOptionsContext } from "../../options";
-import { usePinchActivation } from "../activation/use-pinch-activation";
-import { usePinchBehavior } from "../behaviors/use-pinch-behavior";
 import { useGestureBuilderState } from "../hooks/use-gesture-builder-state";
 import { useStableRuntimeConfig } from "../hooks/use-stable-runtime-config";
 import type { PinchGesture, ScreenGestureConfig } from "../types";
+import { usePinchActivation } from "./pinch-activation";
+import { usePinchBehavior } from "./use-pinch-behavior";
 
 interface BuildPinchGestureHookProps {
 	gestureConfig: ScreenGestureConfig;

package/src/shared/providers/screen/gestures/{activation/use-pinch-activation.ts → pinch/pinch-activation.ts}

@@ -1,11 +1,11 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import type {
 	GestureStateManager,
 	GestureTouchEvent,
 } from "react-native-gesture-handler";
 import type { SharedValue } from "react-native-reanimated";
 import type { ScreenOptionsContextValue } from "../../options";
-import { resolvePinchRuntime } from "../helpers/runtime-options";
+import { resolvePinchRuntime } from "../shared/runtime";
 import type { PinchGestureRuntime } from "../types";
 
 interface UsePinchActivationProps {
@@ -68,5 +68,8 @@ export const usePinchActivation = ({
 		[runtime, screenOptions],
 	);
 
-	return { onTouchesDown, onTouchesMove };
+	return useMemo(
+		() => ({ onTouchesDown, onTouchesMove }),
+		[onTouchesDown, onTouchesMove],
+	);
 };

package/src/shared/providers/screen/gestures/{helpers/pinch-phases.ts → pinch/pinch-lifecycle.ts}

@@ -2,14 +2,14 @@ import { clamp } from "react-native-reanimated";
 import { EPSILON, FALSE, TRUE } from "../../../../constants";
 import { animateToProgress } from "../../../../utils/animation/animate-to-progress";
 import { emit } from "../../../../utils/animation/emit";
+import { normalizePinchScale } from "../shared/physics";
 import type {
 	PinchGestureEvent,
 	PinchGestureRuntime,
 	PinchReleaseResult,
 	PinchTrackState,
 } from "../types";
-import { normalizePinchScale } from "./gesture-physics";
-import { resetPinchGestureValues } from "./gesture-reset";
+import { resetPinchGestureValues } from "./pinch-reset";
 
 export const startPinchBase = (
 	runtime: PinchGestureRuntime,
@@ -33,6 +33,7 @@ export const startPinchBase = (
 	gestures.settling.set(0);
 	gestures.active.set(null);
 	gestures.direction.set(null);
+	gestures.velocity.set(0);
 	gestures.scale.set(1);
 	gestures.normScale.set(0);
 	gestures.raw.scale.set(1);
@@ -79,10 +80,16 @@ export const finalizePinchRelease = (
 		stores: { gestures, animations, system },
 	} = runtime;
 
+	if (typeof release.commitProgress === "number") {
+		animations.progress.set(release.commitProgress);
+		system.targetProgress.set(release.commitProgress);
+	}
+
 	resetPinchGestureValues({
 		spec: release.resetSpec,
 		gestures,
 		shouldDismiss: release.shouldDismiss,
+		resetValuesImmediately: release.resetValuesImmediately,
 	});
 
 	animateToProgress({