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

package/src/shared/utils/bounds/navigation/reveal/config.ts

@@ -6,21 +6,10 @@ export const REVEAL_BORDER_RADIUS = Platform.select({
 	default: 36,
 });
 
-export const ZOOM_SHARED_OPTIONS = Object.freeze({
-	anchor: "top" as const,
-	scaleMode: "uniform" as const,
-});
-
-export const ZOOM_DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
-export const ZOOM_DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
-export const ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT = 2;
-export const ZOOM_DRAG_TRANSLATION_NEGATIVE_MAX = 1;
-export const ZOOM_DRAG_TRANSLATION_POSITIVE_MAX = 1;
-export const ZOOM_DRAG_TRANSLATION_EXPONENT = 1;
-
-export const ZOOM_MASK_OUTSET = Object.freeze({
-	top: 0,
-	right: 0,
-	bottom: 0,
-	left: 0,
-});
+export const DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
+export const DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
+export const DRAG_DIRECTIONAL_SCALE_EXPONENT = 2;
+export const DRAG_MASK_HEIGHT_COLLAPSE_END = 0.7;
+export const HORIZONTAL_DRAG_MASK_COLLAPSE_SCALE = 0.5;
+export const DISMISS_SCALE_ORBIT_DEPTH = 0.8;
+export const CLOSE_SOURCE_HANDOFF_PROGRESS = 0.25;

package/src/shared/utils/bounds/navigation/zoom/build.ts

@@ -5,7 +5,10 @@ import {
 	NAVIGATION_MASK_ELEMENT_STYLE_ID,
 	VISIBLE_STYLE,
 } from "../../../../constants";
