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

package/src/shared/utils/bounds/index.ts

@@ -3,65 +3,40 @@ import type {
 	BoundsInterpolationProps,
 	BoundsNavigationZoomOptions,
 } from "../../types/bounds.types";
-import { createBoundTag } from "./helpers/create-bound-tag";
-import { createInterpolators } from "./helpers/create-interpolators";
-import { createLinkAccessor } from "./helpers/create-link-accessor";
-import { prepareBoundStyles } from "./helpers/prepare-bound-styles";
-import type { BoundsOptions } from "./types/options";
-import { buildZoomStyles } from "./zoom/build";
+import { createBoundsAccessorCore } from "./helpers/create-bounds-accessor-core";
+import { buildRevealStyles } from "./navigation/reveal/build";
+import { buildZoomStyles } from "./navigation/zoom/build";
 
 export const createBoundsAccessor = (
 	getProps: () => BoundsInterpolationProps,
 ): BoundsAccessor => {
 	"worklet";
 
-	const computeBounds = (params?: BoundsOptions) => {
-		"worklet";
-		const props = getProps();
-		const options = (params ?? { id: "" }) as BoundsOptions;
-		const computed = prepareBoundStyles({
-			props,
-			options,
-		});
-		// Navigation helpers are intentionally opinionated. Only the resolved
-		// tag from `id`/`group` is allowed to flow into `navigation.zoom()`;
-		// base bounds overrides like `target`, `anchor`, or `scaleMode` must not.
-		const tag = createBoundTag({
-			id: options.id,
-			group: options.group,
-		});
-
-		const target = Object.isExtensible(computed) ? computed : { ...computed };
-
-		Object.defineProperty(target, "navigation", {
-			value: {
-				zoom: (zoomOptions?: BoundsNavigationZoomOptions) => {
-					"worklet";
-					return buildZoomStyles({
-						props,
-						tag,
-						zoomOptions,
-					});
-				},
-			},
-			enumerable: false,
-			configurable: true,
-		});
-
-		return target;
-	};
-
-	const { getMeasured, getSnapshot, getLink } = createLinkAccessor(getProps);
-	const { interpolateStyle, interpolateBounds } = createInterpolators({
+	return createBoundsAccessorCore({
 		getProps,
-		getLink,
-	});
-
-	return Object.assign(computeBounds, {
-		getMeasured,
-		getSnapshot,
-		getLink,
-		interpolateStyle,
-		interpolateBounds,
+		extendResult: ({ target, props, tag }) => {
+			"worklet";
+			Object.defineProperty(target, "navigation", {
+				value: {
+					zoom: (zoomOptions?: BoundsNavigationZoomOptions) => {
+						"worklet";
+						return buildZoomStyles({
+							props,
+							tag,
+							zoomOptions,
+						});
+					},
+					reveal: () => {
+						"worklet";
+						return buildRevealStyles({
+							props,
+							tag,
+						});
+					},
+				},
+				enumerable: false,
+				configurable: true,
+			});
+		},
 	}) as BoundsAccessor;
 };

package/src/shared/utils/bounds/navigation/helpers.ts

@@ -0,0 +1,14 @@
+import type { BoundsLink } from "../../../types/bounds.types";
+
+export function getSourceBorderRadius(link: BoundsLink): number {
+	"worklet";
+
+	return typeof link.source?.styles.borderRadius === "number"
+		? link.source.styles.borderRadius
+		: 0;
+}
+
+export const toNumber = (value: unknown, fallback = 0): number => {
+	"worklet";
+	return typeof value === "number" ? value : fallback;
+};

package/src/shared/utils/bounds/{zoom → navigation}/math.ts

@@ -1,29 +1,13 @@
-import { interpolate } from "react-native-reanimated";
+import { clamp, interpolate } from "react-native-reanimated";
 
-export type CombinedScaleMode = "multiply" | "average" | "max" | "min";
+type CombinedScaleMode = "multiply" | "average" | "max" | "min";
 
-export const clamp = (value: number, min: number, max: number): number => {
-	"worklet";
-	const lower = min < max ? min : max;
-	const upper = max > min ? max : min;
-
-	if (value < lower) return lower;
-	if (value > upper) return upper;
-
-	return value;
-};
-
-export const clamp01 = (value: number): number => {
-	"worklet";
-	return clamp(value, 0, 1);
-};
-
-export const lerp = (from: number, to: number, t: number): number => {
+const lerp = (from: number, to: number, t: number): number => {
 	"worklet";
 	return from + (to - from) * t;
 };
 
-export const safeDivide = (
+const safeDivide = (
 	numerator: number,
 	denominator: number,
 	fallback = 0,
@@ -33,16 +17,12 @@ export const safeDivide = (
 	return numerator / denominator;
 };
 
-export const inverseLerp = (
-	value: number,
-	inMin: number,
-	inMax: number,
-): number => {
+const inverseLerp = (value: number, inMin: number, inMax: number): number => {
 	"worklet";
 	return safeDivide(value - inMin, inMax - inMin, 0);
 };
 
-export const mapRangeClamped = (
+const mapRangeClamped = (
 	value: number,
 	inMin: number,
 	inMax: number,
@@ -50,32 +30,18 @@ export const mapRangeClamped = (
 	outMax: number,
 ): number => {
 	"worklet";
-	const t = clamp01(inverseLerp(value, inMin, inMax));
+	const t = clamp(inverseLerp(value, inMin, inMax), 0, 1);
 	return lerp(outMin, outMax, t);
 };
 
-export const applyPowerCurve = (value: number, exponent: number): number => {
+const applyPowerCurve = (value: number, exponent: number): number => {
 	"worklet";
 	const safeExponent = exponent > 0 ? exponent : 1;
 	const magnitude = Math.abs(value) ** safeExponent;
 	return value < 0 ? -magnitude : magnitude;
 };
 
-export const normalizedToTranslation = ({
-	normalized,
-	dimension,
-	resistance,
-}: {
-	normalized: number;
-	dimension: number;
-	resistance: number;
-}): number => {
-	"worklet";
-	const distance = Math.max(0, dimension) * resistance;
-	return mapRangeClamped(normalized, -1, 1, -distance, distance);
-};
-
-export const normalizedToScale = ({
+const normalizedToScale = ({
 	normalized,
 	outputRange,
 	exponent = 1,
@@ -127,7 +93,7 @@ export const computeCenterScaleShift = ({
 	return (center - containerCenter) * (scale - 1);
 };
 
-export const compensateTranslationForParentScale = ({
+const compensateTranslationForParentScale = ({
 	translation,
 	parentScale,
 	epsilon,
@@ -192,34 +158,6 @@ export const resolveDirectionalDragScale = ({
 	return interpolate(oppositeDrag, [0, 1], [1, growMax], "clamp");
 };
 
-export const resolveDirectionalDragTranslation = ({
-	normalized,
-	dimension,
-	resistance,
-	negativeMax,
-	positiveMax,
-	exponent = 1,
-}: {
-	normalized: number;
-	dimension: number;
-	resistance: number;
-	negativeMax: number;
-	positiveMax: number;
-	exponent?: number;
-}) => {
-	"worklet";
-
-	const clampedMagnitude = Math.min(1, Math.abs(normalized));
-	const curvedMagnitude = clampedMagnitude ** Math.max(1, exponent);
-	const baseDistance = Math.max(0, dimension) * resistance;
-
-	if (normalized < 0) {
-		return -baseDistance * negativeMax * curvedMagnitude;
-	}
-
-	return baseDistance * positiveMax * curvedMagnitude;
-};
-
 export const resolveOpacityRangeTuple = ({
 	value,
 	fallback,