@tamagui/sheet 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/SheetScrollView.cjs

@@ -1,3 +1,4 @@
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5,36 +6,27 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
 }) : target, mod));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var SheetScrollView_exports = {};
-__export(SheetScrollView_exports, {
-  SheetScrollView: () => SheetScrollView
-});
+__export(SheetScrollView_exports, { SheetScrollView: () => SheetScrollView });
 module.exports = __toCommonJS(SheetScrollView_exports);
 var import_compose_refs = require("@tamagui/compose-refs");
 var import_core = require("@tamagui/core");
@@ -48,290 +40,277 @@ var import_useSheetScrollViewGestures = require("./useSheetScrollViewGestures.cj
 var import_webViewport = require("./webViewport.cjs");
 var import_jsx_runtime = require("react/jsx-runtime");
 const SHEET_SCROLL_VIEW_NAME = "SheetScrollView";
-const SheetScrollView = import_react.default.forwardRef(({
-  __scopeSheet,
-  children,
-  onScroll,
-  scrollEnabled: scrollEnabledProp,
-  ...props
-}, ref) => {
-  const context = (0, import_SheetContext.useSheetContext)(SHEET_SCROLL_VIEW_NAME, __scopeSheet);
-  const gestureContext = (0, import_GestureSheetContext.useGestureSheetContext)();
-  const {
-    scrollBridge,
-    setHasScrollView,
-    hasFit,
-    screenSize
-  } = context;
-  const keyboardOccludedHeight = Math.max(0, context.keyboardOccludedHeight || 0);
-  const isKeyboardVisible = context.isKeyboardVisible === true || import_core.isWeb && (0, import_webViewport.getWebKeyboardResizeHeight)() >= import_webViewport.MIN_KEYBOARD_HEIGHT;
-  const [scrollEnabled] = (0, import_use_controllable_state.useControllableState)({
-    prop: scrollEnabledProp,
-    defaultProp: true
-  });
-  const scrollRef = import_react.default.useRef(null);
-  const [hasScrollableContent, setHasScrollableContent] = (0, import_react.useState)(true);
-  const parentHeight = (0, import_react.useRef)(0);
-  const contentHeight = (0, import_react.useRef)(0);
-  const frozenFrameHeight = Math.max(0, context.keyboardStableFrameHeight || 0);
-  const fitSizingStyle = hasFit ? {
-    flex: void 0,
-    height: void 0,
-    maxHeight: screenSize || void 0
-  } : {
-    flex: 1
-  };
-  const contentContainerStyle = hasFit ? void 0 : {
-    minHeight: "100%"
-  };
-  const keyboardFrozenOverride = hasFit && isKeyboardVisible && frozenFrameHeight > 0 ? {
-    height: frozenFrameHeight,
-    maxHeight: frozenFrameHeight
-  } : null;
-  const panGestureRef = gestureContext?.panGestureRef;
-  const {
-    ScrollView: RNGHScrollView
-  } = (0, import_gestureState.getGestureHandlerState)();
-  const useRNGHScrollView = (0, import_gestureState.isGestureHandlerEnabled)() && RNGHScrollView && panGestureRef;
-  const currentScrollOffset = (0, import_react.useRef)(0);
-  const lastEmittedScrollOffset = (0, import_react.useRef)(0);
-  const lockedScrollY = (0, import_react.useRef)(0);
-  const focusedInputScrollFrame = (0, import_react.useRef)(0);
-  const setScrollEnabled = (next, lockTo) => {
-    if (!next) {
-      const lockY = lockTo ?? scrollBridge.scrollLockY ?? currentScrollOffset.current;
-      if (scrollBridge.enabled === false && scrollBridge.scrollLockY === lockY) {
-        return;
-      }
-      scrollBridge.enabled = false;
-      lockedScrollY.current = lockY;
-      scrollBridge.scrollLockY = lockY;
-      if (currentScrollOffset.current !== lockY) {
-        scrollRef.current?.scrollTo?.({
-          x: 0,
-          y: lockY,
-          animated: false
-        });
-        currentScrollOffset.current = lockY;
-      }
-    } else {
-      if (scrollBridge.enabled === true && scrollBridge.scrollLockY === void 0) {
-        return;
-      }
-      scrollBridge.enabled = true;
-      lockedScrollY.current = currentScrollOffset.current;
-      scrollBridge.scrollLockY = void 0;
-    }
-  };
-  const forceScrollTo = y => {
-    scrollRef.current?.scrollTo?.({
-      x: 0,
-      y,
-      animated: false
-    });
-    currentScrollOffset.current = y;
-  };
-  const emitManualScroll = import_react.default.useCallback((node, y) => {
-    currentScrollOffset.current = y;
-    scrollBridge.y = y;
-    if (y > 0) scrollBridge.scrollStartY = -1;
-    lastEmittedScrollOffset.current = y;
-    onScroll?.({
-      nativeEvent: {
-        contentOffset: {
-          x: node.scrollLeft,
-          y
-        },
-        contentSize: {
-          height: node.scrollHeight,
-          width: node.scrollWidth
-        },
-        layoutMeasurement: {
-          height: node.offsetHeight,
-          width: node.offsetWidth
-        }
-      },
-      timeStamp: Date.now()
-    });
-  }, [onScroll, scrollBridge]);
-  const scrollFocusedInputClearOfKeyboard = import_react.default.useCallback(() => {
-    if (!import_core.isWeb || !hasFit || !isKeyboardVisible || keyboardOccludedHeight <= 0) {
-      return;
-    }
-    const node = scrollRef.current?.getScrollableNode();
-    const active = document.activeElement;
-    if (!node || !active || !(0, import_webViewport.isEditableElement)(active) || !node.contains(active)) {
-      return;
-    }
-    const keyboardHeight = Math.max(keyboardOccludedHeight, (0, import_webViewport.getWebKeyboardBottomInset)());
-    if (keyboardHeight <= 0) return;
-    const activeRect = active.getBoundingClientRect();
-    const nodeRect = node.getBoundingClientRect();
-    const margin = 12;
-    const keyboardTop = (0, import_webViewport.getStableLayoutViewportHeight)() - keyboardHeight;
-    const visibleTop = nodeRect.top + margin;
-    const visibleBottom = Math.min(nodeRect.bottom, keyboardTop) - margin;
-    let nextScrollTop = node.scrollTop;
-    if (activeRect.bottom > visibleBottom) {
-      nextScrollTop += Math.ceil(activeRect.bottom - visibleBottom);
-    } else if (activeRect.top < visibleTop) {
-      nextScrollTop -= Math.ceil(visibleTop - activeRect.top);
-    }
-    const maxScrollTop = Math.max(0, node.scrollHeight - node.clientHeight);
-    nextScrollTop = Math.max(0, Math.min(maxScrollTop, nextScrollTop));
-    if (nextScrollTop === node.scrollTop) return;
-    node.scrollTop = nextScrollTop;
-    currentScrollOffset.current = nextScrollTop;
-    scrollBridge.y = nextScrollTop;
-    if (nextScrollTop > 0) scrollBridge.scrollStartY = -1;
-  }, [hasFit, isKeyboardVisible, keyboardOccludedHeight, scrollBridge]);
-  const scheduleFocusedInputScroll = import_react.default.useCallback(() => {
-    if (!import_core.isWeb || !hasFit) return;
-    cancelAnimationFrame(focusedInputScrollFrame.current);
-    focusedInputScrollFrame.current = requestAnimationFrame(() => {
-      scrollFocusedInputClearOfKeyboard();
-      focusedInputScrollFrame.current = requestAnimationFrame(scrollFocusedInputClearOfKeyboard);
-    });
-  }, [hasFit, scrollFocusedInputClearOfKeyboard]);
-  (0, import_react.useEffect)(() => {
-    if (!import_core.isWeb || !hasFit) return;
-    scheduleFocusedInputScroll();
-    window.addEventListener("focusin", scheduleFocusedInputScroll);
-    window.visualViewport?.addEventListener("resize", scheduleFocusedInputScroll);
-    return () => {
-      cancelAnimationFrame(focusedInputScrollFrame.current);
-      window.removeEventListener("focusin", scheduleFocusedInputScroll);
-      window.visualViewport?.removeEventListener("resize", scheduleFocusedInputScroll);
-    };
-  }, [hasFit, scheduleFocusedInputScroll]);
-  (0, import_react.useEffect)(() => {
-    setHasScrollView(true);
-    if ((0, import_gestureState.isGestureHandlerEnabled)()) {
-      scrollBridge.setScrollEnabled = setScrollEnabled;
-      scrollBridge.forceScrollTo = forceScrollTo;
-    }
-    return () => {
-      setHasScrollView(false);
-      scrollBridge.setScrollEnabled = void 0;
-      scrollBridge.forceScrollTo = void 0;
-    };
-  }, []);
-  const updateScrollable = () => {
-    if (parentHeight.current && contentHeight.current) {
-      setHasScrollableContent(contentHeight.current > parentHeight.current);
-    }
-  };
-  const recordFitHeight = height => {
-    parentHeight.current = height;
-  };
-  (0, import_react.useEffect)(() => {
-    scrollBridge.hasScrollableContent = hasScrollableContent;
-  }, [hasScrollableContent]);
-  const gestureProps = (0, import_useSheetScrollViewGestures.useSheetScrollViewGestures)({
-    scrollRef,
-    scrollBridge,
-    hasScrollableContent,
-    scrollEnabled,
-    setScrollEnabled,
-    onManualScroll: emitManualScroll
-  });
-  const contentWrapper = /* @__PURE__ */(0, import_jsx_runtime.jsxs)(import_core.View, {
-    onLayout: e => {
-      const height = Math.floor(e.nativeEvent.layout.height);
-      if (height !== contentHeight.current) {
-        contentHeight.current = height;
-        updateScrollable();
-        if (keyboardOccludedHeight > 0) {
-          scheduleFocusedInputScroll();
-        }
-      }
-    },
-    children: [children, keyboardOccludedHeight > 0 && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_core.View, {
-      "data-sheet-keyboard-scroll-pad": true,
-      height: keyboardOccludedHeight,
-      width: "100%"
-    })]
-  });
-  if (useRNGHScrollView && RNGHScrollView && panGestureRef) {
-    const RNGHComponent = RNGHScrollView;
-    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(RNGHComponent, {
-      ref: (0, import_compose_refs.composeRefs)(scrollRef, ref),
-      style: fitSizingStyle,
-      scrollEventThrottle: 1,
-      scrollEnabled,
-      simultaneousHandlers: [panGestureRef],
-      onLayout: e => {
-        recordFitHeight(Math.ceil(e.nativeEvent.layout.height));
-        updateScrollable();
-      },
-      onScroll: e => {
-        const {
-          y
-        } = e.nativeEvent.contentOffset;
-        currentScrollOffset.current = y;
-        if (scrollBridge.scrollLockY !== void 0) {
-          if (y !== scrollBridge.scrollLockY) {
-            scrollRef.current?.scrollTo?.({
-              x: 0,
-              y: scrollBridge.scrollLockY,
-              animated: false
-            });
-          }
-          currentScrollOffset.current = scrollBridge.scrollLockY;
-          scrollBridge.y = scrollBridge.scrollLockY;
-          if (lastEmittedScrollOffset.current !== scrollBridge.scrollLockY) {
-            lastEmittedScrollOffset.current = scrollBridge.scrollLockY;
-            onScroll?.({
-              ...e,
-              nativeEvent: {
-                ...e.nativeEvent,
-                contentOffset: {
-                  ...e.nativeEvent.contentOffset,
-                  y: scrollBridge.scrollLockY
-                }
-              }
-            });
-          }
-          return;
-        }
-        scrollBridge.y = y;
-        if (y > 0) scrollBridge.scrollStartY = -1;
-        lastEmittedScrollOffset.current = y;
-        onScroll?.(e);
-      },
-      contentContainerStyle,
-      bounces: false,
-      keyboardShouldPersistTaps: "always",
-      keyboardDismissMode: "none",
-      ...props,
-      ...keyboardFrozenOverride,
-      children: contentWrapper
-    });
-  }
-  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_scroll_view.ScrollView, {
-    onLayout: e => {
-      recordFitHeight(Math.ceil(e.nativeEvent.layout.height));
-      updateScrollable();
-    },
-    ref: (0, import_compose_refs.composeRefs)(scrollRef, ref),
-    ...fitSizingStyle,
-    scrollEventThrottle: 1,
-    className: "_ovs-contain",
-    scrollEnabled,
-    onScroll: e => {
-      const {
-        y
-      } = e.nativeEvent.contentOffset;
-      currentScrollOffset.current = y;
-      scrollBridge.y = y;
-      if (y > 0) scrollBridge.scrollStartY = -1;
-      lastEmittedScrollOffset.current = y;
-      onScroll?.(e);
-    },
-    contentContainerStyle,
-    ...gestureProps,
-    ...props,
-    ...keyboardFrozenOverride,
-    children: contentWrapper
-  });
-});
+const SheetScrollView = (0, import_core.createStyledHOC)(import_scroll_view.ScrollView, ({ scope, children, onScroll, scrollEnabled: scrollEnabledProp, ...props }, ref) => {
+	const context = (0, import_SheetContext.useSheetContext)(scope);
+	const gestureContext = (0, import_GestureSheetContext.useGestureSheetContext)();
+	const { scrollBridge, setHasScrollView, hasFit, screenSize } = context;
+	const keyboardOccludedHeight = Math.max(0, context.keyboardOccludedHeight || 0);
+	const isKeyboardVisible = context.isKeyboardVisible === true || import_core.isWeb && (0, import_webViewport.getWebKeyboardResizeHeight)() >= import_webViewport.MIN_KEYBOARD_HEIGHT;
+	const [scrollEnabled] = (0, import_use_controllable_state.useControllableState)({
+		prop: scrollEnabledProp,
+		defaultProp: true
+	});
+	const scrollRef = import_react.default.useRef(null);
+	const [hasScrollableContent, setHasScrollableContent] = (0, import_react.useState)(true);
+	const parentHeight = (0, import_react.useRef)(0);
+	const contentHeight = (0, import_react.useRef)(0);
+	const frozenFrameHeight = Math.max(0, context.keyboardStableFrameHeight || 0);
+	const fitSizingStyle = hasFit ? {
+		flex: void 0,
+		height: void 0,
+		maxHeight: screenSize || void 0
+	} : { flex: 1 };
+	const contentContainerStyle = hasFit ? void 0 : { minHeight: "100%" };
+	const keyboardFrozenOverride = hasFit && isKeyboardVisible && frozenFrameHeight > 0 ? {
+		height: frozenFrameHeight,
+		maxHeight: frozenFrameHeight
+	} : null;
+	const panGestureRef = gestureContext?.panGestureRef;
+	const { ScrollView: RNGHScrollView } = (0, import_gestureState.getGestureHandlerState)();
+	const useRNGHScrollView = (0, import_gestureState.isGestureHandlerEnabled)() && RNGHScrollView && panGestureRef;
+	const currentScrollOffset = (0, import_react.useRef)(0);
+	const lastEmittedScrollOffset = (0, import_react.useRef)(0);
+	const lockedScrollY = (0, import_react.useRef)(0);
+	const focusedInputScrollFrame = (0, import_react.useRef)(0);
+	const setScrollEnabled = (next, lockTo) => {
+		if (!next) {
+			const lockY = lockTo ?? scrollBridge.scrollLockY ?? currentScrollOffset.current;
+			if (scrollBridge.enabled === false && scrollBridge.scrollLockY === lockY) {
+				return;
+			}
+			scrollBridge.enabled = false;
+			lockedScrollY.current = lockY;
+			scrollBridge.scrollLockY = lockY;
+			if (currentScrollOffset.current !== lockY) {
+				scrollRef.current?.scrollTo?.({
+					x: 0,
+					y: lockY,
+					animated: false
+				});
+				currentScrollOffset.current = lockY;
+			}
+		} else {
+			if (scrollBridge.enabled === true && scrollBridge.scrollLockY === void 0) {
+				return;
+			}
+			scrollBridge.enabled = true;
+			lockedScrollY.current = currentScrollOffset.current;
+			scrollBridge.scrollLockY = void 0;
+		}
+	};
+	const forceScrollTo = (y) => {
+		scrollRef.current?.scrollTo?.({
+			x: 0,
+			y,
+			animated: false
+		});
+		currentScrollOffset.current = y;
+	};
+	const emitManualScroll = import_react.default.useCallback((node, y) => {
+		currentScrollOffset.current = y;
+		scrollBridge.y = y;
+		if (y > 0) scrollBridge.scrollStartY = -1;
+		lastEmittedScrollOffset.current = y;
+		onScroll?.({
+			nativeEvent: {
+				contentOffset: {
+					x: node.scrollLeft,
+					y
+				},
+				contentSize: {
+					height: node.scrollHeight,
+					width: node.scrollWidth
+				},
+				layoutMeasurement: {
+					height: node.offsetHeight,
+					width: node.offsetWidth
+				}
+			},
+			timeStamp: Date.now()
+		});
+	}, [onScroll, scrollBridge]);
+	const scrollFocusedInputClearOfKeyboard = import_react.default.useCallback(() => {
+		if (!import_core.isWeb || !hasFit || !isKeyboardVisible || keyboardOccludedHeight <= 0) {
+			return;
+		}
+		const node = scrollRef.current?.getScrollableNode();
+		const active = document.activeElement;
+		if (!node || !active || !(0, import_webViewport.isEditableElement)(active) || !node.contains(active)) {
+			return;
+		}
+		const keyboardHeight = Math.max(keyboardOccludedHeight, (0, import_webViewport.getWebKeyboardBottomInset)());
+		if (keyboardHeight <= 0) return;
+		const activeRect = active.getBoundingClientRect();
+		const nodeRect = node.getBoundingClientRect();
+		const margin = 12;
+		const keyboardTop = (0, import_webViewport.getStableLayoutViewportHeight)() - keyboardHeight;
+		const visibleTop = nodeRect.top + margin;
+		const visibleBottom = Math.min(nodeRect.bottom, keyboardTop) - margin;
+		let nextScrollTop = node.scrollTop;
+		if (activeRect.bottom > visibleBottom) {
+			nextScrollTop += Math.ceil(activeRect.bottom - visibleBottom);
+		} else if (activeRect.top < visibleTop) {
+			nextScrollTop -= Math.ceil(visibleTop - activeRect.top);
+		}
+		const maxScrollTop = Math.max(0, node.scrollHeight - node.clientHeight);
+		nextScrollTop = Math.max(0, Math.min(maxScrollTop, nextScrollTop));
+		if (nextScrollTop === node.scrollTop) return;
+		node.scrollTop = nextScrollTop;
+		currentScrollOffset.current = nextScrollTop;
+		scrollBridge.y = nextScrollTop;
+		if (nextScrollTop > 0) scrollBridge.scrollStartY = -1;
+	}, [
+		hasFit,
+		isKeyboardVisible,
+		keyboardOccludedHeight,
+		scrollBridge
+	]);
+	const scheduleFocusedInputScroll = import_react.default.useCallback(() => {
+		if (!import_core.isWeb || !hasFit) return;
+		cancelAnimationFrame(focusedInputScrollFrame.current);
+		focusedInputScrollFrame.current = requestAnimationFrame(() => {
+			scrollFocusedInputClearOfKeyboard();
+			focusedInputScrollFrame.current = requestAnimationFrame(scrollFocusedInputClearOfKeyboard);
+		});
+	}, [hasFit, scrollFocusedInputClearOfKeyboard]);
+	(0, import_react.useEffect)(() => {
+		if (!import_core.isWeb || !hasFit) return;
+		scheduleFocusedInputScroll();
+		window.addEventListener("focusin", scheduleFocusedInputScroll);
+		window.visualViewport?.addEventListener("resize", scheduleFocusedInputScroll);
+		return () => {
+			cancelAnimationFrame(focusedInputScrollFrame.current);
+			window.removeEventListener("focusin", scheduleFocusedInputScroll);
+			window.visualViewport?.removeEventListener("resize", scheduleFocusedInputScroll);
+		};
+	}, [hasFit, scheduleFocusedInputScroll]);
+	(0, import_react.useEffect)(() => {
+		setHasScrollView(true);
+		if ((0, import_gestureState.isGestureHandlerEnabled)()) {
+			scrollBridge.setScrollEnabled = setScrollEnabled;
+			scrollBridge.forceScrollTo = forceScrollTo;
+		}
+		return () => {
+			setHasScrollView(false);
+			scrollBridge.setScrollEnabled = void 0;
+			scrollBridge.forceScrollTo = void 0;
+		};
+	}, []);
+	const updateScrollable = () => {
+		if (parentHeight.current && contentHeight.current) {
+			setHasScrollableContent(contentHeight.current > parentHeight.current);
+		}
+	};
+	const recordFitHeight = (height) => {
+		parentHeight.current = height;
+	};
+	(0, import_react.useEffect)(() => {
+		scrollBridge.hasScrollableContent = hasScrollableContent;
+	}, [hasScrollableContent]);
+	const gestureProps = (0, import_useSheetScrollViewGestures.useSheetScrollViewGestures)({
+		scrollRef,
+		scrollBridge,
+		hasScrollableContent,
+		scrollEnabled,
+		setScrollEnabled,
+		onManualScroll: emitManualScroll
+	});
+	const contentWrapper = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_core.View, {
+		onLayout: (e) => {
+			const height = Math.floor(e.nativeEvent.layout.height);
+			if (height !== contentHeight.current) {
+				contentHeight.current = height;
+				updateScrollable();
+				if (keyboardOccludedHeight > 0) {
+					scheduleFocusedInputScroll();
+				}
+			}
+		},
+		children: [children, keyboardOccludedHeight > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_core.View, {
+			"data-sheet-keyboard-scroll-pad": true,
+			height: keyboardOccludedHeight,
+			width: "100%"
+		})]
+	});
+	if (useRNGHScrollView && RNGHScrollView && panGestureRef) {
+		const RNGHComponent = RNGHScrollView;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RNGHComponent, {
+			ref: (0, import_compose_refs.composeRefs)(scrollRef, ref),
+			style: fitSizingStyle,
+			scrollEventThrottle: 1,
+			scrollEnabled,
+			simultaneousHandlers: [panGestureRef],
+			onLayout: (e) => {
+				recordFitHeight(Math.ceil(e.nativeEvent.layout.height));
+				updateScrollable();
+			},
+			onScroll: (e) => {
+				const { y } = e.nativeEvent.contentOffset;
+				currentScrollOffset.current = y;
+				if (scrollBridge.scrollLockY !== void 0) {
+					if (y !== scrollBridge.scrollLockY) {
+						scrollRef.current?.scrollTo?.({
+							x: 0,
+							y: scrollBridge.scrollLockY,
+							animated: false
+						});
+					}
+					currentScrollOffset.current = scrollBridge.scrollLockY;
+					scrollBridge.y = scrollBridge.scrollLockY;
+					if (lastEmittedScrollOffset.current !== scrollBridge.scrollLockY) {
+						lastEmittedScrollOffset.current = scrollBridge.scrollLockY;
+						onScroll?.({
+							...e,
+							nativeEvent: {
+								...e.nativeEvent,
+								contentOffset: {
+									...e.nativeEvent.contentOffset,
+									y: scrollBridge.scrollLockY
+								}
+							}
+						});
+					}
+					return;
+				}
+				scrollBridge.y = y;
+				if (y > 0) scrollBridge.scrollStartY = -1;
+				lastEmittedScrollOffset.current = y;
+				onScroll?.(e);
+			},
+			contentContainerStyle,
+			bounces: false,
+			keyboardShouldPersistTaps: "always",
+			keyboardDismissMode: "none",
+			...props,
+			...keyboardFrozenOverride,
+			children: contentWrapper
+		});
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_scroll_view.ScrollView, {
+		onLayout: (e) => {
+			recordFitHeight(Math.ceil(e.nativeEvent.layout.height));
+			updateScrollable();
+		},
+		ref: (0, import_compose_refs.composeRefs)(scrollRef, ref),
+		...fitSizingStyle,
+		scrollEventThrottle: 1,
+		className: "_ovs-contain",
+		scrollEnabled,
+		onScroll: (e) => {
+			const { y } = e.nativeEvent.contentOffset;
+			currentScrollOffset.current = y;
+			scrollBridge.y = y;
+			if (y > 0) scrollBridge.scrollStartY = -1;
+			lastEmittedScrollOffset.current = y;
+			onScroll?.(e);
+		},
+		contentContainerStyle,
+		...gestureProps,
+		...props,
+		...keyboardFrozenOverride,
+		children: contentWrapper
+	});
+}, {
+	disableTheme: true,
+	displayName: SHEET_SCROLL_VIEW_NAME
+});