react-native-screen-transitions 2.0.6 → 2.2.0

package/src/utils/gesture/check-gesture-activation.ts

@@ -0,0 +1,310 @@
+import type { ScaledSize } from "react-native";
+import type { GestureStateManagerType } from "react-native-gesture-handler/lib/typescript/handlers/gestures/gestureStateManager";
+import type { SharedValue } from "react-native-reanimated";
+import {
+	type ActivationArea,
+	type GestureActivationArea,
+	GestureOffsetState,
+	type SideActivation,
+} from "../../types/gesture";
+
+type Directions = {
+	vertical: boolean;
+	verticalInverted: boolean;
+	horizontal: boolean;
+	horizontalInverted: boolean;
+};
+
+interface CheckGestureActivationProps {
+	initialTouch: { x: number; y: number };
+	touch: { x: number; y: number };
+	directions: Directions;
+	manager?: GestureStateManagerType;
+	gestureOffsetState: SharedValue<GestureOffsetState>;
+	activationArea?: GestureActivationArea;
+	dimensions: ScaledSize;
+	responseDistance?: number;
+}
+
+type NormalizedSides = {
+	left: ActivationArea;
+	right: ActivationArea;
+	top: ActivationArea;
+	bottom: ActivationArea;
+};
+
+interface ShouldActivateOrFailProps {
+	deltaX: number;
+	deltaY: number;
+	hasHorizontal: boolean;
+	hasVertical: boolean;
+	isHorizontalSwipe: boolean;
+	isVerticalSwipe: boolean;
+	allowedRight: boolean;
+	allowedLeft: boolean;
+	allowedUp: boolean;
+	allowedDown: boolean;
+	horizontalGateRight: boolean;
+	horizontalGateLeft: boolean;
+	verticalGateUp: boolean;
+	verticalGateDown: boolean;
+	isSwipingRight: boolean;
+	isSwipingLeft: boolean;
+	isSwipingUp: boolean;
+	isSwipingDown: boolean;
+}
+
+interface ReturnValues {
+	isSwipingDown: boolean;
+	isSwipingUp: boolean;
+	isSwipingRight: boolean;
+	isSwipingLeft: boolean;
+}
+
+/**
+ * 10 seems like the correct threshold for compatability with nested gestures outside of our package.
+ */
+const GESTURE_ACTIVATION_THRESHOLD_X = 10;
+const GESTURE_ACTIVATION_THRESHOLD_Y = 10;
+const GESTURE_FAIL_TOLERANCE_X = 15;
+const GESTURE_FAIL_TOLERANCE_Y = 20;
+const DEFAULT_EDGE_DISTANCE_HORIZONTAL = 50;
+const DEFAULT_EDGE_DISTANCE_VERTICAL = 135;
+const DEFAULT_ACTIVATION_AREA = "screen" as const;
+
+function normalizeSides(area?: GestureActivationArea): NormalizedSides {
+	"worklet";
+	if (!area || typeof area === "string") {
+		const mode: ActivationArea = area ?? DEFAULT_ACTIVATION_AREA;
+		return { left: mode, right: mode, top: mode, bottom: mode };
+	}
+
+	const s: SideActivation = area as SideActivation;
+	return {
+		left: s.left ?? DEFAULT_ACTIVATION_AREA,
+		right: s.right ?? DEFAULT_ACTIVATION_AREA,
+		top: s.top ?? DEFAULT_ACTIVATION_AREA,
+		bottom: s.bottom ?? DEFAULT_ACTIVATION_AREA,
+	};
+}
+
+function computeEdgeConstraints(
+	initialTouch: { x: number; y: number },
+	dimensions: ScaledSize,
+	sides: NormalizedSides,
+	responseDistance?: number,
+) {
+	"worklet";
+	const xDist = responseDistance ?? DEFAULT_EDGE_DISTANCE_HORIZONTAL;
+	const yDist = responseDistance ?? DEFAULT_EDGE_DISTANCE_VERTICAL;
+
+	const horizontalRight = sides.left === "screen" || initialTouch.x <= xDist; // right swipe checks left edge
+	const horizontalLeft =
+		sides.right === "screen" || initialTouch.x >= dimensions.width - xDist; // left swipe checks right edge
+	const verticalDown = sides.top === "screen" || initialTouch.y <= yDist; // down swipe checks top edge
+	const verticalUp =
+		sides.bottom === "screen" || initialTouch.y >= dimensions.height - yDist; // up swipe checks bottom edge
+
+	return { horizontalRight, horizontalLeft, verticalDown, verticalUp } as const;
+}
+
+function calculateSwipeDirs(deltaX: number, deltaY: number) {
+	"worklet";
+
+	const isVerticalSwipe = Math.abs(deltaY) > Math.abs(deltaX);
+	const isHorizontalSwipe = Math.abs(deltaX) > Math.abs(deltaY);
+
+	const isSwipingDown = isVerticalSwipe && deltaY > 0;
+	const isSwipingUp = isVerticalSwipe && deltaY < 0;
+	const isSwipingRight = isHorizontalSwipe && deltaX > 0;
+	const isSwipingLeft = isHorizontalSwipe && deltaX < 0;
+
+	return {
+		isSwipingDown,
+		isSwipingUp,
+		isSwipingRight,
+		isSwipingLeft,
+		isVerticalSwipe,
+		isHorizontalSwipe,
+	};
+}
+
+function shouldActivateOrFail(params: ShouldActivateOrFailProps) {
+	"worklet";
+
+	const {
+		deltaX,
+		deltaY,
+		hasHorizontal,
+		hasVertical,
+		isHorizontalSwipe,
+		isVerticalSwipe,
+		allowedRight,
+		allowedLeft,
+		allowedUp,
+		allowedDown,
+		horizontalGateRight,
+		horizontalGateLeft,
+		verticalGateUp,
+		verticalGateDown,
+		isSwipingRight,
+		isSwipingLeft,
+		isSwipingUp,
+		isSwipingDown,
+	} = params;
+
+	let shouldActivate = false;
+	let shouldFail = false;
+
+	if (hasHorizontal && isHorizontalSwipe) {
+		const hasEnoughHorizontalMovement =
+			Math.abs(deltaX) >= GESTURE_ACTIVATION_THRESHOLD_X;
+
+		const hasAcceptableVerticalDeviation =
+			Math.abs(deltaY) <= GESTURE_FAIL_TOLERANCE_X;
+
+		if (hasEnoughHorizontalMovement && hasAcceptableVerticalDeviation) {
+			const rightOk = isSwipingRight && allowedRight && horizontalGateRight;
+			const leftOk = isSwipingLeft && allowedLeft && horizontalGateLeft;
+			if (rightOk || leftOk) {
+				shouldActivate = true;
+			}
+		} else if (!hasAcceptableVerticalDeviation) {
+			shouldFail = true;
+		}
+	}
+
+	if (hasVertical && isVerticalSwipe) {
+		const hasEnoughVerticalMovement =
+			Math.abs(deltaY) >= GESTURE_ACTIVATION_THRESHOLD_Y;
+		const hasAcceptableHorizontalDeviation =
+			Math.abs(deltaX) <= GESTURE_FAIL_TOLERANCE_Y;
+
+		if (hasEnoughVerticalMovement && hasAcceptableHorizontalDeviation) {
+			const upOk = isSwipingUp && allowedUp && verticalGateUp;
+			const downOk = isSwipingDown && allowedDown && verticalGateDown;
+			if (upOk || downOk) {
+				shouldActivate = true;
+			}
+		} else if (!hasAcceptableHorizontalDeviation) {
+			shouldFail = true;
+		}
+	}
+
+	if (hasHorizontal && isHorizontalSwipe) {
+		if ((isSwipingLeft && !allowedLeft) || (isSwipingRight && !allowedRight)) {
+			shouldFail = true;
+		}
+		// If gating prohibits the dominant horizontal swipe, fail early
+		if (
+			(isSwipingRight && allowedRight && !horizontalGateRight) ||
+			(isSwipingLeft && allowedLeft && !horizontalGateLeft)
+		) {
+			shouldFail = true;
+		}
+	}
+
+	if (hasVertical && isVerticalSwipe) {
+		if ((isSwipingUp && !allowedUp) || (isSwipingDown && !allowedDown)) {
+			shouldFail = true;
+		}
+		// If gating prohibits the dominant vertical swipe, fail early
+		if (
+			(isSwipingUp && allowedUp && !verticalGateUp) ||
+			(isSwipingDown && allowedDown && !verticalGateDown)
+		) {
+			shouldFail = true;
+		}
+	}
+
+	return { shouldActivate, shouldFail };
+}
+
+/**
+ * Since we're using onTouchesMove to activate our pan, faillOffset and activateOffset don't actually work. In that case we'll create this function to use in onTouchesMove which acts simarly to the original functionality.
+ */
+export const applyOffsetRules = ({
+	initialTouch,
+	touch,
+	directions,
+	manager,
+	gestureOffsetState,
+	activationArea,
+	dimensions,
+	responseDistance,
+}: CheckGestureActivationProps): ReturnValues => {
+	"worklet";
+
+	const deltaX = touch.x - initialTouch.x;
+	const deltaY = touch.y - initialTouch.y;
+
+	const allowedDown = directions.vertical;
+	const allowedUp = directions.verticalInverted;
+	const allowedRight = directions.horizontal;
+	const allowedLeft = directions.horizontalInverted;
+
+	const hasHorizontal = allowedLeft || allowedRight;
+	const hasVertical = allowedUp || allowedDown;
+
+	const {
+		isSwipingDown,
+		isSwipingUp,
+		isSwipingRight,
+		isSwipingLeft,
+		isVerticalSwipe,
+		isHorizontalSwipe,
+	} = calculateSwipeDirs(deltaX, deltaY);
+
+	if (gestureOffsetState.value !== GestureOffsetState.PENDING) {
+		return {
+			isSwipingDown,
+			isSwipingUp,
+			isSwipingRight,
+			isSwipingLeft,
+		};
+	}
+
+	const sides = normalizeSides(activationArea);
+
+	const {
+		horizontalRight: horizontalGateRight,
+		horizontalLeft: horizontalGateLeft,
+		verticalDown: verticalGateDown,
+		verticalUp: verticalGateUp,
+	} = computeEdgeConstraints(initialTouch, dimensions, sides, responseDistance);
+
+	const { shouldActivate, shouldFail } = shouldActivateOrFail({
+		deltaX,
+		deltaY,
+		hasHorizontal,
+		hasVertical,
+		isHorizontalSwipe,
+		isVerticalSwipe,
+		allowedRight,
+		allowedLeft,
+		allowedUp,
+		allowedDown,
+		horizontalGateRight,
+		horizontalGateLeft,
+		verticalGateUp,
+		verticalGateDown,
+		isSwipingRight,
+		isSwipingLeft,
+		isSwipingUp,
+		isSwipingDown,
+	});
+
+	if (shouldActivate) {
+		gestureOffsetState.value = GestureOffsetState.PASSED;
+	} else if (shouldFail) {
+		gestureOffsetState.value = GestureOffsetState.FAILED;
+		manager?.fail();
+	}
+
+	return {
+		isSwipingDown,
+		isSwipingUp,
+		isSwipingRight,
+		isSwipingLeft,
+	};
+};

