react-native-screen-transitions 3.3.0-beta.2 → 3.3.0-beta.4

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

@@ -1,471 +0,0 @@
-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();
-		expect(result).toEqual({
-			left: "screen",
-			right: "screen",
-			top: "screen",
-			bottom: "screen",
-		});
-	});
-
-	it("normalizes string input to all sides", () => {
-		const result = normalizeSides("edge");
-		expect(result).toEqual({
-			left: "edge",
-			right: "edge",
-			top: "edge",
-			bottom: "edge",
-		});
-	});
-
-	it("handles per-side object input", () => {
-		const result = normalizeSides({
-			left: "edge",
-			right: "screen",
-			top: "edge",
-		});
-		expect(result).toEqual({
-			left: "edge",
-			right: "screen",
-			top: "edge",
-			bottom: "screen", // defaults to screen
-		});
-	});
-
-	it("defaults missing sides to screen", () => {
-		const result = normalizeSides({ left: "edge" });
-		expect(result.left).toBe("edge");
-		expect(result.right).toBe("screen");
-		expect(result.top).toBe("screen");
-		expect(result.bottom).toBe("screen");
-	});
-});
-
-describe("computeEdgeConstraints", () => {
-	const dimensions = { width: 375, height: 812 };
-	const allScreen = { left: "screen", right: "screen", top: "screen", bottom: "screen" } as const;
-	const allEdge = { left: "edge", right: "edge", top: "edge", bottom: "edge" } as const;
-
-	it("allows all directions when all sides are 'screen'", () => {
-		const result = computeEdgeConstraints({ x: 200, y: 400 }, dimensions, allScreen);
-		expect(result.horizontalRight).toBe(true);
-		expect(result.horizontalLeft).toBe(true);
-		expect(result.verticalDown).toBe(true);
-		expect(result.verticalUp).toBe(true);
-	});
-
-	it("restricts to left edge for horizontal-right when edge mode", () => {
-		// Touch at x=200 (center) should NOT allow right swipe with edge activation
-		const center = computeEdgeConstraints({ x: 200, y: 400 }, dimensions, allEdge);
-		expect(center.horizontalRight).toBe(false);
-
-		// Touch at x=30 (within 50px edge) should allow right swipe
-		const edge = computeEdgeConstraints({ x: 30, y: 400 }, dimensions, allEdge);
-		expect(edge.horizontalRight).toBe(true);
-	});
-
-	it("restricts to right edge for horizontal-left when edge mode", () => {
-		// Touch at x=200 (center) should NOT allow left swipe
-		const center = computeEdgeConstraints({ x: 200, y: 400 }, dimensions, allEdge);
-		expect(center.horizontalLeft).toBe(false);
-
-		// Touch at x=350 (within 50px of right edge) should allow left swipe
-		const edge = computeEdgeConstraints({ x: 350, y: 400 }, dimensions, allEdge);
-		expect(edge.horizontalLeft).toBe(true);
-	});
-
-	it("restricts to top edge for vertical-down when edge mode", () => {
-		// Touch at y=400 (center) should NOT allow down swipe
-		const center = computeEdgeConstraints({ x: 200, y: 400 }, dimensions, allEdge);
-		expect(center.verticalDown).toBe(false);
-
-		// Touch at y=100 (within 135px edge) should allow down swipe
-		const edge = computeEdgeConstraints({ x: 200, y: 100 }, dimensions, allEdge);
-		expect(edge.verticalDown).toBe(true);
-	});
-
-	it("uses custom responseDistance", () => {
-		// With custom distance of 100px
-		const result = computeEdgeConstraints({ x: 80, y: 400 }, dimensions, allEdge, 100);
-		expect(result.horizontalRight).toBe(true); // 80 < 100
-	});
-});
-
-describe("calculateSwipeDirs", () => {
-	it("detects horizontal swipe right", () => {
-		const result = calculateSwipeDirs(50, 10);
-		expect(result.isHorizontalSwipe).toBe(true);
-		expect(result.isVerticalSwipe).toBe(false);
-		expect(result.isSwipingRight).toBe(true);
-		expect(result.isSwipingLeft).toBe(false);
-	});
-
-	it("detects horizontal swipe left", () => {
-		const result = calculateSwipeDirs(-50, 10);
-		expect(result.isHorizontalSwipe).toBe(true);
-		expect(result.isSwipingLeft).toBe(true);
-		expect(result.isSwipingRight).toBe(false);
-	});
-
-	it("detects vertical swipe down", () => {
-		const result = calculateSwipeDirs(10, 50);
-		expect(result.isVerticalSwipe).toBe(true);
-		expect(result.isHorizontalSwipe).toBe(false);
-		expect(result.isSwipingDown).toBe(true);
-		expect(result.isSwipingUp).toBe(false);
-	});
-
-	it("detects vertical swipe up", () => {
-		const result = calculateSwipeDirs(10, -50);
-		expect(result.isVerticalSwipe).toBe(true);
-		expect(result.isSwipingUp).toBe(true);
-		expect(result.isSwipingDown).toBe(false);
-	});
-
-	it("horizontal wins when equal deltas", () => {
-		// When deltaX === deltaY, neither wins (both false)
-		const result = calculateSwipeDirs(50, 50);
-		expect(result.isHorizontalSwipe).toBe(false);
-		expect(result.isVerticalSwipe).toBe(false);
-	});
-});
-
-describe("shouldActivateOrFail", () => {
-	const baseParams = {
-		deltaX: 0,
-		deltaY: 0,
-		hasHorizontal: true,
-		hasVertical: true,
-		isHorizontalSwipe: false,
-		isVerticalSwipe: false,
-		allowedRight: true,
-		allowedLeft: true,
-		allowedUp: true,
-		allowedDown: true,
-		horizontalGateRight: true,
-		horizontalGateLeft: true,
-		verticalGateUp: true,
-		verticalGateDown: true,
-		isSwipingRight: false,
-		isSwipingLeft: false,
-		isSwipingUp: false,
-		isSwipingDown: false,
-	};
-
-	it("activates on valid horizontal right swipe", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 15, // above threshold (10)
-			deltaY: 5, // within tolerance (15)
-			isHorizontalSwipe: true,
-			isSwipingRight: true,
-		});
-		expect(result.shouldActivate).toBe(true);
-		expect(result.shouldFail).toBe(false);
-	});
-
-	it("activates on valid vertical down swipe", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 5, // within tolerance (20)
-			deltaY: 15, // above threshold (10)
-			isVerticalSwipe: true,
-			isSwipingDown: true,
-		});
-		expect(result.shouldActivate).toBe(true);
-		expect(result.shouldFail).toBe(false);
-	});
-
-	it("fails when swiping in disallowed direction", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 15,
-			deltaY: 5,
-			isHorizontalSwipe: true,
-			isSwipingRight: true,
-			allowedRight: false, // direction not allowed
-		});
-		expect(result.shouldActivate).toBe(false);
-		expect(result.shouldFail).toBe(true);
-	});
-
-	it("fails when edge gate blocks the swipe", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 15,
-			deltaY: 5,
-			isHorizontalSwipe: true,
-			isSwipingRight: true,
-			horizontalGateRight: false, // edge gate blocks
-		});
-		expect(result.shouldActivate).toBe(false);
-		expect(result.shouldFail).toBe(true);
-	});
-
-	it("fails when vertical deviation exceeds tolerance during horizontal swipe", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 15,
-			deltaY: 20, // exceeds GESTURE_FAIL_TOLERANCE_X (15)
-			isHorizontalSwipe: true,
-			isSwipingRight: true,
-		});
-		expect(result.shouldActivate).toBe(false);
-		expect(result.shouldFail).toBe(true);
-	});
-
-	it("does not activate when movement is below threshold", () => {
-		const result = shouldActivateOrFail({
-			...baseParams,
-			deltaX: 5, // below threshold (10)
-			deltaY: 2,
-			isHorizontalSwipe: true,
-			isSwipingRight: true,
-		});
-		expect(result.shouldActivate).toBe(false);
-		expect(result.shouldFail).toBe(false);
-	});
-
-	it("handles bidirectional gesture activation", () => {
-		// Both horizontal and vertical allowed, vertical swipe detected
-		const result = shouldActivateOrFail({
-			...baseParams,
-			hasHorizontal: true,
-			hasVertical: true,
-			deltaX: 5,
-			deltaY: 15,
-			isVerticalSwipe: true,
-			isSwipingDown: true,
-		});
-		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);
-		});
-	});
-});

