@tamagui/sheet 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/useSheetScrollViewGestures.cjs

@@ -1,191 +1,183 @@
+
 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
-  });
+	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;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var useSheetScrollViewGestures_exports = {};
-__export(useSheetScrollViewGestures_exports, {
-  useSheetScrollViewGestures: () => useSheetScrollViewGestures
-});
+__export(useSheetScrollViewGestures_exports, { useSheetScrollViewGestures: () => useSheetScrollViewGestures });
 module.exports = __toCommonJS(useSheetScrollViewGestures_exports);
 var import_react = require("react");
-function useSheetScrollViewGestures({
-  scrollRef,
-  scrollBridge,
-  hasScrollableContent,
-  onManualScroll
-}) {
-  const state = (0, import_react.useRef)({
-    startY: 0,
-    lastY: 0,
-    owner: "none",
-    hadPanOwner: false,
-    panDragOffset: 0,
-    dys: [],
-    scrollYAtGestureStart: 0
-  });
-  const onManualScrollRef = (0, import_react.useRef)(onManualScroll);
-  (0, import_react.useEffect)(() => {
-    onManualScrollRef.current = onManualScroll;
-  }, [onManualScroll]);
-  (0, import_react.useEffect)(() => {
-    if (!scrollRef.current) return;
-    const controller = new AbortController();
-    const node = scrollRef.current?.getScrollableNode();
-    if (!node) return;
-    node.style.overscrollBehavior = "contain";
-    let originalOverflow = "";
-    const disableScroll = () => {
-      if (node.style.overflowY !== "hidden") {
-        originalOverflow = node.style.overflowY;
-        node.style.overflowY = "hidden";
-      }
-    };
-    const enableScroll = () => {
-      node.style.overflowY = originalOverflow;
-    };
-    const setScrollTop = nextScrollY => {
-      if (node.scrollTop === nextScrollY) return;
-      node.scrollTop = nextScrollY;
-      onManualScrollRef.current?.(node, nextScrollY);
-    };
-    const handleTouchStart = e => {
-      const touch = e.touches[0];
-      if (!touch) return;
-      const currentScrollY = node.scrollTop;
-      state.current = {
-        startY: touch.pageY,
-        lastY: touch.pageY,
-        owner: "none",
-        hadPanOwner: false,
-        panDragOffset: 0,
-        dys: [],
-        scrollYAtGestureStart: currentScrollY
-      };
-      scrollBridge.scrollStartY = touch.pageY;
-      scrollBridge.scrollNodeTouched = true;
-    };
-    const handleTouchMove = e => {
-      const touch = e.touches[0];
-      if (!touch) return;
-      const {
-        current: s
-      } = state;
-      const pageY = touch.pageY;
-      const dy = pageY - s.lastY;
-      s.lastY = pageY;
-      if (dy === 0) return;
-      const isDraggingDown = dy > 0;
-      const currentScrollY = node.scrollTop;
-      const isPaneAtTop = scrollBridge.isAtTop ?? scrollBridge.paneY <= scrollBridge.paneMinY + 5;
-      scrollBridge.y = currentScrollY;
-      let shouldPanOwn = false;
-      if (!isPaneAtTop) {
-        shouldPanOwn = true;
-      } else if (currentScrollY <= 0 && isDraggingDown) {
-        shouldPanOwn = true;
-      }
-      const newOwner = shouldPanOwn ? "pan" : "scroll";
-      if (newOwner !== s.owner) {
-        if (newOwner === "pan") {
-          s.hadPanOwner = true;
-          s.panDragOffset = 0;
-          s.dys = [];
-          scrollBridge.startPanDrag?.();
-          scrollBridge.setParentDragging(true);
-          disableScroll();
-        } else {
-          scrollBridge.setParentDragging(false);
-          scrollBridge.scrollLock = false;
-          if (s.hadPanOwner) {
-            disableScroll();
-          } else {
-            enableScroll();
-          }
-        }
-        s.owner = newOwner;
-      }
-      if (s.owner === "pan") {
-        if (e.cancelable) e.preventDefault();
-        s.panDragOffset += dy;
-        scrollBridge.drag(s.panDragOffset);
-        s.dys.push(dy);
-        if (s.dys.length > 100) s.dys = s.dys.slice(-10);
-      } else if (s.owner === "scroll" && (!e.isTrusted || s.hadPanOwner)) {
-        if (e.cancelable) e.preventDefault();
-        const scrollDelta = -dy;
-        const maxScrollY = node.scrollHeight - node.clientHeight;
-        const newScrollY = Math.max(0, Math.min(maxScrollY, currentScrollY + scrollDelta));
-        if (newScrollY !== currentScrollY) {
-          setScrollTop(newScrollY);
-          scrollBridge.y = newScrollY;
-          if (newScrollY > 0) scrollBridge.scrollStartY = -1;
-        }
-      }
-    };
-    const handleTouchEnd = () => {
-      const {
-        current: s
-      } = state;
-      if (s.owner === "pan") {
-        scrollBridge.setParentDragging(false);
-        let vy = 0;
-        if (s.dys.length) {
-          const recentDys = s.dys.slice(-10);
-          const dist = recentDys.reduce((a, b) => a + b, 0);
-          vy = dist / recentDys.length * 0.04;
-        }
-        scrollBridge.release({
-          dragAt: s.panDragOffset,
-          vy
-        });
-      } else if (s.owner === "scroll") {
-        scrollBridge.snapToPosition?.(0);
-      }
-      enableScroll();
-      s.owner = "none";
-      s.hadPanOwner = false;
-      s.panDragOffset = 0;
-      s.dys = [];
-      scrollBridge.scrollNodeTouched = false;
-    };
-    node.addEventListener("touchstart", handleTouchStart, {
-      signal: controller.signal,
-      passive: true
-    });
-    node.addEventListener("touchmove", handleTouchMove, {
-      signal: controller.signal,
-      passive: false
-    });
-    node.addEventListener("touchend", handleTouchEnd, {
-      signal: controller.signal,
-      passive: true
-    });
-    node.addEventListener("touchcancel", handleTouchEnd, {
-      signal: controller.signal,
-      passive: true
-    });
-    return () => {
-      enableScroll();
-      controller.abort();
-    };
-  }, [scrollRef, scrollBridge, hasScrollableContent]);
-  return {};
-}
+function useSheetScrollViewGestures({ scrollRef, scrollBridge, hasScrollableContent, onManualScroll }) {
+	const state = (0, import_react.useRef)({
+		startY: 0,
+		lastY: 0,
+		owner: "none",
+		hadPanOwner: false,
+		panDragOffset: 0,
+		dys: [],
+		scrollYAtGestureStart: 0
+	});
+	const onManualScrollRef = (0, import_react.useRef)(onManualScroll);
+	(0, import_react.useEffect)(() => {
+		onManualScrollRef.current = onManualScroll;
+	}, [onManualScroll]);
+	(0, import_react.useEffect)(() => {
+		if (!scrollRef.current) return;
+		const controller = new AbortController();
+		const node = scrollRef.current?.getScrollableNode();
+		if (!node) return;
+		node.style.overscrollBehavior = "contain";
+		let originalOverflow = "";
+		const disableScroll = () => {
+			if (node.style.overflowY !== "hidden") {
+				originalOverflow = node.style.overflowY;
+				node.style.overflowY = "hidden";
+			}
+		};
+		const enableScroll = () => {
+			node.style.overflowY = originalOverflow;
+		};
+		const setScrollTop = (nextScrollY) => {
+			if (node.scrollTop === nextScrollY) return;
+			node.scrollTop = nextScrollY;
+			onManualScrollRef.current?.(node, nextScrollY);
+		};
+		const handleTouchStart = (e) => {
+			const touch = e.touches[0];
+			if (!touch) return;
+			const currentScrollY = node.scrollTop;
+			state.current = {
+				startY: touch.pageY,
+				lastY: touch.pageY,
+				owner: "none",
+				hadPanOwner: false,
+				panDragOffset: 0,
+				dys: [],
+				scrollYAtGestureStart: currentScrollY
+			};
+			scrollBridge.scrollStartY = touch.pageY;
+			scrollBridge.scrollNodeTouched = true;
+		};
+		const handleTouchMove = (e) => {
+			const touch = e.touches[0];
+			if (!touch) return;
+			const { current: s } = state;
+			const pageY = touch.pageY;
+			const dy = pageY - s.lastY;
+			s.lastY = pageY;
+			if (dy === 0) return;
+			const isDraggingDown = dy > 0;
+			const currentScrollY = node.scrollTop;
+			const isPaneAtTop = scrollBridge.isAtTop ?? scrollBridge.paneY <= scrollBridge.paneMinY + 5;
+			scrollBridge.y = currentScrollY;
+			let shouldPanOwn = false;
+			if (!isPaneAtTop) {
+				shouldPanOwn = true;
+			} else if (currentScrollY <= 0 && isDraggingDown) {
+				shouldPanOwn = true;
+			}
+			const newOwner = shouldPanOwn ? "pan" : "scroll";
+			if (newOwner !== s.owner) {
+				if (newOwner === "pan") {
+					s.hadPanOwner = true;
+					s.panDragOffset = 0;
+					s.dys = [];
+					scrollBridge.startPanDrag?.();
+					scrollBridge.setParentDragging(true);
+					disableScroll();
+				} else {
+					scrollBridge.setParentDragging(false);
+					scrollBridge.scrollLock = false;
+					if (s.hadPanOwner) {
+						disableScroll();
+					} else {
+						enableScroll();
+					}
+				}
+				s.owner = newOwner;
+			}
+			if (s.owner === "pan") {
+				if (e.cancelable) e.preventDefault();
+				s.panDragOffset += dy;
+				scrollBridge.drag(s.panDragOffset);
+				s.dys.push(dy);
+				if (s.dys.length > 100) s.dys = s.dys.slice(-10);
+			} else if (s.owner === "scroll" && (!e.isTrusted || s.hadPanOwner)) {
+				if (e.cancelable) e.preventDefault();
+				const scrollDelta = -dy;
+				const maxScrollY = node.scrollHeight - node.clientHeight;
+				const newScrollY = Math.max(0, Math.min(maxScrollY, currentScrollY + scrollDelta));
+				if (newScrollY !== currentScrollY) {
+					setScrollTop(newScrollY);
+					scrollBridge.y = newScrollY;
+					if (newScrollY > 0) scrollBridge.scrollStartY = -1;
+				}
+			}
+		};
+		const handleTouchEnd = () => {
+			const { current: s } = state;
+			if (s.owner === "pan") {
+				scrollBridge.setParentDragging(false);
+				let vy = 0;
+				if (s.dys.length) {
+					const recentDys = s.dys.slice(-10);
+					const dist = recentDys.reduce((a, b) => a + b, 0);
+					vy = dist / recentDys.length * .04;
+				}
+				scrollBridge.release({
+					dragAt: s.panDragOffset,
+					vy
+				});
+			} else if (s.owner === "scroll") {
+				scrollBridge.snapToPosition?.(0);
+			}
+			enableScroll();
+			s.owner = "none";
+			s.hadPanOwner = false;
+			s.panDragOffset = 0;
+			s.dys = [];
+			scrollBridge.scrollNodeTouched = false;
+		};
+		node.addEventListener("touchstart", handleTouchStart, {
+			signal: controller.signal,
+			passive: true
+		});
+		node.addEventListener("touchmove", handleTouchMove, {
+			signal: controller.signal,
+			passive: false
+		});
+		node.addEventListener("touchend", handleTouchEnd, {
+			signal: controller.signal,
+			passive: true
+		});
+		node.addEventListener("touchcancel", handleTouchEnd, {
+			signal: controller.signal,
+			passive: true
+		});
+		return () => {
+			enableScroll();
+			controller.abort();
+		};
+	}, [
+		scrollRef,
+		scrollBridge,
+		hasScrollableContent
+	]);
+	return {};
+}