package/src/utils/gesture/determine-dismissal.ts

@@ -0,0 +1,131 @@
+interface GetAxisThresholdProps {
+	translation: number;
+	velocity: number;
+	screenSize: number;
+	gestureVelocityImpact: number;
+}
+
+interface DetermineDismissalProps {
+	event: {
+		translationX: number;
+		translationY: number;
+		velocityX: number;
+		velocityY: number;
+	};
+	directions: {
+		vertical: boolean;
+		verticalInverted: boolean;
+		horizontal: boolean;
+		horizontalInverted: boolean;
+	};
+	dimensions: { width: number; height: number };
+	gestureVelocityImpact: number;
+}
+
+// Note: we normalize velocity by the axis dimension to map px/s to progress/s.
+// This produces consistent behavior across devices and enables realistic bounce.
+
+const MAX_PROGRESS_VELOCITY = 3.5; // ~3 progress units/second
+
+const getAxisThreshold = ({
+	translation,
+	velocity,
+	screenSize,
+	gestureVelocityImpact,
+}: GetAxisThresholdProps) => {
+	"worklet";
+	const finalTranslation = translation + velocity * gestureVelocityImpact;
+
+	return (
+		Math.abs(finalTranslation) > screenSize / 2 &&
+		(velocity !== 0 || translation !== 0)
+	);
+};
+
+const getVelocity = (
+	dimensions: { width: number; height: number },
+	velocityX: number,
+	velocityY: number,
+	dismissAxis: "x" | "y",
+) => {
+	"worklet";
+	const axisSize = dismissAxis === "y" ? dimensions.height : dimensions.width;
+	const axisVelocityPx = dismissAxis === "y" ? velocityY : velocityX;
+	let velocity = axisVelocityPx / Math.max(1, axisSize);
+
+	if (velocity > MAX_PROGRESS_VELOCITY) velocity = MAX_PROGRESS_VELOCITY;
+	if (velocity < -MAX_PROGRESS_VELOCITY) velocity = -MAX_PROGRESS_VELOCITY;
+
+	return velocity;
+};
+
+export const determineDismissal = ({
+	event,
+	directions,
+	dimensions,
+	gestureVelocityImpact,
+}: DetermineDismissalProps) => {
+	"worklet";
+
+	let shouldDismiss: boolean = false;
+	let dismissAxis: "x" | "y" = "x";
+
+	if (directions.vertical && event.translationY > 0) {
+		const dismiss = getAxisThreshold({
+			translation: event.translationY,
+			velocity: event.velocityY,
+			screenSize: dimensions.height,
+			gestureVelocityImpact,
+		});
+		if (dismiss) {
+			dismissAxis = "y";
+			shouldDismiss = true;
+		}
+	}
+	if (directions.verticalInverted && event.translationY < 0) {
+		const dismiss = getAxisThreshold({
+			translation: event.translationY,
+			velocity: event.velocityY,
+			screenSize: dimensions.height,
+			gestureVelocityImpact,
+		});
+		if (dismiss) {
+			dismissAxis = "y";
+			shouldDismiss = true;
+		}
+	}
+	if (directions.horizontal && event.translationX > 0) {
+		const dismiss = getAxisThreshold({
+			translation: event.translationX,
+			velocity: event.velocityX,
+			screenSize: dimensions.width,
+			gestureVelocityImpact,
+		});
+		if (dismiss) {
+			dismissAxis = "x";
+			shouldDismiss = true;
+		}
+	}
+	if (directions.horizontalInverted && event.translationX < 0) {
+		const dismiss = getAxisThreshold({
+			translation: event.translationX,
+			velocity: event.velocityX,
+			screenSize: dimensions.width,
+			gestureVelocityImpact,
+		});
+
+		if (dismiss) {
+			dismissAxis = "x";
+			shouldDismiss = true;
+		}
+	}
+
+	const velocity = getVelocity(
+		dimensions,
+		event.velocityX,
+		event.velocityY,
+		dismissAxis,
+	);
+
+	return { shouldDismiss, velocity };
+};

