react-native-screen-transitions 3.2.1 → 3.3.0-beta.1

package/lib/typescript/shared/utils/gesture/validate-snap-points.d.ts

@@ -0,0 +1,13 @@
+interface ValidateSnapPointsResult {
+    hasSnapPoints: boolean;
+    snapPoints: number[];
+    minSnapPoint: number;
+    maxSnapPoint: number;
+}
+interface ValidateSnapPointsOptions {
+    snapPoints?: number[];
+    canDismiss?: boolean;
+}
+export declare const validateSnapPoints: ({ snapPoints, canDismiss, }: ValidateSnapPointsOptions) => ValidateSnapPointsResult;
+export {};
+//# sourceMappingURL=validate-snap-points.d.ts.map

package/lib/typescript/shared/utils/gesture/validate-snap-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-snap-points.d.ts","sourceRoot":"","sources":["../../../../../src/shared/utils/gesture/validate-snap-points.ts"],"names":[],"mappings":"AAAA,UAAU,wBAAwB;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,yBAAyB;IAClC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,kBAAkB,GAAI,6BAGhC,yBAAyB,KAAG,wBAqB9B,CAAC"}

package/lib/typescript/shared/utils/gesture/velocity.d.ts

@@ -17,6 +17,7 @@ interface CalculateProgressProps {
 }
 export declare const velocity: {
     normalize: (velocityPixelsPerSecond: number, screenSize: number) => number;
+    normalizeTranslation: (translation: number, dimension: number) => number;
     calculateRestoreVelocity: (currentValueNormalized: number, baseVelocityNormalized: number) => number;
     calculateProgressVelocity: ({ animations, shouldDismiss, event, dimensions, directions, }: CalculateProgressProps) => number;
     shouldPassDismissalThreshold: (translationPixels: number, velocityPixelsPerSecond: number, screenSize: number, velocityWeight: number) => boolean;

package/lib/typescript/shared/utils/gesture/velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"velocity.d.ts","sourceRoot":"","sources":["../../../../../src/shared/utils/gesture/velocity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,uBAAuB,EACvB,6BAA6B,EAC7B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,UAAU,sBAAsB;IAC/B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,uBAAuB,CAAC,6BAA6B,CAAC,CAAC;IAC9D,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,UAAU,EAAE;QACX,UAAU,EAAE,OAAO,CAAC;QACpB,kBAAkB,EAAE,OAAO,CAAC;QAC5B,QAAQ,EAAE,OAAO,CAAC;QAClB,gBAAgB,EAAE,OAAO,CAAC;KAC1B,CAAC;CACF;AAuHD,eAAO,MAAM,QAAQ;yCA9GuB,MAAM,cAAc,MAAM;uDAc7C,MAAM,0BACN,MAAM;+FAkB5B,sBAAsB;sDAyDL,MAAM,2BACA,MAAM,cACnB,MAAM,kBACF,MAAM;CAsBtB,CAAC"}
+{"version":3,"file":"velocity.d.ts","sourceRoot":"","sources":["../../../../../src/shared/utils/gesture/velocity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,uBAAuB,EACvB,6BAA6B,EAC7B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,UAAU,sBAAsB;IAC/B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,uBAAuB,CAAC,6BAA6B,CAAC,CAAC;IAC9D,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,UAAU,EAAE;QACX,UAAU,EAAE,OAAO,CAAC;QACpB,kBAAkB,EAAE,OAAO,CAAC;QAC5B,QAAQ,EAAE,OAAO,CAAC;QAClB,gBAAgB,EAAE,OAAO,CAAC;KAC1B,CAAC;CACF;AAgID,eAAO,MAAM,QAAQ;yCAvHuB,MAAM,cAAc,MAAM;wCAa3B,MAAM,aAAa,MAAM;uDAU3C,MAAM,0BACN,MAAM;+FAkB5B,sBAAsB;sDAyDL,MAAM,2BACA,MAAM,cACnB,MAAM,kBACF,MAAM;CAuBtB,CAAC"}

package/lib/typescript/shared/utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    error(message: string): void;
+    warn(message: string): void;
+};
+export declare const error: (message: string) => Error;
+//# sourceMappingURL=logger.d.ts.map

package/lib/typescript/shared/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../src/shared/utils/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;mBACH,MAAM;kBAIP,MAAM;CAIpB,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,SAAS,MAAM,UACK,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-screen-transitions",
-  "version": "3.2.1",
+  "version": "3.3.0-beta.1",
   "description": "Easy screen transitions for React Native and Expo",
   "author": "Ed",
   "license": "MIT",
@@ -44,7 +44,8 @@
     "lint": "biome check ./src",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run build",
-    "release": "release-it"
+    "release": "release-it",
+    "release:beta": "release-it --preRelease=beta"
   },
   "keywords": [
     "react-native",

package/src/blank-stack/components/adjusted-screen.tsx

@@ -9,6 +9,7 @@ import Animated, {
 	useSharedValue,
 } from "react-native-reanimated";
 import { Screen as RNSScreen } from "react-native-screens";
+import { EPSILON } from "../../shared/constants";
 import { useStack } from "../../shared/hooks/navigation/use-stack";
 import { LayoutAnchorProvider } from "../../shared/providers/layout-anchor.provider";
 import { useManagedStackContext } from "../../shared/providers/stack/managed.provider";
@@ -28,7 +29,6 @@ enum ScreenActivity {
 	ON_TOP = 2,
 }
 
-const EPSILON = 1e-5;
 const POINT_NONE = "none" as const;
 const POINT_BOX_NONE = "box-none" as const;
 

package/src/shared/__tests__/derivations.test.ts

@@ -8,6 +8,7 @@ const createMockState = (
 	progress: 1,
 	closing: 0,
 	animating: 0,
+	entering: 1,
 	gesture: {
 		isDragging: 0,
 		x: 0,

package/src/shared/__tests__/determine-snap-target.test.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it } from "bun:test";
+import { determineSnapTarget } from "../utils/gesture/determine-snap-target";
+
+describe("determineSnapTarget", () => {
+	const dimension = 800; // screen height
+	const snapPoints = [0.3, 0.6, 1]; // 3 snap points
+
+	describe("basic snapping without velocity", () => {
+		it("snaps to nearest snap point when exactly at a snap point", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.6,
+				snapPoints,
+				velocity: 0,
+				dimension,
+			});
+			expect(result.targetProgress).toBe(0.6);
+			expect(result.shouldDismiss).toBe(false);
+		});
+
+		it("snaps to lower snap point when below midpoint", () => {
+			// Midpoint between 0.3 and 0.6 is 0.45
+			const result = determineSnapTarget({
+				currentProgress: 0.4,
+				snapPoints,
+				velocity: 0,
+				dimension,
+			});
+			expect(result.targetProgress).toBe(0.3);
+		});
+
+		it("snaps to higher snap point when above midpoint", () => {
+			// Midpoint between 0.3 and 0.6 is 0.45
+			const result = determineSnapTarget({
+				currentProgress: 0.5,
+				snapPoints,
+				velocity: 0,
+				dimension,
+			});
+			expect(result.targetProgress).toBe(0.6);
+		});
+
+		it("snaps to highest point when above all snap points", () => {
+			const result = determineSnapTarget({
+				currentProgress: 1.2,
+				snapPoints,
+				velocity: 0,
+				dimension,
+			});
+			expect(result.targetProgress).toBe(1);
+		});
+	});
+
+	describe("velocity influence", () => {
+		it("velocity toward dismiss pushes toward lower snap point", () => {
+			// At 0.5 (above midpoint 0.45), normally would snap to 0.6
+			// But positive velocity (toward dismiss) should push toward 0.3
+			const result = determineSnapTarget({
+				currentProgress: 0.5,
+				snapPoints,
+				velocity: 800, // Strong velocity toward dismiss
+				dimension,
+				velocityFactor: 0.15,
+			});
+			expect(result.targetProgress).toBe(0.3);
+		});
+
+		it("velocity toward expand pushes toward higher snap point", () => {
+			// At 0.4 (below midpoint 0.45), normally would snap to 0.3
+			// But negative velocity (toward expand) should push toward 0.6
+			const result = determineSnapTarget({
+				currentProgress: 0.4,
+				snapPoints,
+				velocity: -800, // Strong velocity toward expand
+				dimension,
+				velocityFactor: 0.15,
+			});
+			expect(result.targetProgress).toBe(0.6);
+		});
+
+		it("weak velocity does not override position", () => {
+			// At 0.55 (above midpoint), weak velocity shouldn't change target
+			const result = determineSnapTarget({
+				currentProgress: 0.55,
+				snapPoints,
+				velocity: 100, // Weak velocity
+				dimension,
+				velocityFactor: 0.15,
+			});
+			expect(result.targetProgress).toBe(0.6);
+		});
+
+		it("respects custom velocityFactor", () => {
+			// Higher velocityFactor = velocity has more influence
+			const result = determineSnapTarget({
+				currentProgress: 0.5,
+				snapPoints,
+				velocity: 400,
+				dimension,
+				velocityFactor: 0.5, // High factor
+			});
+			expect(result.targetProgress).toBe(0.3);
+		});
+	});
+
+	describe("dismiss behavior", () => {
+		it("allows dismiss when canDismiss is true and near 0", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.1,
+				snapPoints,
+				velocity: 500,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0);
+			expect(result.shouldDismiss).toBe(true);
+		});
+
+		it("prevents dismiss when canDismiss is false", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.1,
+				snapPoints,
+				velocity: 1000, // Strong dismiss velocity
+				dimension,
+				canDismiss: false,
+			});
+			expect(result.targetProgress).toBe(0.3); // First snap point
+			expect(result.shouldDismiss).toBe(false);
+		});
+
+		it("defaults canDismiss to true", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.1,
+				snapPoints,
+				velocity: 500,
+				dimension,
+			});
+			expect(result.shouldDismiss).toBe(true);
+		});
+
+		it("shouldDismiss is false when snapping to any snap point", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.5,
+				snapPoints,
+				velocity: 0,
+				dimension,
+			});
+			expect(result.shouldDismiss).toBe(false);
+		});
+	});
+
+	describe("edge cases", () => {
+		it("handles single snap point", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.3,
+				snapPoints: [0.5],
+				velocity: 0,
+				dimension,
+			});
+			expect(result.targetProgress).toBe(0.5);
+		});
+
+		it("handles unsorted snap points", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.5,
+				snapPoints: [1, 0.3, 0.6], // Unsorted
+				velocity: 0,
+				dimension,
+			});
+			// After sorting: [0.3, 0.6, 1], midpoint 0.3-0.6 is 0.45
+			expect(result.targetProgress).toBe(0.6);
+		});
+
+		it("handles progress at exactly 0", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0,
+				snapPoints,
+				velocity: 0,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0);
+			expect(result.shouldDismiss).toBe(true);
+		});
+
+		it("handles negative progress", () => {
+			const result = determineSnapTarget({
+				currentProgress: -0.1,
+				snapPoints,
+				velocity: 0,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0);
+		});
+
+		it("handles very high velocity", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.9,
+				snapPoints,
+				velocity: 5000, // Very high velocity
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0);
+			expect(result.shouldDismiss).toBe(true);
+		});
+
+		it("handles snap points not starting at typical values", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.7,
+				snapPoints: [0.5, 0.75, 1],
+				velocity: 0,
+				dimension,
+			});
+			// Midpoint between 0.5 and 0.75 is 0.625
+			// 0.7 is above 0.625, so should snap to 0.75
+			expect(result.targetProgress).toBe(0.75);
+		});
+
+		it("handles two snap points", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.4,
+				snapPoints: [0.3, 1],
+				velocity: 0,
+				dimension,
+			});
+			// Midpoint is 0.65, 0.4 is below, so snap to 0.3
+			expect(result.targetProgress).toBe(0.3);
+		});
+	});
+
+	describe("zone boundaries", () => {
+		it("snaps to higher at exact midpoint (uses < not <=)", () => {
+			// Midpoint between 0 and 0.3 is 0.15
+			// The algorithm uses `<` so at exact midpoint, it snaps to higher
+			const result = determineSnapTarget({
+				currentProgress: 0.15,
+				snapPoints,
+				velocity: 0,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0.3);
+		});
+
+		it("snaps to lower just below midpoint", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.149,
+				snapPoints,
+				velocity: 0,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0);
+		});
+
+		it("snaps to higher just above midpoint", () => {
+			const result = determineSnapTarget({
+				currentProgress: 0.151,
+				snapPoints,
+				velocity: 0,
+				dimension,
+				canDismiss: true,
+			});
+			expect(result.targetProgress).toBe(0.3);
+		});
+	});
+});