package/dist/cjs/useSheetScrollViewGestures.native.cjs

@@ -0,0 +1,150 @@
+"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 useSheetScrollViewGestures_native_exports = {};
+__export(useSheetScrollViewGestures_native_exports, { useSheetScrollViewGestures: () => useSheetScrollViewGestures });
+module.exports = __toCommonJS(useSheetScrollViewGestures_native_exports);
+var import_react = require("react");
+function useSheetScrollViewGestures(param) {
+	var { scrollBridge, hasScrollableContent, scrollEnabled, setScrollEnabled } = param;
+	var state = (0, import_react.useRef)({
+		lastPageY: 0,
+		dragAt: 0,
+		dys: [],
+		isScrolling: false,
+		isDraggingScrollArea: false,
+		scrollEngaged: false,
+		prevScrollY: 0,
+		handoffOccurred: false,
+		handoffDragOffset: 0
+	});
+	var release = function() {
+		var s = state.current;
+		if (!s.isDraggingScrollArea) return;
+		s.isDraggingScrollArea = false;
+		scrollBridge.scrollStartY = -1;
+		scrollBridge.scrollLock = false;
+		s.isScrolling = false;
+		s.scrollEngaged = false;
+		s.prevScrollY = 0;
+		s.handoffOccurred = false;
+		s.handoffDragOffset = 0;
+		setScrollEnabled(true);
+		var vy = 0;
+		if (s.dys.length) {
+			var recentDys = s.dys.slice(-10);
+			var dist = recentDys.reduce(function(a, b) {
+				return a + b;
+			}, 0);
+			vy = dist / recentDys.length * .04;
+		}
+		s.dys = [];
+		scrollBridge.release({
+			dragAt: s.dragAt,
+			vy
+		});
+	};
+	var onStartShouldSetResponder = function() {
+		var s = state.current;
+		scrollBridge.scrollStartY = -1;
+		s.isDraggingScrollArea = true;
+		s.scrollEngaged = scrollBridge.y > 0;
+		s.prevScrollY = scrollBridge.y;
+		s.handoffOccurred = false;
+		s.handoffDragOffset = 0;
+		return false;
+	};
+	var onMoveShouldSetResponder = function(e) {
+		if (!scrollEnabled) return false;
+		var s = state.current;
+		var { pageY } = e.nativeEvent;
+		if (s.lastPageY === 0) {
+			s.lastPageY = pageY;
+			return false;
+		}
+		return Math.abs(pageY - s.lastPageY) > 10;
+	};
+	var onResponderMove = function(e) {
+		var s = state.current;
+		var { pageY } = e.nativeEvent;
+		if (!s.isScrolling && scrollBridge.scrollStartY === -1) {
+			scrollBridge.scrollStartY = pageY;
+			s.lastPageY = pageY;
+		}
+		var dragAt = pageY - scrollBridge.scrollStartY;
+		var dy = pageY - s.lastPageY;
+		s.lastPageY = pageY;
+		var isDraggingDown = dy > 0;
+		var isPaneAtTop = scrollBridge.paneY <= scrollBridge.paneMinY + 5;
+		var currentScrollY = scrollBridge.y;
+		if (currentScrollY > 0) s.scrollEngaged = true;
+		var wasScrolledNowAtZero = s.scrollEngaged && s.prevScrollY > 0 && currentScrollY <= 0;
+		if (wasScrolledNowAtZero && !s.handoffOccurred) {
+			s.handoffOccurred = true;
+			s.handoffDragOffset = 0;
+		}
+		s.prevScrollY = currentScrollY;
+		var panHandles = false;
+		if (!isPaneAtTop) {
+			panHandles = isDraggingDown ? currentScrollY <= 0 || !hasScrollableContent : true;
+		} else if (isDraggingDown) {
+			if (currentScrollY > 0 && hasScrollableContent && !s.handoffOccurred) {
+				panHandles = false;
+			} else {
+				panHandles = s.handoffOccurred || wasScrolledNowAtZero || currentScrollY <= 0;
+			}
+		} else {
+			panHandles = !hasScrollableContent;
+			if (!panHandles) {
+				s.handoffOccurred = false;
+				s.handoffDragOffset = 0;
+				s.scrollEngaged = currentScrollY > 0;
+				s.prevScrollY = currentScrollY;
+				s.isScrolling = true;
+				scrollBridge.scrollLock = true;
+				setScrollEnabled(true);
+				return;
+			}
+		}
+		if (panHandles) {
+			setScrollEnabled(false);
+			var effectiveDragAt = dragAt;
+			if (s.handoffOccurred) {
+				s.handoffDragOffset += dy;
+				effectiveDragAt = s.handoffDragOffset;
+			}
+			scrollBridge.drag(effectiveDragAt);
+			s.dragAt = effectiveDragAt;
+			s.dys.push(dy);
+			if (s.dys.length > 100) s.dys = s.dys.slice(-10);
+		} else {
+			setScrollEnabled(true);
+		}
+	};
+	return {
+		onResponderRelease: release,
+		onStartShouldSetResponder,
+		onMoveShouldSetResponder,
+		onResponderMove
+	};
+}