package/lib/commonjs/components/bounds-activator.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_reactNativeGestureHandler","_bounds","_jsxRuntime","BoundActivator","sharedBoundTag","children","measure","tapGesture","useMemo","Gesture","Tap","onStart","Bounds","setActiveBoundId","jsx","GestureDetector","gesture","exports"],"sourceRoot":"../../../src","sources":["components/bounds-activator.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,0BAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAA0C,IAAAG,WAAA,GAAAH,OAAA;AAQnC,MAAMI,cAAc,GAAGA,CAAC;EAC9BC,cAAc;EACdC,QAAQ;EACRC;AACoB,CAAC,KAAK;EAC1B,MAAMC,UAAU,GAAG,IAAAC,cAAO,EAAC,MAAM;IAChC,OAAOC,kCAAO,CAACC,GAAG,CAAC,CAAC,CAACC,OAAO,CAAC,MAAM;MAClC,SAAS;;MACT,IAAIP,cAAc,EAAE;QACnBQ,cAAM,CAACC,gBAAgB,CAACT,cAAc,CAAC;QACvCE,OAAO,CAAC,CAAC;MACV;IACD,CAAC,CAAC;EACH,CAAC,EAAE,CAACF,cAAc,EAAEE,OAAO,CAAC,CAAC;EAE7B,IAAI,CAACF,cAAc,EAAE,OAAOC,QAAQ;EAEpC,oBAAO,IAAAH,WAAA,CAAAY,GAAA,EAACd,0BAAA,CAAAe,eAAe;IAACC,OAAO,EAAET,UAAW;IAAAF,QAAA,EAAEA;EAAQ,CAAkB,CAAC;AAC1E,CAAC;AAACY,OAAA,CAAAd,cAAA,GAAAA,cAAA","ignoreList":[]}