package/src/shared/__tests__/gesture-activation.test.ts

@@ -1,11 +1,27 @@
 import { describe, expect, it } from "bun:test";
+import type { ScrollConfig } from "../providers/gestures.provider";
 import {
 	normalizeSides,
 	computeEdgeConstraints,
 	calculateSwipeDirs,
 	shouldActivateOrFail,
+	checkScrollAwareActivation,
 } from "../utils/gesture/check-gesture-activation";
 
+/** Helper to create ScrollConfig with sensible defaults */
+const createScrollConfig = (
+	overrides: Partial<ScrollConfig> = {},
+): ScrollConfig => ({
+	x: 0,
+	y: 0,
+	contentWidth: 0,
+	contentHeight: 0,
+	layoutWidth: 0,
+	layoutHeight: 0,
+	isTouched: true,
+	...overrides,
+});
+
 describe("normalizeSides", () => {
 	it("returns all sides as 'screen' when no area provided", () => {
 		const result = normalizeSides();
@@ -249,3 +265,207 @@ describe("shouldActivateOrFail", () => {
 		expect(result.shouldActivate).toBe(true);
 	});
 });
+
+describe("checkScrollAwareActivation", () => {
+	const baseDirections = {
+		vertical: true,
+		verticalInverted: false,
+		horizontal: false,
+		horizontalInverted: false,
+	};
+
+	const noSwipe = {
+		isSwipingDown: false,
+		isSwipingUp: false,
+		isSwipingRight: false,
+		isSwipingLeft: false,
+	};
+
+	describe("vertical sheet (dismiss down)", () => {
+		it("activates when swiping down at scroll top", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingDown: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("vertical");
+		});
+
+		it("does not activate when swiping down but scroll is not at top", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingDown: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ y: 100, contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+
+		it("does not activate when swiping up without snap points", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+	});
+
+	describe("vertical inverted sheet (dismiss up)", () => {
+		const invertedDirections = {
+			vertical: false,
+			verticalInverted: true,
+			horizontal: false,
+			horizontalInverted: false,
+		};
+
+		it("activates when swiping up at scroll bottom", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: invertedDirections,
+				scrollConfig: createScrollConfig({ y: 500, contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("vertical-inverted");
+		});
+
+		it("does not activate when swiping up but scroll is not at bottom", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: invertedDirections,
+				scrollConfig: createScrollConfig({ y: 200, contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+	});
+
+	describe("horizontal sheet (dismiss right)", () => {
+		const horizontalDirections = {
+			vertical: false,
+			verticalInverted: false,
+			horizontal: true,
+			horizontalInverted: false,
+		};
+
+		it("activates when swiping right at scroll left edge", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingRight: true },
+				directions: horizontalDirections,
+				scrollConfig: createScrollConfig({ contentWidth: 500, layoutWidth: 0 }),
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("horizontal");
+		});
+
+		it("does not activate when scroll is not at left edge", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingRight: true },
+				directions: horizontalDirections,
+				scrollConfig: createScrollConfig({ x: 100, contentWidth: 500, layoutWidth: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+	});
+
+	describe("horizontal inverted sheet (dismiss left)", () => {
+		const invertedHorizontalDirections = {
+			vertical: false,
+			verticalInverted: false,
+			horizontal: false,
+			horizontalInverted: true,
+		};
+
+		it("activates when swiping left at scroll right edge", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingLeft: true },
+				directions: invertedHorizontalDirections,
+				scrollConfig: createScrollConfig({ x: 500, contentWidth: 500, layoutWidth: 0 }),
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("horizontal-inverted");
+		});
+	});
+
+	describe("snap points behavior", () => {
+		it("activates for swipe up (expand) at scroll top when hasSnapPoints and canExpandMore", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+				hasSnapPoints: true,
+				canExpandMore: true,
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("vertical-inverted");
+		});
+
+		it("does not activate for swipe up when canExpandMore is false", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+				hasSnapPoints: true,
+				canExpandMore: false,
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+
+		it("does not activate for swipe up when scroll is not at top", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingUp: true },
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ y: 100, contentHeight: 500, layoutHeight: 0 }),
+				hasSnapPoints: true,
+				canExpandMore: true,
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+
+		it("activates for swipe left (expand) on horizontal sheet with snap points", () => {
+			const horizontalDirections = {
+				vertical: false,
+				verticalInverted: false,
+				horizontal: true,
+				horizontalInverted: false,
+			};
+
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingLeft: true },
+				directions: horizontalDirections,
+				scrollConfig: createScrollConfig({ contentWidth: 500, layoutWidth: 0 }),
+				hasSnapPoints: true,
+				canExpandMore: true,
+			});
+			expect(result.shouldActivate).toBe(true);
+			expect(result.direction).toBe("horizontal-inverted");
+		});
+	});
+
+	describe("no activation cases", () => {
+		it("returns false when no swipe is detected", () => {
+			const result = checkScrollAwareActivation({
+				swipeInfo: noSwipe,
+				directions: baseDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+			expect(result.direction).toBe(null);
+		});
+
+		it("returns false when direction is disabled", () => {
+			const disabledDirections = {
+				vertical: false,
+				verticalInverted: false,
+				horizontal: false,
+				horizontalInverted: false,
+			};
+
+			const result = checkScrollAwareActivation({
+				swipeInfo: { ...noSwipe, isSwipingDown: true },
+				directions: disabledDirections,
+				scrollConfig: createScrollConfig({ contentHeight: 500, layoutHeight: 0 }),
+			});
+			expect(result.shouldActivate).toBe(false);
+		});
+	});
+});