@tamagui/sheet 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/useGestureHandlerPan.native.cjs

@@ -0,0 +1,273 @@
+"use strict";
+
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useGestureHandlerPan_exports = {};
+__export(useGestureHandlerPan_exports, { useGestureHandlerPan: () => useGestureHandlerPan });
+module.exports = __toCommonJS(useGestureHandlerPan_exports);
+var import_constants = require("@tamagui/constants");
+var import_react = require("react");
+var import_gestureState = require("./gestureState.native.js");
+var import_keyboardAvoidance = require("./keyboardAvoidance.native.js");
+var AT_TOP_THRESHOLD = 5;
+var SCROLL_HANDOFF_THRESHOLD = 160;
+function useGestureHandlerPan(config) {
+	var { positions, frameSize, setPosition, animateTo, stopSpring, scrollBridge, setIsDragging, getCurrentPosition, resisted, disableDrag, isShowingInnerSheet, setAnimatedPosition, scrollGestureRef } = config;
+	var gestureHandlerEnabled = (0, import_gestureState.isGestureHandlerEnabled)();
+	var panGestureRef = (0, import_react.useRef)(null);
+	var _config_snapPointsMode;
+	var releaseConfigRef = (0, import_react.useRef)({
+		dismissOnSnapToBottom: config.dismissOnSnapToBottom === true,
+		snapPointsMode: (_config_snapPointsMode = config.snapPointsMode) !== null && _config_snapPointsMode !== void 0 ? _config_snapPointsMode : "percent",
+		isKeyboardVisible: config.isKeyboardVisible === true
+	});
+	var _config_snapPointsMode1;
+	releaseConfigRef.current = {
+		dismissOnSnapToBottom: config.dismissOnSnapToBottom === true,
+		snapPointsMode: (_config_snapPointsMode1 = config.snapPointsMode) !== null && _config_snapPointsMode1 !== void 0 ? _config_snapPointsMode1 : "percent",
+		isKeyboardVisible: config.isKeyboardVisible === true
+	};
+	var gestureStateRef = (0, import_react.useRef)({
+		startY: 0,
+		lastPanTranslationY: 0,
+		accumulatedOffset: 0,
+		prevTranslationY: 0,
+		scrollEngaged: false,
+		frozenPositions: [],
+		frozenMinY: 0,
+		frozenIsKeyboardVisible: false,
+		panStarted: false,
+		startedBelowTop: false,
+		upwardDragAfterTop: 0,
+		scrollUnlockedAfterTop: false,
+		keepScrollLockedAfterEnd: false
+	});
+	var unlockScrollTimer = (0, import_react.useRef)(null);
+	(0, import_react.useEffect)(function() {
+		return function() {
+			if (unlockScrollTimer.current) {
+				clearTimeout(unlockScrollTimer.current);
+				unlockScrollTimer.current = null;
+			}
+		};
+	}, []);
+	var onStart = (0, import_react.useCallback)(function() {
+		stopSpring();
+	}, [stopSpring]);
+	var onEnd = (0, import_react.useCallback)(function(closestPoint, animationOverride) {
+		var keepScrollLocked = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+		if (unlockScrollTimer.current) {
+			clearTimeout(unlockScrollTimer.current);
+			unlockScrollTimer.current = null;
+		}
+		setIsDragging(false);
+		scrollBridge.setParentDragging(false);
+		scrollBridge.lockScrollAtTop = false;
+		if (keepScrollLocked) {
+			var _scrollBridge_setScrollEnabled;
+			(_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 ? void 0 : _scrollBridge_setScrollEnabled.call(scrollBridge, false, 0);
+			unlockScrollTimer.current = setTimeout(function() {
+				var _scrollBridge_setScrollEnabled2;
+				unlockScrollTimer.current = null;
+				(_scrollBridge_setScrollEnabled2 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled2 === void 0 ? void 0 : _scrollBridge_setScrollEnabled2.call(scrollBridge, true);
+			}, 160);
+		} else {
+			var _scrollBridge_setScrollEnabled1;
+			(_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 ? void 0 : _scrollBridge_setScrollEnabled1.call(scrollBridge, true);
+		}
+		setPosition(closestPoint);
+		animateTo(closestPoint, animationOverride);
+	}, [
+		setIsDragging,
+		scrollBridge,
+		setPosition,
+		animateTo
+	]);
+	var panGesture = (0, import_react.useMemo)(function() {
+		if (!gestureHandlerEnabled || disableDrag || isShowingInnerSheet || !frameSize) {
+			return null;
+		}
+		var { Gesture } = (0, import_gestureState.getGestureHandlerState)();
+		if (!Gesture) {
+			return null;
+		}
+		var minY = positions[0];
+		var gs = gestureStateRef.current;
+		var gesture = Gesture.Pan().withRef(panGestureRef).activeOffsetY([-10, 10]).failOffsetX([-20, 20]).shouldCancelWhenOutside(false).onBegin(function() {
+			gs.panStarted = false;
+			if (config.pauseKeyboardHandler) {
+				config.pauseKeyboardHandler.current = true;
+			}
+			var pos = getCurrentPosition();
+			var atTop = pos <= minY + AT_TOP_THRESHOLD;
+			var currentScrollY = scrollBridge.y;
+			gs.startY = pos;
+			gs.lastPanTranslationY = 0;
+			gs.accumulatedOffset = 0;
+			gs.prevTranslationY = 0;
+			gs.scrollEngaged = currentScrollY > 0;
+			gs.frozenPositions = [...positions];
+			gs.frozenMinY = minY;
+			gs.frozenIsKeyboardVisible = releaseConfigRef.current.isKeyboardVisible;
+			gs.startedBelowTop = !atTop;
+			gs.upwardDragAfterTop = 0;
+			gs.scrollUnlockedAfterTop = false;
+			gs.keepScrollLockedAfterEnd = false;
+			scrollBridge.lockScrollAtTop = false;
+			if (unlockScrollTimer.current) {
+				clearTimeout(unlockScrollTimer.current);
+				unlockScrollTimer.current = null;
+			}
+			if (!atTop) {
+				var _scrollBridge_setScrollEnabled;
+				(_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 ? void 0 : _scrollBridge_setScrollEnabled.call(scrollBridge, false, 0);
+			}
+		}).onStart(function() {
+			gs.panStarted = true;
+			setIsDragging(true);
+			scrollBridge.initialPosition = gs.startY;
+			onStart();
+		}).onChange(function(event) {
+			var { translationY } = event;
+			var isSwipingDown = gs.prevTranslationY < translationY;
+			var deltaY = translationY - gs.prevTranslationY;
+			gs.prevTranslationY = translationY;
+			var scrollY = scrollBridge.y;
+			if (scrollY > 0) {
+				gs.scrollEngaged = true;
+			}
+			var currentPos = gs.startY + gs.accumulatedOffset;
+			var isCurrentlyAtTop = currentPos <= minY + AT_TOP_THRESHOLD;
+			var nodeIsScrolling = scrollY > 0;
+			var panHandles = false;
+			var hasScrollableContent = scrollBridge.hasScrollableContent !== false;
+			if (!isCurrentlyAtTop) {
+				if (isSwipingDown) {
+					panHandles = !nodeIsScrolling || !hasScrollableContent;
+				} else {
+					panHandles = true;
+				}
+			} else {
+				if (isSwipingDown) {
+					if (nodeIsScrolling && hasScrollableContent) {
+						panHandles = false;
+					} else if (gs.scrollEngaged && hasScrollableContent) {
+						panHandles = true;
+					} else {
+						panHandles = true;
+					}
+				} else {
+					if (hasScrollableContent) {
+						if (gs.startedBelowTop && !gs.scrollUnlockedAfterTop) {
+							gs.upwardDragAfterTop += Math.max(0, -deltaY);
+							if (gs.upwardDragAfterTop >= SCROLL_HANDOFF_THRESHOLD) {
+								gs.scrollUnlockedAfterTop = true;
+								panHandles = false;
+							} else {
+								panHandles = true;
+							}
+						} else {
+							panHandles = false;
+						}
+					} else {
+						panHandles = true;
+					}
+				}
+			}
+			if (panHandles) {
+				var _scrollBridge_setScrollEnabled;
+				scrollBridge.lockScrollAtTop = gs.startedBelowTop && !gs.scrollUnlockedAfterTop;
+				var lockTo = isCurrentlyAtTop && isSwipingDown && gs.scrollEngaged ? void 0 : 0;
+				(_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 ? void 0 : _scrollBridge_setScrollEnabled.call(scrollBridge, false, lockTo);
+				gs.accumulatedOffset += deltaY;
+				var newPosition = resisted(gs.startY + gs.accumulatedOffset, minY);
+				scrollBridge.paneY = newPosition;
+				setAnimatedPosition(newPosition);
+				scrollBridge.setParentDragging(newPosition > minY);
+			} else {
+				var _scrollBridge_setScrollEnabled1;
+				scrollBridge.lockScrollAtTop = false;
+				(_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 ? void 0 : _scrollBridge_setScrollEnabled1.call(scrollBridge, true);
+				scrollBridge.setParentDragging(false);
+			}
+		}).onEnd(function(event) {
+			var { velocityY } = event;
+			var currentPos = gs.startY + gs.accumulatedOffset;
+			var keepScrollLockedAfterEnd = gs.startedBelowTop && !gs.scrollUnlockedAfterTop;
+			scrollBridge.lockScrollAtTop = false;
+			scrollBridge.scrollLockY = keepScrollLockedAfterEnd ? 0 : void 0;
+			gs.keepScrollLockedAfterEnd = keepScrollLockedAfterEnd;
+			var snapPositions = gs.frozenPositions.length > 0 ? gs.frozenPositions : positions;
+			var snapMinY = gs.frozenPositions.length > 0 ? gs.frozenMinY : minY;
+			if (currentPos <= snapMinY + AT_TOP_THRESHOLD && scrollBridge.y > 0) {
+				onEnd(0, void 0, keepScrollLockedAfterEnd);
+				return;
+			}
+			var velocity = velocityY / 1e3;
+			var projectedEnd = currentPos + frameSize * velocity * .2;
+			var releaseConfig = releaseConfigRef.current;
+			var closestPoint = (0, import_keyboardAvoidance.getSheetReleasePosition)({
+				positions: snapPositions,
+				projectedEnd,
+				currentPosition: currentPos,
+				frameSize,
+				dismissOnSnapToBottom: releaseConfig.dismissOnSnapToBottom,
+				snapPointsMode: releaseConfig.snapPointsMode,
+				isKeyboardVisible: gs.frozenIsKeyboardVisible,
+				isWeb: import_constants.isWeb
+			});
+			onEnd(closestPoint, void 0, keepScrollLockedAfterEnd);
+		}).onFinalize(function() {
+			scrollBridge.lockScrollAtTop = false;
+			scrollBridge.scrollLockY = gs.keepScrollLockedAfterEnd ? 0 : void 0;
+			if (gs.panStarted) {
+				setIsDragging(false);
+			} else {
+				if (config.pauseKeyboardHandler) {
+					config.pauseKeyboardHandler.current = false;
+				}
+			}
+		}).runOnJS(true);
+		if (scrollGestureRef === null || scrollGestureRef === void 0 ? void 0 : scrollGestureRef.current) {
+			return gesture.simultaneousWithExternalGesture(scrollGestureRef.current);
+		}
+		return gesture;
+	}, [
+		gestureHandlerEnabled,
+		disableDrag,
+		isShowingInnerSheet,
+		frameSize,
+		positions,
+		scrollBridge,
+		getCurrentPosition,
+		resisted,
+		onStart,
+		onEnd,
+		setIsDragging,
+		setAnimatedPosition
+	]);
+	return {
+		panGesture,
+		panGestureRef,
+		gestureHandlerEnabled
+	};
+}