package/lib/commonjs/hooks/bounds/use-bound-measurer.js

@@ -1,52 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useBoundMeasurer = void 0;
-var _react = require("react");
-var _reactNativeReanimated = require("react-native-reanimated");
-var _keys = require("../../providers/keys");
-var _bounds = require("../../stores/bounds");
-var _flattenStyles = require("../../utils/bounds/flatten-styles");
-var _useScreenAnimation = require("../animation/use-screen-animation");
-const useBoundMeasurer = ({
-  sharedBoundTag,
-  animatedRef,
-  current,
-  style
-}) => {
-  const {
-    previous
-  } = (0, _keys.useKeys)();
-  const interpolatorProps = (0, _useScreenAnimation.useScreenAnimation)();
-  const hasAlreadyMeasured = (0, _reactNativeReanimated.useSharedValue)(false);
-  const measureAndSet = (0, _react.useCallback)(() => {
-    "worklet";
-
-    if (!sharedBoundTag) return;
-    const measured = (0, _reactNativeReanimated.measure)(animatedRef);
-    if (measured) {
-      _bounds.Bounds.setBounds(current.route.key, sharedBoundTag, measured, (0, _flattenStyles.flattenStyle)(style));
-    }
-  }, [sharedBoundTag, animatedRef, current.route.key, style]);
-  const measureOnLayout = (0, _react.useCallback)(() => {
-    "worklet";
-
-    if (!sharedBoundTag || hasAlreadyMeasured.value) return;
-    const previousRouteKey = previous?.route.key;
-    if (!previousRouteKey) return;
-    const previousBounds = _bounds.Bounds.getBounds(previousRouteKey);
-    const hasPreviousBoundForTag = previousBounds[sharedBoundTag];
-    if (interpolatorProps.value.current.animating && hasPreviousBoundForTag) {
-      measureAndSet();
-      hasAlreadyMeasured.value = true;
-    }
-  }, [measureAndSet, interpolatorProps, sharedBoundTag, previous?.route.key, hasAlreadyMeasured]);
-  return {
-    measureAndSet,
-    measureOnLayout
-  };
-};
-exports.useBoundMeasurer = useBoundMeasurer;
-//# sourceMappingURL=use-bound-measurer.js.map