package/src/shared/__tests__/gesture.velocity.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { velocity } from "../utils/gesture/velocity";
-
-type Directions = {
-	horizontal: boolean;
-	horizontalInverted: boolean;
-	vertical: boolean;
-	verticalInverted: boolean;
-};
-
-type GestureEventInit = {
-	translationX?: number;
-	translationY?: number;
-	velocityX?: number;
-	velocityY?: number;
-};
-
-const createAnimations = (progress: number) =>
-	({
-		progress: { value: progress },
-		closing: { value: 0 },
-		animating: { value: 0 },
-	}) as const;
-
-const createEvent = ({
-	translationX = 0,
-	translationY = 0,
-	velocityX = 0,
-	velocityY = 0,
-}: GestureEventInit) =>
-	({ translationX, translationY, velocityX, velocityY }) as any;
-
-const createDirections = (overrides: Partial<Directions> = {}) => ({
-	horizontal: false,
-	horizontalInverted: false,
-	vertical: false,
-	verticalInverted: false,
-	...overrides,
-});
-
-describe("velocity.normalize", () => {
-	it("clamps values to the configured range", () => {
-		expect(velocity.normalize(6400, 320)).toBeCloseTo(3.2, 5);
-		expect(velocity.normalize(-6400, 320)).toBeCloseTo(-3.2, 5);
-	});
-});
-
-describe("velocity.calculateProgressVelocity", () => {
-	const dimensions = { width: 320, height: 640 };
-
-	it("returns positive magnitude when progressing toward open target", () => {
-		const animations = createAnimations(0.25);
-		const event = createEvent({
-			translationX: 48,
-			translationY: 6,
-			velocityX: 800,
-		});
-
-		const result = velocity.calculateProgressVelocity({
-			animations: animations as any,
-			shouldDismiss: false,
-			event,
-			dimensions,
-			directions: createDirections({ horizontal: true }),
-		});
-
-		expect(result).toBeCloseTo(2.5, 5);
-	});
-
-	it("prefers the axis with greater normalized translation", () => {
-		const animations = createAnimations(0.8);
-		const event = createEvent({
-			translationX: 24,
-			translationY: -140,
-			velocityX: 120,
-			velocityY: -900,
-		});
-
-		const result = velocity.calculateProgressVelocity({
-			animations: animations as any,
-			shouldDismiss: true,
-			event,
-			dimensions,
-			directions: createDirections({
-				horizontal: true,
-				verticalInverted: true,
-			}),
-		});
-
-		expect(result).toBeLessThan(0);
-		expect(Math.abs(result)).toBeCloseTo(1.406, 3);
-	});
-
-	it("caps the returned magnitude using clamp", () => {
-		const animations = createAnimations(0.5);
-		const event = createEvent({
-			translationX: 10,
-			velocityX: 5000,
-		});
-
-		const result = velocity.calculateProgressVelocity({
-			animations: animations as any,
-			shouldDismiss: false,
-			event,
-			dimensions,
-			directions: createDirections({ horizontal: true }),
-		});
-
-		expect(result).toBeCloseTo(3.2, 5);
-	});
-});
-
-describe("velocity.shouldPassDismissalThreshold", () => {
-	const width = 320;
-
-	it("returns true once translation alone crosses half the screen", () => {
-		expect(velocity.shouldPassDismissalThreshold(170, 0, width, 0.3)).toBe(
-			true,
-		);
-	});
-
-	it("combines translation with weighted velocity", () => {
-		expect(velocity.shouldPassDismissalThreshold(40, 2500, width, 0.5)).toBe(
-			true,
-		);
-	});
-
-	it("returns false when movement is negligible", () => {
-		expect(velocity.shouldPassDismissalThreshold(0, 0, width, 0.3)).toBe(false);
-	});
-});