react-native-screen-transitions 4.1.0-beta.1 → 4.1.0-rc.0

package/src/providers/motion/gestures/pan/activation/pan-activation-decision.ts

@@ -0,0 +1,452 @@
+import type { GestureTouchEvent } from "react-native-gesture-handler";
+import { EPSILON } from "../../../../../constants";
+import {
+	GestureActivationState,
+	type ScrollGestureState,
+} from "../../../../../types/gesture.types";
+import type { Direction } from "../../../../../types/ownership.types";
+import { getPanSnapAxisConfigForDirection } from "../../shared/directions";
+import { resolveRuntimeSnapPoints } from "../../shared/snap-points";
+import type {
+	GestureDimensions,
+	GestureOwnerMap,
+	PanGestureRuntime,
+} from "../../types";
+import {
+	checkScrollBoundary,
+	resolveOffsetRules,
+} from "./pan-activation-rules";
+
+export type PanActivationAction = "activate" | "fail" | "wait";
+
+export type PanActivationReason =
+	| "ancestor-dismissing"
+	| "already-dragging"
+	| "disabled"
+	| "dismissing"
+	| "multi-touch"
+	| "no-direction"
+	| "offset-failed"
+	| "ownership"
+	| "ready"
+	| "scroll-boundary"
+	| "scroll-collapse-only"
+	| "scroll-max-expanded"
+	| "snap-locked"
+	| "threshold-pending";
+
+export interface PanActivationDecision {
+	action: PanActivationAction;
+	reason: PanActivationReason;
+	direction: Direction | null;
+	nextActivationState: GestureActivationState;
+}
+
+interface ResolvePanActivationMoveDecisionProps {
+	event: GestureTouchEvent;
+	runtime: PanGestureRuntime;
+	dimensions: GestureDimensions;
+	initialTouch: { x: number; y: number };
+	activationState: GestureActivationState;
+	ancestorDismissing: boolean;
+	gestureOwners: GestureOwnerMap;
+	currentScreenKey: string;
+	scrollState: ScrollGestureState | null;
+}
+
+type OffsetRuleResult = ReturnType<typeof resolveOffsetRules>;
+type ActiveSnapAxis = ReturnType<typeof getPanSnapAxisConfigForDirection>;
+
+const createDecision = (
+	action: PanActivationAction,
+	reason: PanActivationReason,
+	direction: Direction | null,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision => {
+	"worklet";
+	return {
+		action,
+		reason,
+		direction,
+		nextActivationState,
+	};
+};
+
+const getSwipeDirection = ({
+	isSwipingDown,
+	isSwipingUp,
+	isSwipingRight,
+	isSwipingLeft,
+}: {
+	isSwipingDown: boolean;
+	isSwipingUp: boolean;
+	isSwipingRight: boolean;
+	isSwipingLeft: boolean;
+}): Direction | null => {
+	"worklet";
+	if (isSwipingDown) return "vertical";
+	if (isSwipingUp) return "vertical-inverted";
+	if (isSwipingRight) return "horizontal";
+	if (isSwipingLeft) return "horizontal-inverted";
+	return null;
+};
+
+const resolvePreflightDecision = (
+	event: GestureTouchEvent,
+	runtime: PanGestureRuntime,
+	ancestorDismissing: boolean,
+): PanActivationDecision | null => {
+	"worklet";
+	if (event.numberOfTouches !== 1) {
+		return createDecision(
+			"fail",
+			"multi-touch",
+			null,
+			GestureActivationState.FAILED,
+		);
+	}
+
+	if (ancestorDismissing) {
+		return createDecision(
+			"fail",
+			"ancestor-dismissing",
+			null,
+			GestureActivationState.FAILED,
+		);
+	}
+
+	if (!runtime.participation.canTrackGesture || !runtime.policy.enabled) {
+		return createDecision(
+			"fail",
+			"disabled",
+			null,
+			GestureActivationState.FAILED,
+		);
+	}
+
+	return null;
+};
+
+const resolveOffsetFailureDecision = (
+	offset: OffsetRuleResult,
+): PanActivationDecision | null => {
+	"worklet";
+	if (offset.nextActivationState !== GestureActivationState.FAILED) {
+		return null;
+	}
+
+	return createDecision(
+		"fail",
+		"offset-failed",
+		null,
+		offset.nextActivationState,
+	);
+};
+
+const resolveDirectionGateDecision = (
+	swipeDirection: Direction | null,
+	offset: OffsetRuleResult,
+	gestureOwners: GestureOwnerMap,
+	currentScreenKey: string,
+): PanActivationDecision | null => {
+	"worklet";
+	if (!swipeDirection) {
+		return createDecision(
+			"wait",
+			"no-direction",
+			null,
+			offset.nextActivationState,
+		);
+	}
+
+	if (gestureOwners[swipeDirection] !== currentScreenKey) {
+		return createDecision(
+			"fail",
+			"ownership",
+			swipeDirection,
+			offset.nextActivationState,
+		);
+	}
+
+	if (offset.nextActivationState !== GestureActivationState.PASSED) {
+		return createDecision(
+			"wait",
+			"threshold-pending",
+			swipeDirection,
+			offset.nextActivationState,
+		);
+	}
+
+	return null;
+};
+
+const resolveSnapLockDecision = (
+	hasSnapPoints: boolean,
+	gestureSnapLocked: boolean,
+	isExpandGesture: boolean,
+	swipeDirection: Direction,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision | null => {
+	"worklet";
+	if (!hasSnapPoints || !gestureSnapLocked || !isExpandGesture) {
+		return null;
+	}
+
+	return createDecision(
+		"fail",
+		"snap-locked",
+		swipeDirection,
+		nextActivationState,
+	);
+};
+
+const resolveSnapScrollExpansionDecision = (
+	runtime: PanGestureRuntime,
+	swipeDirection: Direction,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision | null => {
+	"worklet";
+	const {
+		participation,
+		policy,
+		stores: { animations, system },
+	} = runtime;
+	const { hasAutoSnapPoint, snapPoints, minSnapPoint, maxSnapPoint } =
+		participation.effectiveSnapPoints;
+
+	if (policy.sheetScrollGestureBehavior === "collapse-only") {
+		return createDecision(
+			"fail",
+			"scroll-collapse-only",
+			swipeDirection,
+			nextActivationState,
+		);
+	}
+
+	const { resolvedMaxSnapPoint } = resolveRuntimeSnapPoints({
+		snapPoints,
+		hasAutoSnapPoint,
+		resolvedAutoSnapPoint: system.resolvedAutoSnapPoint.get(),
+		minSnapPoint,
+		maxSnapPoint,
+		canDismiss: participation.canDismiss,
+	});
+
+	const canExpandMore =
+		animations.transitionProgress.get() < resolvedMaxSnapPoint - EPSILON &&
+		system.targetProgress.get() < resolvedMaxSnapPoint - EPSILON;
+
+	if (canExpandMore) {
+		return null;
+	}
+
+	return createDecision(
+		"fail",
+		"scroll-max-expanded",
+		swipeDirection,
+		nextActivationState,
+	);
+};
+
+const resolveDismissingDecision = (
+	hasSnapPoints: boolean,
+	isDismissing: boolean,
+	swipeDirection: Direction,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision | null => {
+	"worklet";
+	if (hasSnapPoints || !isDismissing) {
+		return null;
+	}
+
+	return createDecision(
+		"wait",
+		"dismissing",
+		swipeDirection,
+		nextActivationState,
+	);
+};
+
+const isVerticalDirection = (direction: Direction) => {
+	"worklet";
+	return direction === "vertical" || direction === "vertical-inverted";
+};
+
+const resolveUntouchedScrollDecision = (
+	scrollState: ScrollGestureState | null,
+	swipeDirection: Direction,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision | null => {
+	"worklet";
+	const axisState = isVerticalDirection(swipeDirection)
+		? scrollState?.vertical
+		: scrollState?.horizontal;
+
+	if (axisState?.isTouched ?? false) {
+		return null;
+	}
+
+	return createDecision(
+		"activate",
+		"ready",
+		swipeDirection,
+		nextActivationState,
+	);
+};
+
+const resolveScrollBoundaryDecision = (
+	scrollState: ScrollGestureState,
+	swipeDirection: Direction,
+	activeSnapAxis: ActiveSnapAxis,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision | null => {
+	"worklet";
+	const atBoundary = checkScrollBoundary(
+		scrollState,
+		swipeDirection,
+		activeSnapAxis?.config.inverted,
+	);
+
+	if (atBoundary) {
+		return null;
+	}
+
+	return createDecision(
+		"fail",
+		"scroll-boundary",
+		swipeDirection,
+		nextActivationState,
+	);
+};
+
+const resolveScrollDecision = (
+	runtime: PanGestureRuntime,
+	scrollState: ScrollGestureState | null,
+	swipeDirection: Direction,
+	activeSnapAxis: ActiveSnapAxis,
+	isExpandGesture: boolean,
+	nextActivationState: GestureActivationState,
+): PanActivationDecision => {
+	"worklet";
+	const hasSnapPoints = runtime.participation.effectiveSnapPoints.hasSnapPoints;
+
+	const dismissingDecision = resolveDismissingDecision(
+		hasSnapPoints,
+		Boolean(runtime.stores.gestures.dismissing.get()),
+		swipeDirection,
+		nextActivationState,
+	);
+	if (dismissingDecision) return dismissingDecision;
+
+	const untouchedScrollDecision = resolveUntouchedScrollDecision(
+		scrollState,
+		swipeDirection,
+		nextActivationState,
+	);
+	if (untouchedScrollDecision) return untouchedScrollDecision;
+
+	const activeScrollState = scrollState as ScrollGestureState;
+	const boundaryDecision = resolveScrollBoundaryDecision(
+		activeScrollState,
+		swipeDirection,
+		activeSnapAxis,
+		nextActivationState,
+	);
+	if (boundaryDecision) return boundaryDecision;
+
+	const snapExpandDecision =
+		hasSnapPoints && isExpandGesture
+			? resolveSnapScrollExpansionDecision(
+					runtime,
+					swipeDirection,
+					nextActivationState,
+				)
+			: null;
+
+	return (
+		snapExpandDecision ??
+		createDecision("activate", "ready", swipeDirection, nextActivationState)
+	);
+};
+
+export const resolvePanActivationMoveDecision = ({
+	event,
+	runtime,
+	dimensions,
+	initialTouch,
+	activationState,
+	ancestorDismissing,
+	gestureOwners,
+	currentScreenKey,
+	scrollState,
+}: ResolvePanActivationMoveDecisionProps): PanActivationDecision => {
+	"worklet";
+	const preflightDecision = resolvePreflightDecision(
+		event,
+		runtime,
+		ancestorDismissing,
+	);
+	if (preflightDecision) return preflightDecision;
+
+	const { policy } = runtime;
+	const touch = event.changedTouches[0];
+	const offset = resolveOffsetRules({
+		touch,
+		initialTouch,
+		directions: policy.panActivationDirections,
+		dimensions,
+		activationState,
+		activationArea: policy.gestureActivationArea,
+	});
+
+	const offsetFailureDecision = resolveOffsetFailureDecision(offset);
+	if (offsetFailureDecision) return offsetFailureDecision;
+
+	if (runtime.stores.gestures.dragging.get()) {
+		return createDecision(
+			"activate",
+			"already-dragging",
+			null,
+			offset.nextActivationState,
+		);
+	}
+
+	const swipeDirection = getSwipeDirection(offset);
+	const directionGateDecision = resolveDirectionGateDecision(
+		swipeDirection,
+		offset,
+		gestureOwners,
+		currentScreenKey,
+	);
+	if (directionGateDecision) return directionGateDecision;
+
+	const activeDirection = swipeDirection as Direction;
+	const { participation } = runtime;
+	const { hasSnapPoints } = participation.effectiveSnapPoints;
+
+	const activeSnapAxis = hasSnapPoints
+		? getPanSnapAxisConfigForDirection(
+				policy.snapAxisDirections,
+				activeDirection,
+			)
+		: null;
+	const isExpandGesture = activeSnapAxis?.config.expand === activeDirection;
+
+	const snapLockDecision = resolveSnapLockDecision(
+		hasSnapPoints,
+		policy.gestureSnapLocked,
+		isExpandGesture,
+		activeDirection,
+		offset.nextActivationState,
+	);
+	if (snapLockDecision) return snapLockDecision;
+
+	return resolveScrollDecision(
+		runtime,
+		scrollState,
+		activeDirection,
+		activeSnapAxis,
+		isExpandGesture,
+		offset.nextActivationState,
+	);
+};