package/lib/commonjs/hooks/bounds/use-bound-measurer.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_reactNativeReanimated","_keys","_bounds","_flattenStyles","_useScreenAnimation","useBoundMeasurer","sharedBoundTag","animatedRef","current","style","previous","useKeys","interpolatorProps","useScreenAnimation","hasAlreadyMeasured","useSharedValue","measureAndSet","useCallback","measured","measure","Bounds","setBounds","route","key","flattenStyle","measureOnLayout","value","previousRouteKey","previousBounds","getBounds","hasPreviousBoundForTag","animating","exports"],"sourceRoot":"../../../../src","sources":["hooks/bounds/use-bound-measurer.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,sBAAA,GAAAD,OAAA;AAMA,IAAAE,KAAA,GAAAF,OAAA;AACA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,cAAA,GAAAJ,OAAA;AACA,IAAAK,mBAAA,GAAAL,OAAA;AASO,MAAMM,gBAAgB,GAAGA,CAAC;EAChCC,cAAc;EACdC,WAAW;EACXC,OAAO;EACPC;AACuB,CAAC,KAAK;EAC7B,MAAM;IAAEC;EAAS,CAAC,GAAG,IAAAC,aAAO,EAAC,CAAC;EAC9B,MAAMC,iBAAiB,GAAG,IAAAC,sCAAkB,EAAC,CAAC;EAC9C,MAAMC,kBAAkB,GAAG,IAAAC,qCAAc,EAAC,KAAK,CAAC;EAEhD,MAAMC,aAAa,GAAG,IAAAC,kBAAW,EAAC,MAAM;IACvC,SAAS;;IACT,IAAI,CAACX,cAAc,EAAE;IACrB,MAAMY,QAAQ,GAAG,IAAAC,8BAAO,EAACZ,WAAW,CAAC;IACrC,IAAIW,QAAQ,EAAE;MACbE,cAAM,CAACC,SAAS,CACfb,OAAO,CAACc,KAAK,CAACC,GAAG,EACjBjB,cAAc,EACdY,QAAQ,EACR,IAAAM,2BAAY,EAACf,KAAK,CACnB,CAAC;IACF;EACD,CAAC,EAAE,CAACH,cAAc,EAAEC,WAAW,EAAEC,OAAO,CAACc,KAAK,CAACC,GAAG,EAAEd,KAAK,CAAC,CAAC;EAE3D,MAAMgB,eAAe,GAAG,IAAAR,kBAAW,EAAC,MAAM;IACzC,SAAS;;IACT,IAAI,CAACX,cAAc,IAAIQ,kBAAkB,CAACY,KAAK,EAAE;IAEjD,MAAMC,gBAAgB,GAAGjB,QAAQ,EAAEY,KAAK,CAACC,GAAG;IAC5C,IAAI,CAACI,gBAAgB,EAAE;IAEvB,MAAMC,cAAc,GAAGR,cAAM,CAACS,SAAS,CAACF,gBAAgB,CAAC;IACzD,MAAMG,sBAAsB,GAAGF,cAAc,CAACtB,cAAc,CAAC;IAE7D,IAAIM,iBAAiB,CAACc,KAAK,CAAClB,OAAO,CAACuB,SAAS,IAAID,sBAAsB,EAAE;MACxEd,aAAa,CAAC,CAAC;MACfF,kBAAkB,CAACY,KAAK,GAAG,IAAI;IAChC;EACD,CAAC,EAAE,CACFV,aAAa,EACbJ,iBAAiB,EACjBN,cAAc,EACdI,QAAQ,EAAEY,KAAK,CAACC,GAAG,EACnBT,kBAAkB,CAClB,CAAC;EAEF,OAAO;IACNE,aAAa;IACbS;EACD,CAAC;AACF,CAAC;AAACO,OAAA,CAAA3B,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/lib/commonjs/hooks/gestures/use-scroll-progress.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useScrollProgress = void 0;
-var _react = require("react");
-var _reactNativeReanimated = require("react-native-reanimated");
-var _gestures = require("../../providers/gestures");
-const useScrollProgress = props => {
-  const {
-    scrollProgress
-  } = (0, _gestures.useGestureContext)();
-  const scrollHandler = (0, _reactNativeReanimated.useAnimatedScrollHandler)({
-    onScroll: event => {
-      props.onScroll?.(event);
-      scrollProgress.modify(v => {
-        "worklet";
-
-        v.x = event.contentOffset.x;
-        v.y = event.contentOffset.y;
-        return v;
-      });
-    }
-  });
-  const onContentSizeChange = (0, _react.useCallback)((width, height) => {
-    props.onContentSizeChange?.(width, height);
-    scrollProgress.modify(v => {
-      "worklet";
-
-      v.contentWidth = width;
-      v.contentHeight = height;
-      return v;
-    });
-  }, [scrollProgress, props.onContentSizeChange]);
-  const onLayout = (0, _react.useCallback)(event => {
-    props.onLayout?.(event);
-    const {
-      width,
-      height
-    } = event.nativeEvent.layout;
-    scrollProgress.modify(v => {
-      "worklet";
-
-      v.layoutHeight = height;
-      v.layoutWidth = width;
-      return v;
-    });
-  }, [scrollProgress, props.onLayout]);
-  return {
-    scrollHandler,
-    onContentSizeChange,
-    onLayout
-  };
-};
-exports.useScrollProgress = useScrollProgress;
-//# sourceMappingURL=use-scroll-progress.js.map