-import type { TransitionInterpolatedStyle } from "../../../../types/animation.types";
+import type {
+	ScreenTransitionOptions,
+	TransitionInterpolatedStyle,
+} from "../../../../types/animation.types";
 import { createLinkAccessor } from "../../helpers/create-link-accessor";
 import { getSourceBorderRadius, toNumber } from "../helpers";
 import {
@@ -16,7 +19,7 @@ import {
 	resolveOpacityRangeTuple,
 } from "../math";
 import {
-	ZOOM_DRAG_RESISTANCE,
+	ZOOM_DISMISS_SCALE_ORBIT_DEPTH,
 	ZOOM_FOCUSED_ELEMENT_CLOSE_OPACITY_RANGE,
 	ZOOM_FOCUSED_ELEMENT_OPEN_OPACITY_RANGE,
 	ZOOM_MASK_OUTSET,
@@ -36,6 +39,71 @@ import type { BuildZoomStylesParams, ZoomInterpolatedStyle } from "./types";
 
 const IDENTITY_DRAG_SCALE_OUTPUT = [1, 1] as const;
 
+function resolveZoomGestureHandoff(rawDrag: number) {
+	"worklet";
+
+	const gestureSensitivity = interpolate(rawDrag, [0, 1], [0.7, 0.1], "clamp");
+	const releaseBoost = interpolate(rawDrag, [0, 1], [1, 1.4], "clamp");
+	const releaseSensitivity = interpolate(
+		gestureSensitivity,
+		[0.28, 0.9],
+		[0.7, 1],
+		"clamp",
+	);
+
+	return {
+		gestureSensitivity,
+		gestureReleaseVelocityScale: releaseBoost * releaseSensitivity,
+	};
+}
+
+function resolveZoomGestureOptions({
+	rawDrag,
+	activeOptions,
+}: {
+	rawDrag: number;
+	activeOptions: ScreenTransitionOptions;
+}) {
+	"worklet";
+
+	const { gestureSensitivity, gestureReleaseVelocityScale } =
+		resolveZoomGestureHandoff(rawDrag);
+
+	return {
+		gestureProgressMode: activeOptions.gestureProgressMode ?? "freeform",
+		gestureSensitivity: activeOptions.gestureSensitivity ?? gestureSensitivity,
+		gestureReleaseVelocityScale:
+			activeOptions.gestureReleaseVelocityScale ?? gestureReleaseVelocityScale,
+	};
+}
+
+function resolveZoomDismissScaleHandoff({
+	progress,
+	releaseScale,
+	targetScale,
+	rawDrag,
+}: {
+	progress: number;
+	releaseScale: number;
+	targetScale: number;
+	rawDrag: number;
+}) {
+	"worklet";
+
+	const closeProgress = 1 - progress;
+	const scaleProgress = Math.sin((Math.PI / 2) * closeProgress);
+	const baseScale = releaseScale + (targetScale - releaseScale) * scaleProgress;
+	const orbitDepth = interpolate(
+		rawDrag,
+		[0, 1],
+		[0, ZOOM_DISMISS_SCALE_ORBIT_DEPTH],
+		"clamp",
+	);
+	const orbitScale = 1 - orbitDepth * Math.sin(Math.PI * closeProgress);
+
+	return baseScale * orbitScale;
+}
+
 /* -------------------------------------------------------------------------- */
 /*                             BUILD ZOOM STYLES                              */
 /* -------------------------------------------------------------------------- */
@@ -114,6 +182,11 @@ export function buildZoomStyles({
 		initialGesture === "horizontal" || initialGesture === "horizontal-inverted";
 	const isVerticalDismiss =
 		initialGesture === "vertical" || initialGesture === "vertical-inverted";
+	const rawDrag = isHorizontalDismiss
+		? Math.abs(props.active.gesture.raw.normX)
+		: isVerticalDismiss
+			? Math.abs(props.active.gesture.raw.normY)
+			: 0;
 
 	const horizontalDragTranslation = resolveDragTranslationTuple(
 		zoomOptions?.horizontalDragTranslation,
@@ -122,17 +195,15 @@ export function buildZoomStyles({
 		zoomOptions?.verticalDragTranslation,
 	);
 	const dragX = resolveDirectionalDragTranslation({
-		normalized: normX,
+		translation: props.active.gesture.x,
 		dimension: screenLayout.width,
-		resistance: ZOOM_DRAG_RESISTANCE,
 		negativeMax: horizontalDragTranslation.negativeMax,
 		positiveMax: horizontalDragTranslation.positiveMax,
 		exponent: horizontalDragTranslation.exponent,
 	});
 	const dragY = resolveDirectionalDragTranslation({
-		normalized: normY,
+		translation: props.active.gesture.y,
 		dimension: screenLayout.height,
-		resistance: ZOOM_DRAG_RESISTANCE,
 		negativeMax: verticalDragTranslation.negativeMax,
 		positiveMax: verticalDragTranslation.positiveMax,
 		exponent: verticalDragTranslation.exponent,
@@ -166,6 +237,18 @@ export function buildZoomStyles({
 			})
 		: IDENTITY_DRAG_SCALE_OUTPUT[1];
 	const dragScale = combineScales(dragXScale, dragYScale);
+	const handoffDragScale = props.active.gesture.dismissing
+		? resolveZoomDismissScaleHandoff({
+				progress: props.active.progress,
+				releaseScale: dragScale,
+				targetScale: 1,
+				rawDrag,
+			})
+		: dragScale;
+	const zoomGestureOptions = resolveZoomGestureOptions({
+		rawDrag,
+		activeOptions: props.active.options,
+	});
 
 	/* ----------------------------- Focused Screen ----------------------------- */
 
@@ -220,9 +303,9 @@ export function buildZoomStyles({
 
 		const contentTranslateX = toNumber(contentRaw.translateX) + dragX;
 		const contentTranslateY = toNumber(contentRaw.translateY) + dragY;
-		const contentScale = toNumber(contentRaw.scale, 1) * dragScale;
-		const maskTranslateX = toNumber(maskRaw.translateX) + dragX - left;
-		const maskTranslateY = toNumber(maskRaw.translateY) + dragY - top;
+		const contentScale = contentRaw.scale * handoffDragScale;
+		const maskTranslateX = maskRaw.translateX + dragX - left;
+		const maskTranslateY = maskRaw.translateY + dragY - top;
 
 		const focusedContentStyle = {
 			opacity: zoomOptions?.debug ? 0.5 : focusedFade,
@@ -251,13 +334,16 @@ export function buildZoomStyles({
 					transform: [
 						{ translateX: maskTranslateX },
 						{ translateY: maskTranslateY },
-						{ scale: dragScale },
+						{ scale: handoffDragScale },
 					],
 				},
 			};
 		}
 
-		return focusedStyles;
+		return {
+			options: zoomGestureOptions,
+			...focusedStyles,
+		};
 	}
 
 	/* ---------------------------- Unfocused Screen ---------------------------- */
@@ -318,26 +404,39 @@ export function buildZoomStyles({
 			? unfocusedElementTarget.pageY + unfocusedElementTarget.height / 2
 			: screenLayout.height / 2);
 
+	const unfocusedContentScale = props.active.logicallySettled
+		? 1
+		: unfocusedScale;
+	const shouldTrackGestureTranslation = !props.active.logicallySettled;
+	const shouldTrackGestureScale = !props.active.logicallySettled;
+	const elementGestureScale = shouldTrackGestureScale ? handoffDragScale : 1;
+	const elementGestureX = shouldTrackGestureTranslation ? dragX : 0;
+	const elementGestureY = shouldTrackGestureTranslation ? dragY : 0;
+	const safeUnfocusedContentScale = Math.max(
+		Math.abs(unfocusedContentScale),
+		EPSILON,
+	);
+
 	const scaleShiftX = computeCenterScaleShift({
 		center: elementCenterX,
 		containerCenter: screenLayout.width / 2,
-		scale: dragScale,
+		scale: elementGestureScale,
 	});
 	const scaleShiftY = computeCenterScaleShift({
 		center: elementCenterY,
 		containerCenter: screenLayout.height / 2,
-		scale: dragScale,
+		scale: elementGestureScale,
 	});
 
 	const compensatedGestureX = composeCompensatedTranslation({
-		gesture: dragX,
-		parentScale: unfocusedScale,
+		gesture: elementGestureX,
+		parentScale: unfocusedContentScale,
 		centerShift: scaleShiftX,
 		epsilon: EPSILON,
 	});
 	const compensatedGestureY = composeCompensatedTranslation({
-		gesture: dragY,
-		parentScale: unfocusedScale,
+		gesture: elementGestureY,
+		parentScale: unfocusedContentScale,
 		centerShift: scaleShiftY,
 		epsilon: EPSILON,
 	});
@@ -346,8 +445,12 @@ export function buildZoomStyles({
 		toNumber(elementRaw.translateX) + compensatedGestureX;
 	const elementTranslateY =
 		toNumber(elementRaw.translateY) + compensatedGestureY;
-	const elementScaleX = toNumber(elementRaw.scaleX, 1) * dragScale;
-	const elementScaleY = toNumber(elementRaw.scaleY, 1) * dragScale;
+	const elementScaleX =
+		(toNumber(elementRaw.scaleX, 1) * elementGestureScale) /
+		safeUnfocusedContentScale;
+	const elementScaleY =
+		(toNumber(elementRaw.scaleY, 1) * elementGestureScale) /
+		safeUnfocusedContentScale;
 
 	const resolvedElementStyle = shouldHideUnfocusedElement
 		? {
@@ -382,9 +485,10 @@ export function buildZoomStyles({
 			};
 
 	return {
+		options: zoomGestureOptions,
 		content: {
 			style: {
-				transform: [{ scale: unfocusedScale }],
+				transform: [{ scale: unfocusedContentScale }],
 			},
 		},
 		[buildEffectiveTag]: {

package/src/shared/utils/bounds/navigation/zoom/config.ts

@@ -3,13 +3,13 @@ export const ZOOM_SHARED_OPTIONS = Object.freeze({
 	scaleMode: "uniform" as const,
 });
 
-export const ZOOM_DRAG_RESISTANCE = 0.4;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MIN = 0.25;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_MAX = 1.06;
 export const ZOOM_DRAG_DIRECTIONAL_SCALE_EXPONENT = 2;
 export const ZOOM_DRAG_TRANSLATION_NEGATIVE_MAX = 1;
 export const ZOOM_DRAG_TRANSLATION_POSITIVE_MAX = 1;
 export const ZOOM_DRAG_TRANSLATION_EXPONENT = 1;
+export const ZOOM_DISMISS_SCALE_ORBIT_DEPTH = 0.8;
 export const ZOOM_BACKGROUND_SCALE = 0.9375;
 export const ZOOM_FOCUSED_ELEMENT_OPEN_OPACITY_RANGE = [0, 0.5, 0, 1] as const;
 export const ZOOM_FOCUSED_ELEMENT_CLOSE_OPACITY_RANGE = [0.6, 1, 0, 1] as const;

package/src/shared/utils/bounds/navigation/zoom/math.ts

@@ -1,25 +1,23 @@
 export const resolveDirectionalDragTranslation = ({
-	normalized,
+	translation,
 	dimension,
-	resistance,
 	negativeMax,
 	positiveMax,
 	exponent = 1,
 }: {
-	normalized: number;
+	translation: number;
 	dimension: number;
-	resistance: number;
 	negativeMax: number;
 	positiveMax: number;
 	exponent?: number;
 }) => {
 	"worklet";
 
-	const clampedMagnitude = Math.min(1, Math.abs(normalized));
+	const baseDistance = Math.max(1, dimension);
+	const clampedMagnitude = Math.min(1, Math.abs(translation) / baseDistance);
 	const curvedMagnitude = clampedMagnitude ** Math.max(1, exponent);
-	const baseDistance = Math.max(0, dimension) * resistance;
 
-	if (normalized < 0) {
+	if (translation < 0) {
 		return -baseDistance * negativeMax * curvedMagnitude;
 	}
 

package/src/shared/utils/gesture-progress-mode.ts

@@ -0,0 +1,67 @@
+import type { GestureProgressMode } from "../types/gesture.types";
+
+type GestureProgressModeOptions = {
+	gestureProgressMode?: GestureProgressMode;
+	gestureDrivesProgress?: boolean;
+};
+
+type ResolveGestureProgressModeOptions = GestureProgressModeOptions & {
+	fallback?: GestureProgressMode;
+};
+
+export const isGestureProgressMode = (
+	value: unknown,
+): value is GestureProgressMode => {
+	"worklet";
+	return value === "progress-driven" || value === "freeform";
+};
+
+export const resolveGestureProgressMode = (
+	options: ResolveGestureProgressModeOptions | boolean | undefined,
+): GestureProgressMode => {
+	"worklet";
+	if (typeof options === "boolean" || options === undefined) {
+		return options === false ? "freeform" : "progress-driven";
+	}
+
+	if (isGestureProgressMode(options.gestureProgressMode)) {
+		return options.gestureProgressMode;
+	}
+
+	if (typeof options.gestureDrivesProgress === "boolean") {
+		return options.gestureDrivesProgress ? "progress-driven" : "freeform";
+	}
+
+	return options.fallback ?? "progress-driven";
+};
+
+export const resolveGestureProgressModeFromOptions = (
+	primary: GestureProgressModeOptions | undefined,
+	fallback: GestureProgressModeOptions | undefined,
+	defaultMode: GestureProgressMode = "progress-driven",
+): GestureProgressMode => {
+	"worklet";
+	if (
+		primary &&
+		(isGestureProgressMode(primary.gestureProgressMode) ||
+			typeof primary.gestureDrivesProgress === "boolean")
+	) {
+		return resolveGestureProgressMode({
+			gestureProgressMode: primary.gestureProgressMode,
+			gestureDrivesProgress: primary.gestureDrivesProgress,
+		});
+	}
+
+	return resolveGestureProgressMode({
+		gestureProgressMode: fallback?.gestureProgressMode,
+		gestureDrivesProgress: fallback?.gestureDrivesProgress,
+		fallback: defaultMode,
+	});
+};
+
+export const gestureProgressModeDrivesProgress = (
+	mode: GestureProgressMode,
+) => {
+	"worklet";
+	return mode === "progress-driven";
+};

package/src/shared/utils/resolve-chain-target.ts

@@ -1,4 +1,4 @@
-export type ChainTarget = "self" | "parent" | "root" | { ancestor: number };
+export type ChainTarget = { depth: number };
 
 type ResolveChainTargetParams<T> = {
 	target: ChainTarget | undefined;
@@ -6,41 +6,28 @@ type ResolveChainTargetParams<T> = {
 	ancestors: readonly T[];
 };
 
-const isAncestorTarget = (
-	target: ChainTarget,
-): target is { ancestor: number } => {
-	return typeof target === "object" && target !== null && "ancestor" in target;
-};
-
 export function resolveChainTarget<T>({
 	target,
 	self,
 	ancestors,
 }: ResolveChainTargetParams<T>): T | null {
+	"worklet";
 	if (!self) {
 		return null;
 	}
 
-	if (!target || target === "self") {
-		return self;
-	}
-
-	if (target === "parent") {
-		return ancestors[0] ?? null;
-	}
-
-	if (target === "root") {
-		return ancestors[ancestors.length - 1] ?? null;
+	const depth = target?.depth ?? 0;
+	if (!Number.isInteger(depth)) {
+		return null;
 	}
 
-	if (!isAncestorTarget(target)) {
-		return null;
+	if (depth === 0) {
+		return self;
 	}
 
-	const depth = target.ancestor;
-	if (!Number.isInteger(depth) || depth < 1) {
+	if (depth > 0) {
 		return null;
 	}
 
-	return ancestors[depth - 1] ?? null;
+	return ancestors[Math.abs(depth) - 1] ?? null;
 }

package/src/shared/utils/resolve-screen-transition-options.ts

@@ -1,11 +1,9 @@
+import { DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR } from "../constants";
 import type {
 	ScreenTransitionConfig,
 	SheetScrollGestureBehavior,
 } from "../types/screen.types";
 
-export const DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR: SheetScrollGestureBehavior =
-	"expand-and-collapse";
-
 export const resolveSheetScrollGestureBehavior = (
 	options: Pick<
 		ScreenTransitionConfig,

package/lib/commonjs/shared/hooks/reanimated/use-animated-debounce.js

@@ -1,43 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useAnimatedDebounce = useAnimatedDebounce;
-var _reactNativeReanimated = require("react-native-reanimated");
-const SCROLL_SETTLE_DELAY_MS = 25;
-/**
- * Debounces a UI-thread callback using Reanimated timing primitives.
- *
- * Call `trigger()` from a worklet to reset the debounce window. When no new
- * trigger arrives within `delayMs`, `onDebounced` fires once on the UI thread.
- */
-function useAnimatedDebounce(onDebounced, delayMs = SCROLL_SETTLE_DELAY_MS) {
-  const token = (0, _reactNativeReanimated.useSharedValue)(0);
-  const trigger = () => {
-    "worklet";
-
-    (0, _reactNativeReanimated.cancelAnimation)(token);
-    token.set((0, _reactNativeReanimated.withDelay)(delayMs, (0, _reactNativeReanimated.withTiming)(token.get() + 1, {
-      duration: 0
-    })));
-  };
-  const cancel = () => {
-    "worklet";
-
-    (0, _reactNativeReanimated.cancelAnimation)(token);
-  };
-  (0, _reactNativeReanimated.useAnimatedReaction)(() => token.get(), (nextToken, previousToken) => {
-    "worklet";
-
-    if (nextToken === 0 || nextToken === previousToken) {
-      return;
-    }
-    onDebounced();
-  }, [delayMs, onDebounced]);
-  return {
-    trigger,
-    cancel
-  };
-}
-//# sourceMappingURL=use-animated-debounce.js.map

package/lib/commonjs/shared/hooks/reanimated/use-animated-debounce.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_reactNativeReanimated","require","SCROLL_SETTLE_DELAY_MS","useAnimatedDebounce","onDebounced","delayMs","token","useSharedValue","trigger","cancelAnimation","set","withDelay","withTiming","get","duration","cancel","useAnimatedReaction","nextToken","previousToken"],"sourceRoot":"../../../../../src","sources":["shared/hooks/reanimated/use-animated-debounce.ts"],"mappings":";;;;;;AAAA,IAAAA,sBAAA,GAAAC,OAAA;AAQA,MAAMC,sBAAsB,GAAG,EAAE;AAOjC;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAClCC,WAAuB,EACvBC,OAAe,GAAGH,sBAAsB,EACb;EAC3B,MAAMI,KAAK,GAAG,IAAAC,qCAAc,EAAC,CAAC,CAAC;EAE/B,MAAMC,OAAO,GAAGA,CAAA,KAAM;IACrB,SAAS;;IACT,IAAAC,sCAAe,EAACH,KAAK,CAAC;IACtBA,KAAK,CAACI,GAAG,CAAC,IAAAC,gCAAS,EAACN,OAAO,EAAE,IAAAO,iCAAU,EAACN,KAAK,CAACO,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE;MAAEC,QAAQ,EAAE;IAAE,CAAC,CAAC,CAAC,CAAC;EAC5E,CAAC;EAED,MAAMC,MAAM,GAAGA,CAAA,KAAM;IACpB,SAAS;;IACT,IAAAN,sCAAe,EAACH,KAAK,CAAC;EACvB,CAAC;EAED,IAAAU,0CAAmB,EAClB,MAAMV,KAAK,CAACO,GAAG,CAAC,CAAC,EACjB,CAACI,SAAS,EAAEC,aAAa,KAAK;IAC7B,SAAS;;IACT,IAAID,SAAS,KAAK,CAAC,IAAIA,SAAS,KAAKC,aAAa,EAAE;MACnD;IACD;IAEAd,WAAW,CAAC,CAAC;EACd,CAAC,EACD,CAACC,OAAO,EAAED,WAAW,CACtB,CAAC;EAED,OAAO;IAAEI,OAAO;IAAEO;EAAO,CAAC;AAC3B","ignoreList":[]}

package/lib/commonjs/shared/providers/screen/animation/helpers/hydrate-transition-state.js

@@ -1,164 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.hydrateTransitionState = exports.computeLogicallySettled = void 0;
-var _constants = require("../../../../constants");
-const computeSettled = (animating, dismissing, closing) => {
-  "worklet";
-
-  return animating || dismissing || closing ? _constants.FALSE : _constants.TRUE;
-};
-const getResolvedSnapPointCount = (snapPoints, resolvedAutoSnap) => {
-  "worklet";
-
-  return snapPoints.length + (resolvedAutoSnap !== null ? 1 : 0);
-};
-const getAutoSnapPointIndex = (snapPoints, resolvedAutoSnap) => {
-  "worklet";
-
-  let index = 0;
-  while (index < snapPoints.length && snapPoints[index] <= resolvedAutoSnap) {
-    index++;
-  }
-  return index;
-};
-const getResolvedSnapPointAt = (snapPoints, resolvedAutoSnap, autoSnapPointIndex, index) => {
-  "worklet";
-
-  if (resolvedAutoSnap === null) {
-    return snapPoints[index];
-  }
-  if (index < autoSnapPointIndex) {
-    return snapPoints[index];
-  }
-  if (index === autoSnapPointIndex) {
-    return resolvedAutoSnap;
-  }
-  return snapPoints[index - 1];
-};
-const computeAnimatedSnapIndex = (progress, snapPoints, resolvedAutoSnap) => {
-  "worklet";
-
-  const snapPointCount = getResolvedSnapPointCount(snapPoints, resolvedAutoSnap);
-  if (snapPointCount === 0) return -1;
-  const autoSnapPointIndex = resolvedAutoSnap === null ? -1 : getAutoSnapPointIndex(snapPoints, resolvedAutoSnap);
-  const firstSnapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, 0);
-  const lastSnapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, snapPointCount - 1);
-  if (progress <= firstSnapPoint) return 0;
-  if (progress >= lastSnapPoint) return snapPointCount - 1;
-  for (let i = 0; i < snapPointCount - 1; i++) {
-    const currentSnapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, i);
-    const nextSnapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, i + 1);
-    if (progress <= nextSnapPoint) {
-      const t = (progress - currentSnapPoint) / (nextSnapPoint - currentSnapPoint);
-      return i + t;
-    }
-  }
-  return snapPointCount - 1;
-};
-const computeTargetSnapIndex = (targetProgress, snapPoints, resolvedAutoSnap) => {
-  "worklet";
-
-  const snapPointCount = getResolvedSnapPointCount(snapPoints, resolvedAutoSnap);
-  if (snapPointCount === 0) return -1;
-  const autoSnapPointIndex = resolvedAutoSnap === null ? -1 : getAutoSnapPointIndex(snapPoints, resolvedAutoSnap);
-  const firstSnapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, 0);
-  if (targetProgress <= 0 && Math.abs(firstSnapPoint) > _constants.EPSILON) {
-    return -1;
-  }
-  let nearestIndex = 0;
-  let smallestDistance = Math.abs(targetProgress - firstSnapPoint);
-  for (let i = 1; i < snapPointCount; i++) {
-    const snapPoint = getResolvedSnapPointAt(snapPoints, resolvedAutoSnap, autoSnapPointIndex, i);
-    const distance = Math.abs(targetProgress - snapPoint);
-    if (distance < smallestDistance) {
-      smallestDistance = distance;
-      nearestIndex = i;
-    }
-  }
-  return nearestIndex;
-};
-const computeLogicallySettledValue = (progress, targetProgress, settled, gestureActive) => {
-  "worklet";
-
-  if (settled) {
-    return _constants.TRUE;
-  }
-  if (gestureActive) {
-    return _constants.FALSE;
-  }
-  return Math.abs(progress - targetProgress) <= _constants.ANIMATION_SNAP_THRESHOLD ? _constants.TRUE : _constants.FALSE;
-};
-const computeLogicallySettled = params => {
-  "worklet";
-
-  return computeLogicallySettledValue(params.progress, params.targetProgress, params.settled, params.gestureActive);
-};
-exports.computeLogicallySettled = computeLogicallySettled;
-const hydrateTransitionState = (s, dimensions) => {
-  "worklet";
-
-  const out = s.unwrapped;
-  out.progress = s.progress.get();
-  out.willAnimate = s.willAnimate.get();
-  out.closing = s.closing.get();
-  out.entering = s.entering.get();
-  out.gesture.x = s.gesture.x.get();
-  out.gesture.y = s.gesture.y.get();
-  out.gesture.normX = s.gesture.normX.get();
-  out.gesture.normY = s.gesture.normY.get();
-  out.gesture.scale = s.gesture.scale.get();
-  out.gesture.normScale = s.gesture.normScale.get();
-  out.gesture.focalX = s.gesture.focalX.get();
-  out.gesture.focalY = s.gesture.focalY.get();
-  out.gesture.raw.x = s.gesture.raw.x.get();
-  out.gesture.raw.y = s.gesture.raw.y.get();
-  out.gesture.raw.normX = s.gesture.raw.normX.get();
-  out.gesture.raw.normY = s.gesture.raw.normY.get();
-  out.gesture.raw.scale = s.gesture.raw.scale.get();
-  out.gesture.raw.normScale = s.gesture.raw.normScale.get();
-  out.gesture.dismissing = s.gesture.dismissing.get();
-  out.gesture.dragging = s.gesture.dragging.get();
-  out.gesture.settling = s.gesture.settling.get();
-  out.gesture.active = s.gesture.active.get();
-  out.gesture.direction = s.gesture.direction.get();
-  const isGestureSettling = Math.abs(out.gesture.normX) > _constants.EPSILON || Math.abs(out.gesture.normY) > _constants.EPSILON || Math.abs(out.gesture.normScale) > _constants.EPSILON;
-  const isGestureActive = out.gesture.dragging || out.gesture.settling || isGestureSettling ? _constants.TRUE : _constants.FALSE;
-  out.animating = s.animating.get() || isGestureActive ? 1 : 0;
-  out.gesture.normalizedX = out.gesture.normX;
-  out.gesture.normalizedY = out.gesture.normY;
-  out.gesture.isDismissing = out.gesture.dismissing;
-  out.gesture.isDragging = out.gesture.dragging;
-  out.settled = computeSettled(out.animating, out.gesture.dismissing, out.closing);
-  const targetProgress = s.targetProgress.get();
-  out.logicallySettled = computeLogicallySettledValue(out.progress, targetProgress, out.settled, isGestureActive);
-  if (s.settled.get() !== out.settled) {
-    s.settled.set(out.settled);
-  }
-  if (s.logicallySettled.get() !== out.logicallySettled) {
-    s.logicallySettled.set(out.logicallySettled);
-  }
-  out.meta = s.meta;
-  out.options = s.options;
-  out.route = s.route;
-  out.layouts.screen.width = dimensions.width;
-  out.layouts.screen.height = dimensions.height;
-  out.layouts.navigationMaskEnabled = s.navigationMaskEnabled;
-  const content = s.measuredContentLayout.get();
-  if (content) {
-    s.contentLayoutSlot.width = content.width;
-    s.contentLayoutSlot.height = content.height;
-    out.layouts.content = s.contentLayoutSlot;
-  } else {
-    out.layouts.content = undefined;
-  }
-  const autoSnapPoint = s.resolvedAutoSnapPoint.get();
-  const resolvedAutoSnap = s.hasAutoSnapPoint && autoSnapPoint > 0 ? autoSnapPoint : null;
-  out.animatedSnapIndex = computeAnimatedSnapIndex(out.progress, s.sortedNumericSnapPoints, resolvedAutoSnap);
-  out.snapIndex = computeTargetSnapIndex(targetProgress, s.sortedNumericSnapPoints, resolvedAutoSnap);
-  return out;
-};
-exports.hydrateTransitionState = hydrateTransitionState;
-//# sourceMappingURL=hydrate-transition-state.js.map