package/lib/commonjs/hooks/gestures/use-scroll-progress.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","require","_reactNativeReanimated","_gestures","useScrollProgress","props","scrollProgress","useGestureContext","scrollHandler","useAnimatedScrollHandler","onScroll","event","modify","v","x","contentOffset","y","onContentSizeChange","useCallback","width","height","contentWidth","contentHeight","onLayout","nativeEvent","layout","layoutHeight","layoutWidth","exports"],"sourceRoot":"../../../../src","sources":["hooks/gestures/use-scroll-progress.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,sBAAA,GAAAD,OAAA;AAEA,IAAAE,SAAA,GAAAF,OAAA;AAQO,MAAMG,iBAAiB,GAAIC,KAA8B,IAAK;EACpE,MAAM;IAAEC;EAAe,CAAC,GAAG,IAAAC,2BAAiB,EAAC,CAAC;EAC9C,MAAMC,aAAa,GAAG,IAAAC,+CAAwB,EAAC;IAC9CC,QAAQ,EAAGC,KAAK,IAAK;MACpBN,KAAK,CAACK,QAAQ,GAAGC,KAAK,CAAC;MACvBL,cAAc,CAACM,MAAM,CAAEC,CAAC,IAAK;QAC5B,SAAS;;QACTA,CAAC,CAACC,CAAC,GAAGH,KAAK,CAACI,aAAa,CAACD,CAAC;QAC3BD,CAAC,CAACG,CAAC,GAAGL,KAAK,CAACI,aAAa,CAACC,CAAC;QAC3B,OAAOH,CAAC;MACT,CAAC,CAAC;IACH;EACD,CAAC,CAAC;EAEF,MAAMI,mBAAmB,GAAG,IAAAC,kBAAW,EACtC,CAACC,KAAa,EAAEC,MAAc,KAAK;IAClCf,KAAK,CAACY,mBAAmB,GAAGE,KAAK,EAAEC,MAAM,CAAC;IAE1Cd,cAAc,CAACM,MAAM,CAAEC,CAAC,IAAK;MAC5B,SAAS;;MACTA,CAAC,CAACQ,YAAY,GAAGF,KAAK;MACtBN,CAAC,CAACS,aAAa,GAAGF,MAAM;MACxB,OAAOP,CAAC;IACT,CAAC,CAAC;EACH,CAAC,EACD,CAACP,cAAc,EAAED,KAAK,CAACY,mBAAmB,CAC3C,CAAC;EAED,MAAMM,QAAQ,GAAG,IAAAL,kBAAW,EAC1BP,KAAwB,IAAK;IAC7BN,KAAK,CAACkB,QAAQ,GAAGZ,KAAK,CAAC;IACvB,MAAM;MAAEQ,KAAK;MAAEC;IAAO,CAAC,GAAGT,KAAK,CAACa,WAAW,CAACC,MAAM;IAClDnB,cAAc,CAACM,MAAM,CAAEC,CAAC,IAAK;MAC5B,SAAS;;MACTA,CAAC,CAACa,YAAY,GAAGN,MAAM;MACvBP,CAAC,CAACc,WAAW,GAAGR,KAAK;MACrB,OAAON,CAAC;IACT,CAAC,CAAC;EACH,CAAC,EACD,CAACP,cAAc,EAAED,KAAK,CAACkB,QAAQ,CAChC,CAAC;EAED,OAAO;IACNf,aAAa;IACbS,mBAAmB;IACnBM;EACD,CAAC;AACF,CAAC;AAACK,OAAA,CAAAxB,iBAAA,GAAAA,iBAAA","ignoreList":[]}