@tamagui/sheet 2.0.0-rc.9 → 2.1.0

package/dist/esm/SheetImplementationCustom.native.js

@@ -3,481 +3,648 @@ import { ProvideAdaptContext, useAdaptContext } from "@tamagui/adapt";
 import { AnimatePresence } from "@tamagui/animate-presence";
 import { useComposedRefs } from "@tamagui/compose-refs";
 import { isWeb, useIsomorphicLayoutEffect } from "@tamagui/constants";
-import { LayoutMeasurementController, View as TamaguiView, Theme, useConfiguration, useDidFinishSSR, useEvent, useThemeName } from "@tamagui/core";
+import { LayoutMeasurementController, View as TamaguiView, useConfiguration, useDidFinishSSR, useEvent, useThemeName } from "@tamagui/core";
 import { getSafeArea } from "@tamagui/native";
 import { needsPortalRepropagation, Portal } from "@tamagui/portal";
 import React, { useState } from "react";
 import { Dimensions, PanResponder, View } from "react-native";
 import { ParentSheetContext, SheetInsideSheetContext } from "./contexts.native.js";
 import { GestureDetectorWrapper } from "./GestureDetectorWrapper.native.js";
+import { getGestureHandlerState } from "./gestureState.native.js";
 import { GestureSheetProvider } from "./GestureSheetContext.native.js";
 import { resisted } from "./helpers.native.js";
+import { getKeyboardOccludedHeight } from "./keyboardAvoidance.native.js";
+import { getStableLayoutViewportHeight, getWebKeyboardHeight, MIN_KEYBOARD_HEIGHT } from "./webViewport.native.js";
 import { SheetProvider } from "./SheetContext.native.js";
 import { useGestureHandlerPan } from "./useGestureHandlerPan.native.js";
 import { useKeyboardControllerSheet } from "./useKeyboardControllerSheet.native.js";
 import { useSheetOpenState } from "./useSheetOpenState.native.js";
 import { useSheetProviderProps } from "./useSheetProviderProps.native.js";
-var hiddenSize = 10000.1,
-  _cachedSafeAreaTop;
+var hiddenSize = 10000.1;
+var rnghRootStyleOpen = {
+  width: "100%",
+  height: "100%"
+};
+var rnghRootStyleClosed = {
+  width: "100%",
+  height: 0
+};
+var _cachedSafeAreaTop;
 function getSafeAreaTopInset() {
-  return _cachedSafeAreaTop !== void 0 || (_cachedSafeAreaTop = getSafeArea().getInsets().top), _cachedSafeAreaTop;
+  if (_cachedSafeAreaTop !== void 0) return _cachedSafeAreaTop;
+  _cachedSafeAreaTop = getSafeArea().getInsets().top;
+  return _cachedSafeAreaTop;
 }
-var relativeDimensionTo = isWeb ? "window" : "screen",
-  SheetImplementationCustom = /* @__PURE__ */React.forwardRef(function (props, forwardedRef) {
-    var parentSheet = React.useContext(ParentSheetContext),
-      {
-        transition,
-        transitionConfig: transitionConfigProp,
-        modal = !1,
-        zIndex = parentSheet.zIndex + 1,
-        moveOnKeyboardChange = !1,
-        unmountChildrenWhenHidden = !1,
-        portalProps,
-        containerComponent: ContainerComponent = React.Fragment
-      } = props,
-      state = useSheetOpenState(props),
-      [overlayComponent, setOverlayComponent] = React.useState(null),
-      providerProps = useSheetProviderProps(props, state, {
-        onOverlayComponent: setOverlayComponent
-      }),
-      {
-        frameSize,
-        setFrameSize,
-        snapPoints,
-        snapPointsMode,
-        hasFit,
-        position,
-        setPosition,
-        scrollBridge,
-        screenSize,
-        setMaxContentSize,
-        maxSnapPoint
-      } = providerProps,
-      {
-        open,
-        controller,
-        isHidden
-      } = state,
-      sheetRef = React.useRef(void 0),
-      ref = useComposedRefs(forwardedRef, sheetRef, providerProps.contentRef),
-      {
-        animationDriver
-      } = useConfiguration();
-    if (!animationDriver) throw new Error("Sheet requires an animation driver to be set");
-    var transitionConfig = function () {
-        var _animationDriver_animations;
-        if (transitionConfigProp) return transitionConfigProp;
-        var [animationProp, animationPropConfig] = transition ? Array.isArray(transition) ? transition : [transition] : [];
-        return animationProp && !((_animationDriver_animations = animationDriver.animations) === null || _animationDriver_animations === void 0) && _animationDriver_animations[animationProp] ? {
-          ...animationDriver.animations[animationProp],
-          ...animationPropConfig
-        } : null;
-      }(),
-      [isShowingInnerSheet, setIsShowingInnerSheet] = React.useState(!1),
-      shouldHideParentSheet = !isWeb && modal && isShowingInnerSheet && needsPortalRepropagation(),
-      sheetInsideSheet = React.useContext(SheetInsideSheetContext),
-      onInnerSheet = React.useCallback(function (hasChild) {
-        setIsShowingInnerSheet(hasChild);
-      }, []),
-      stableFrameSize = React.useRef(frameSize);
-    React.useEffect(function () {
-      open && frameSize && (stableFrameSize.current = frameSize);
-    }, [open, frameSize]);
-    var effectiveFrameSize = open ? frameSize : stableFrameSize.current || frameSize,
-      positions = React.useMemo(function () {
-        return snapPoints.map(function (point) {
-          return getYPositions(snapPointsMode, point, screenSize, effectiveFrameSize);
-        });
-      }, [screenSize, effectiveFrameSize, snapPoints, snapPointsMode]),
-      {
-        keyboardHeight,
-        isKeyboardVisible,
-        dismissKeyboard,
-        pauseKeyboardHandler,
-        flushPendingHide
-      } = useKeyboardControllerSheet({
-        enabled: !isWeb && !!moveOnKeyboardChange
-      }),
-      [isDragging, setIsDragging_] = React.useState(!1),
-      isDraggingRef = React.useRef(!1),
-      setIsDragging = React.useCallback(function (val) {
-        isDraggingRef.current = val, pauseKeyboardHandler.current = val, setIsDragging_(val), val || flushPendingHide();
-      }, [pauseKeyboardHandler, flushPendingHide]),
-      activePositionsRef = React.useRef(positions),
-      activePositions = React.useMemo(function () {
-        if (isDragging || isDraggingRef.current) return activePositionsRef.current;
-        var result;
-        if (!isKeyboardVisible || keyboardHeight <= 0) result = positions;else {
-          var safeAreaTop = isWeb ? 0 : getSafeAreaTopInset();
-          result = positions.map(function (p) {
-            return screenSize && p >= screenSize ? p : Math.max(safeAreaTop, p - keyboardHeight);
-          });
-        }
-        return activePositionsRef.current = result, result;
-      }, [positions, isKeyboardVisible, keyboardHeight, screenSize, isDragging]),
-      {
-        useAnimatedNumber,
-        useAnimatedNumberStyle,
-        useAnimatedNumberReaction
-      } = animationDriver,
-      _animationDriver_View,
-      AnimatedView = (_animationDriver_View = animationDriver.View) !== null && _animationDriver_View !== void 0 ? _animationDriver_View : TamaguiView;
-    useIsomorphicLayoutEffect(function () {
-      if (sheetInsideSheet && open) return sheetInsideSheet(!0), function () {
-        sheetInsideSheet(!1);
-      };
-    }, [sheetInsideSheet, open]);
-    var nextParentContext = React.useMemo(function () {
-        return {
-          zIndex
-        };
-      }, [zIndex]),
-      isMounted = useDidFinishSSR(),
-      startPosition = isMounted && screenSize ? screenSize : hiddenSize,
-      animatedNumber = useAnimatedNumber(startPosition),
-      at = React.useRef(startPosition),
-      hasntMeasured = at.current === hiddenSize,
-      [disableAnimation, setDisableAnimation] = useState(hasntMeasured),
-      skipAdaptAnimation = React.useRef(!1);
-    controller?.skipNextAnimation && (skipAdaptAnimation.current = !0);
-    var hasScrollView = React.useRef(!1);
-    useAnimatedNumberReaction({
-      value: animatedNumber,
-      hostRef: sheetRef
-    }, React.useCallback(function (value) {
-      at.current = value, scrollBridge.paneY = value;
-      var minY = activePositions[0],
-        wasAtTop = scrollBridge.isAtTop,
-        nowAtTop = value <= minY + 5;
-      if (wasAtTop !== nowAtTop) if (scrollBridge.isAtTop = nowAtTop, nowAtTop) {
+var relativeDimensionTo = isWeb ? "window" : "screen";
+function getStableViewportHeight() {
+  if (isWeb && typeof window !== "undefined") return getStableLayoutViewportHeight();
+  return Dimensions.get(relativeDimensionTo).height;
+}
+var SheetImplementationCustom = /* @__PURE__ */React.forwardRef(function SheetImplementationCustom2(props, forwardedRef) {
+  var parentSheet = React.useContext(ParentSheetContext);
+  var {
+    transition,
+    transitionConfig: transitionConfigProp,
+    modal = false,
+    zIndex = parentSheet.zIndex + 1,
+    moveOnKeyboardChange = false,
+    unmountChildrenWhenHidden = false,
+    portalProps,
+    containerComponent: ContainerComponent = React.Fragment,
+    onAnimationComplete
+  } = props;
+  var state = useSheetOpenState(props);
+  var [overlayComponent, setOverlayComponent] = React.useState(null);
+  var providerProps = useSheetProviderProps(props, state, {
+    onOverlayComponent: setOverlayComponent
+  });
+  var {
+    frameSize,
+    setFrameSize,
+    snapPoints,
+    snapPointsMode,
+    hasFit,
+    position,
+    setPosition,
+    scrollBridge,
+    screenSize,
+    setMaxContentSize,
+    maxSnapPoint
+  } = providerProps;
+  var {
+    open,
+    controller,
+    isHidden
+  } = state;
+  var openRef = React.useRef(open);
+  openRef.current = open;
+  var sheetRef = React.useRef(void 0);
+  var ref = useComposedRefs(forwardedRef, sheetRef, providerProps.contentRef);
+  var {
+    animationDriver
+  } = useConfiguration();
+  if (!animationDriver) throw new Error(`Sheet requires an animation driver to be set`);
+  var transitionConfig = function () {
+    var _animationDriver_animations;
+    if (transitionConfigProp) return transitionConfigProp;
+    var [animationProp, animationPropConfig] = !transition ? [] : Array.isArray(transition) ? transition : [transition];
+    if (animationProp && ((_animationDriver_animations = animationDriver.animations) === null || _animationDriver_animations === void 0 ? void 0 : _animationDriver_animations[animationProp])) return {
+      ...animationDriver.animations[animationProp],
+      ...animationPropConfig
+    };
+    return null;
+  }();
+  var [isShowingInnerSheet, setIsShowingInnerSheet] = React.useState(false);
+  var shouldHideParentSheet = !isWeb && modal && isShowingInnerSheet && needsPortalRepropagation();
+  var sheetInsideSheet = React.useContext(SheetInsideSheetContext);
+  var onInnerSheet = React.useCallback(function (hasChild) {
+    setIsShowingInnerSheet(hasChild);
+  }, []);
+  var {
+    keyboardHeight,
+    isKeyboardVisible,
+    dismissKeyboard,
+    pauseKeyboardHandler,
+    flushPendingHide
+  } = useKeyboardControllerSheet({
+    enabled: Boolean(moveOnKeyboardChange)
+  });
+  var stableFrameSize = React.useRef(frameSize);
+  React.useEffect(function () {
+    if (open && frameSize) stableFrameSize.current = frameSize;
+  }, [open, frameSize]);
+  var isWebKbSheet = isWeb && hasFit && moveOnKeyboardChange;
+  var hasCleanKbBaseline = React.useRef(false);
+  var seedSettled = React.useRef(false);
+  var stableKbGeom = React.useRef({
+    frame: 0,
+    screen: 0
+  });
+  if ((!isWeb || !isKeyboardVisible) && frameSize > 0 && screenSize > 0) {
+    stableKbGeom.current.frame = frameSize;
+    stableKbGeom.current.screen = screenSize;
+    hasCleanKbBaseline.current = true;
+  } else if (isWebKbSheet && isKeyboardVisible && !hasCleanKbBaseline.current && screenSize > 0) stableKbGeom.current.screen = Math.max(stableKbGeom.current.screen, screenSize);
+  var seedingKbBaseline = isWebKbSheet && isKeyboardVisible && !hasCleanKbBaseline.current && !seedSettled.current;
+  var freezeForKb = isWebKbSheet && isKeyboardVisible && stableKbGeom.current.frame > 0;
+  var effScreenSize = freezeForKb ? stableKbGeom.current.screen : screenSize;
+  var effectiveFrameSize = freezeForKb ? stableKbGeom.current.frame : open ? frameSize : stableFrameSize.current || frameSize;
+  var positions = React.useMemo(function () {
+    return snapPoints.map(function (point) {
+      return getYPositions(snapPointsMode, point, effScreenSize, effectiveFrameSize);
+    });
+  }, [effScreenSize, effectiveFrameSize, snapPoints, snapPointsMode]);
+  var [isDragging, setIsDragging_] = React.useState(false);
+  var isDraggingRef = React.useRef(false);
+  var setIsDragging = React.useCallback(function (val) {
+    isDraggingRef.current = val;
+    pauseKeyboardHandler.current = val;
+    setIsDragging_(val);
+    if (!val) flushPendingHide();
+  }, [pauseKeyboardHandler, flushPendingHide]);
+  var activePositionsRef = React.useRef(positions);
+  var activePositions = React.useMemo(function () {
+    if (isDragging || isDraggingRef.current) return activePositionsRef.current;
+    var result;
+    if (isWeb || !isKeyboardVisible || keyboardHeight <= 0) result = positions;else {
+      var safeAreaTop = getSafeAreaTopInset();
+      result = positions.map(function (p) {
+        if (screenSize && p >= screenSize) return p;
+        return Math.max(safeAreaTop, p - keyboardHeight);
+      });
+    }
+    activePositionsRef.current = result;
+    return result;
+  }, [positions, isKeyboardVisible, keyboardHeight, screenSize, isDragging]);
+  var keyboardOccludedHeight = seedingKbBaseline ? 0 : getKeyboardOccludedHeight({
+    frameSize: effectiveFrameSize,
+    isKeyboardVisible,
+    keyboardHeight,
+    screenSize: effScreenSize,
+    sheetY: position >= 0 ? activePositions[position] : void 0
+  });
+  var keyboardStableFrameHeight = !isWebKbSheet ? 0 : seedingKbBaseline ? stableKbGeom.current.screen || screenSize : stableKbGeom.current.frame > 0 ? stableKbGeom.current.frame : 0;
+  var {
+    useAnimatedNumber,
+    useAnimatedNumberStyle,
+    useAnimatedNumberReaction
+  } = animationDriver;
+  var _animationDriver_View;
+  var AnimatedView = (_animationDriver_View = animationDriver.View) !== null && _animationDriver_View !== void 0 ? _animationDriver_View : TamaguiView;
+  useIsomorphicLayoutEffect(function () {
+    if (!(sheetInsideSheet && open)) return;
+    sheetInsideSheet(true);
+    return function () {
+      sheetInsideSheet(false);
+    };
+  }, [sheetInsideSheet, open]);
+  var nextParentContext = React.useMemo(function () {
+    return {
+      zIndex
+    };
+  }, [zIndex]);
+  var startPosition = useDidFinishSSR() && screenSize ? screenSize : hiddenSize;
+  var animatedNumber = useAnimatedNumber(startPosition);
+  var at = React.useRef(startPosition);
+  var hasntMeasured = at.current === hiddenSize;
+  var [disableAnimation, setDisableAnimation] = useState(hasntMeasured);
+  var skipAdaptAnimation = React.useRef(false);
+  if (controller === null || controller === void 0 ? void 0 : controller.skipNextAnimation) skipAdaptAnimation.current = true;
+  var hasScrollView = React.useRef(false);
+  var opacityFallbackTimer = React.useRef(null);
+  useAnimatedNumberReaction({
+    value: animatedNumber,
+    hostRef: sheetRef
+  }, React.useCallback(function (value) {
+    at.current = value;
+    scrollBridge.paneY = value;
+    var minY = activePositions[0];
+    var wasAtTop = scrollBridge.isAtTop;
+    var nowAtTop = value <= minY + 5;
+    if (wasAtTop !== nowAtTop) {
+      scrollBridge.isAtTop = nowAtTop;
+      if (nowAtTop) {
         var _scrollBridge_setScrollEnabled;
-        scrollBridge.scrollLockY = void 0, (_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 || _scrollBridge_setScrollEnabled.call(scrollBridge, !0);
+        if (scrollBridge.y > 0) {
+          var _scrollBridge_forceScrollTo;
+          (_scrollBridge_forceScrollTo = scrollBridge.forceScrollTo) === null || _scrollBridge_forceScrollTo === void 0 || _scrollBridge_forceScrollTo.call(scrollBridge, 0);
+          scrollBridge.y = 0;
+        }
+        scrollBridge.scrollLockY = void 0;
+        (_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 || _scrollBridge_setScrollEnabled.call(scrollBridge, true);
       } else {
         var _scrollBridge_setScrollEnabled1;
-        scrollBridge.scrollLockY = 0, (_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 || _scrollBridge_setScrollEnabled1.call(scrollBridge, !1);
+        scrollBridge.scrollLockY = 0;
+        (_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 || _scrollBridge_setScrollEnabled1.call(scrollBridge, false);
       }
-    }, [animationDriver, activePositions]));
-    function stopSpring() {
-      animatedNumber.stop(), scrollBridge.onFinishAnimate && (scrollBridge.onFinishAnimate(), scrollBridge.onFinishAnimate = void 0);
     }
-    var animateTo = useEvent(function (position2, animationOverride) {
-      if (frameSize !== 0) {
-        var toValue = isHidden || position2 === -1 ? screenSize : activePositions[position2];
-        if (at.current !== toValue) {
-          if (at.current = toValue, stopSpring(), skipAdaptAnimation.current) {
-            skipAdaptAnimation.current = !1, animatedNumber.setValue(toValue, {
-              type: "timing",
-              duration: 0
-            });
-            return;
-          }
-          animatedNumber.setValue(toValue, animationOverride || {
-            type: "spring",
-            ...transitionConfig
-          });
-        }
-      }
-    });
-    useIsomorphicLayoutEffect(function () {
-      if (hasntMeasured && screenSize && frameSize) {
-        at.current = screenSize, animatedNumber.setValue(screenSize, {
-          type: "timing",
-          duration: 0
-        }, function () {
-          setTimeout(function () {
-            setDisableAnimation(!1);
-          }, 10);
-        });
-        return;
-      }
-      if (!disableAnimation && !(!frameSize || !screenSize || isHidden || hasntMeasured && !open) && (animateTo(position), position === -1 && (scrollBridge.scrollLock = !1, scrollBridge.scrollStartY = -1), open && position >= 0)) {
-        var isTopPosition = position === 0;
-        if (scrollBridge.isAtTop = isTopPosition, isTopPosition) {
-          var _scrollBridge_setScrollEnabled;
-          scrollBridge.scrollLockY = void 0, (_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 || _scrollBridge_setScrollEnabled.call(scrollBridge, !0);
-        } else {
-          var _scrollBridge_setScrollEnabled1;
-          scrollBridge.scrollLockY = 0, (_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 || _scrollBridge_setScrollEnabled1.call(scrollBridge, !1);
-        }
+  }, [animationDriver, activePositions]));
+  function stopSpring() {
+    animatedNumber.stop();
+    if (scrollBridge.onFinishAnimate) {
+      scrollBridge.onFinishAnimate();
+      scrollBridge.onFinishAnimate = void 0;
+    }
+  }
+  var animateTo = useEvent(function (position2, animationOverride) {
+    if (frameSize === 0) return;
+    var toValue = isHidden || position2 === -1 ? effScreenSize : activePositions[position2];
+    if (at.current === toValue) return;
+    at.current = toValue;
+    stopSpring();
+    var isOpenAnimation = position2 !== -1 && !isHidden;
+    if (opacityFallbackTimer.current) {
+      clearTimeout(opacityFallbackTimer.current);
+      opacityFallbackTimer.current = null;
+    }
+    var animationCompleteCallback = function () {
+      var _controller_onAnimationComplete;
+      if (opacityFallbackTimer.current) {
+        clearTimeout(opacityFallbackTimer.current);
+        opacityFallbackTimer.current = null;
       }
-    }, [hasntMeasured, disableAnimation, isHidden, frameSize, screenSize, open, position]);
-    var _props_disableDrag,
-      disableDrag = (_props_disableDrag = props.disableDrag) !== null && _props_disableDrag !== void 0 ? _props_disableDrag : controller?.disableDrag,
-      themeName = useThemeName(),
-      [blockPan, setBlockPan] = React.useState(!1),
-      panResponder = React.useMemo(function () {
-        if (disableDrag || !frameSize || isShowingInnerSheet) return;
-        var minY = positions[0];
-        scrollBridge.paneMinY = minY;
-        var startY = at.current;
-        function setPanning(val) {
-          setIsDragging(val);
-        }
-        var release = function (param) {
-            var {
-              vy
-            } = param;
-            if (scrollBridge.setParentDragging(!1), !scrollBridge.scrollLock) {
-              isExternalDrag = !1, previouslyScrolling = !1, setPanning(!1);
-              for (var currentPos = at.current, end = currentPos + frameSize * vy * 0.2, closestPoint = 0, dist = Number.POSITIVE_INFINITY, i = 0; i < positions.length; i++) {
-                var position2 = positions[i],
-                  curDist = end > position2 ? end - position2 : position2 - end;
-                curDist < dist && (dist = curDist, closestPoint = i);
-              }
-              setPosition(closestPoint), animateTo(closestPoint);
-            }
-          },
-          finish = function (_e, state2) {
-            release({
-              vy: state2.vy,
-              dragAt: state2.dy
-            });
-          },
-          previouslyScrolling = !1,
-          onMoveShouldSet = function (e, param) {
-            var {
-              dy
-            } = param;
-            function getShouldSet() {
-              if (e.target === providerProps.handleRef.current) return !0;
-              if (scrollBridge.hasScrollableContent === !0) {
-                if (scrollBridge.scrollLock) return !1;
-                var isScrolled = scrollBridge.y !== 0,
-                  isDraggingUp = dy < 0,
-                  isNearTop = scrollBridge.paneY - 5 <= scrollBridge.paneMinY;
-                if (isScrolled) return previouslyScrolling = !0, !1;
-                if (isNearTop && hasScrollView.current && isDraggingUp) return !1;
-              }
-              return Math.abs(dy) > 10;
-            }
-            var granted = getShouldSet();
-            return granted && scrollBridge.setParentDragging(!0), granted;
-          },
-          grant = function () {
-            setPanning(!0), stopSpring(), startY = at.current;
-          },
-          isExternalDrag = !1;
-        return scrollBridge.drag = function (dy) {
-          isExternalDrag || (isExternalDrag = !0, grant());
-          var to = dy + startY;
-          animatedNumber.setValue(resisted(to, minY), {
-            type: "direct"
-          });
-        }, scrollBridge.release = release, scrollBridge.snapToPosition = function (positionIndex) {
-          isExternalDrag = !1, previouslyScrolling = !1, setPanning(!1), setPosition(positionIndex), animateTo(positionIndex);
-        }, PanResponder.create({
-          onMoveShouldSetPanResponder: onMoveShouldSet,
-          onPanResponderGrant: grant,
-          onPanResponderMove: function (_e, param) {
-            var {
-                dy
-              } = param,
-              toFull = dy + startY,
-              to = resisted(toFull, minY),
-              isAtTop = to <= minY;
-            isAtTop ? scrollBridge.setParentDragging(!1) : scrollBridge.setParentDragging(!0), animatedNumber.setValue(to, {
-              type: "direct"
-            });
-          },
-          onPanResponderEnd: finish,
-          onPanResponderTerminate: finish,
-          onPanResponderRelease: finish
-        });
-      }, [disableDrag, isShowingInnerSheet, animateTo, frameSize, positions, setPosition]);
-    React.useEffect(function () {
-      isDragging || isHidden || !open || disableAnimation || !frameSize || !screenSize || animateTo(position, {
+      if (!isOpenAnimation && !openRef.current) setOpacity(0);
+      onAnimationComplete === null || onAnimationComplete === void 0 || onAnimationComplete({
+        open: isOpenAnimation
+      });
+      controller === null || controller === void 0 || (_controller_onAnimationComplete = controller.onAnimationComplete) == null || _controller_onAnimationComplete.call(controller, {
+        open: isOpenAnimation
+      });
+    };
+    if (!isOpenAnimation) opacityFallbackTimer.current = setTimeout(function () {
+      opacityFallbackTimer.current = null;
+      if (!openRef.current) setOpacity(0);
+    }, 1e3);
+    if (skipAdaptAnimation.current) {
+      skipAdaptAnimation.current = false;
+      animatedNumber.setValue(toValue, {
         type: "timing",
-        duration: 250
+        duration: 0
+      }, animationCompleteCallback);
+      return;
+    }
+    animatedNumber.setValue(toValue, animationOverride || {
+      type: "spring",
+      ...transitionConfig
+    }, animationCompleteCallback);
+  });
+  useIsomorphicLayoutEffect(function () {
+    if (hasntMeasured && screenSize && frameSize) {
+      at.current = screenSize;
+      animatedNumber.setValue(screenSize, {
+        type: "timing",
+        duration: 0
+      }, function () {
+        setTimeout(function () {
+          setDisableAnimation(false);
+        }, 10);
       });
-    }, [isKeyboardVisible, keyboardHeight]);
-    var wasDragging = React.useRef(!1);
-    React.useEffect(function () {
-      if (isDragging) {
-        wasDragging.current = !0;
-        return;
+      return;
+    }
+    if (disableAnimation) return;
+    if (isDraggingRef.current) return;
+    if (!frameSize || !screenSize || isHidden || hasntMeasured && !open) return;
+    animateTo(position);
+    if (position === -1) {
+      scrollBridge.scrollLock = false;
+      scrollBridge.scrollStartY = -1;
+    }
+    if (open && position >= 0) {
+      var isTopPosition = position === 0;
+      scrollBridge.isAtTop = isTopPosition;
+      if (isTopPosition) {
+        var _scrollBridge_setScrollEnabled;
+        scrollBridge.scrollLockY = void 0;
+        (_scrollBridge_setScrollEnabled = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled === void 0 || _scrollBridge_setScrollEnabled.call(scrollBridge, true);
+      } else {
+        var _scrollBridge_setScrollEnabled1;
+        scrollBridge.scrollLockY = 0;
+        (_scrollBridge_setScrollEnabled1 = scrollBridge.setScrollEnabled) === null || _scrollBridge_setScrollEnabled1 === void 0 || _scrollBridge_setScrollEnabled1.call(scrollBridge, false);
       }
-      wasDragging.current && (wasDragging.current = !1, !(!frameSize || !screenSize || isHidden || !open) && animateTo(position));
-    }, [isDragging]), React.useEffect(function () {
-      !open && isKeyboardVisible && dismissKeyboard();
-    }, [open]);
-    var {
-        panGesture,
-        panGestureRef,
-        gestureHandlerEnabled
-      } = useGestureHandlerPan({
-        positions: activePositions,
-        frameSize,
-        setPosition,
-        animateTo,
-        stopSpring,
-        scrollBridge,
-        setIsDragging,
-        getCurrentPosition: function () {
-          return at.current;
-        },
-        resisted,
-        disableDrag,
-        isShowingInnerSheet,
-        setAnimatedPosition: function (val) {
-          at.current = val, animatedNumber.setValue(val, {
-            type: "direct"
-          });
-        },
-        pauseKeyboardHandler
-      }),
-      handleAnimationViewLayout = React.useCallback(function (e) {
-        var _e_nativeEvent;
-        if (!(!open && stableFrameSize.current !== 0)) {
-          var layoutHeight = (_e_nativeEvent = e.nativeEvent) === null || _e_nativeEvent === void 0 ? void 0 : _e_nativeEvent.layout.height,
-            next = modal ? Math.min(layoutHeight, Dimensions.get(relativeDimensionTo).height) : layoutHeight;
-          next && setFrameSize(next);
+    }
+  }, [hasntMeasured, disableAnimation, isHidden, frameSize, screenSize, open, position]);
+  var _props_disableDrag;
+  var disableDrag = (_props_disableDrag = props.disableDrag) !== null && _props_disableDrag !== void 0 ? _props_disableDrag : controller === null || controller === void 0 ? void 0 : controller.disableDrag;
+  useThemeName();
+  var [blockPan, setBlockPan] = React.useState(false);
+  var panResponder = React.useMemo(function () {
+    if (disableDrag) return;
+    if (!frameSize) return;
+    if (isShowingInnerSheet) return;
+    var minY = activePositions[0];
+    scrollBridge.paneMinY = minY;
+    var startY = at.current;
+    function setPanning(val) {
+      setIsDragging(val);
+    }
+    var release = function (param) {
+      var {
+        vy
+      } = param;
+      scrollBridge.setParentDragging(false);
+      if (scrollBridge.scrollLock) return;
+      isExternalDrag = false;
+      previouslyScrolling = false;
+      setPanning(false);
+      var end = at.current + frameSize * vy * .2;
+      var closestPoint = 0;
+      var dist = Number.POSITIVE_INFINITY;
+      for (var i = 0; i < activePositions.length; i++) {
+        var position2 = activePositions[i];
+        var curDist = end > position2 ? end - position2 : position2 - end;
+        if (curDist < dist) {
+          dist = curDist;
+          closestPoint = i;
         }
-      }, [open, modal]),
-      handleMaxContentViewLayout = React.useCallback(function (e) {
-        var _e_nativeEvent,
-          next = Math.min((_e_nativeEvent = e.nativeEvent) === null || _e_nativeEvent === void 0 ? void 0 : _e_nativeEvent.layout.height, Dimensions.get(relativeDimensionTo).height);
-        next && setMaxContentSize(next);
-      }, []),
-      animatedStyle = useAnimatedNumberStyle(animatedNumber, function (val) {
-        "worklet";
-
-        var translateY = frameSize === 0 ? hiddenSize : val;
-        return {
-          transform: [{
-            translateY
-          }]
-        };
-      }),
-      [opacity, setOpacity] = React.useState(open ? 1 : 0);
-    open && opacity === 0 && setOpacity(1), React.useEffect(function () {
-      if (!open) {
-        var tm = setTimeout(function () {
-          setOpacity(0);
-        }, 400);
-        return function () {
-          clearTimeout(tm);
-        };
       }
-    }, [open]);
-    var forcedContentHeight = hasFit ? void 0 : snapPointsMode === "percent" ?
-      // Use dvh for modal (viewport-relative), % for inline (container-relative)
-      `${maxSnapPoint}${isWeb && modal ? "dvh" : "%"}` : maxSnapPoint,
-      setHasScrollView = React.useCallback(function (val) {
-        hasScrollView.current = val;
-      }, []),
-      contents = /* @__PURE__ */_jsx(LayoutMeasurementController, {
-        disable: !open,
-        children: /* @__PURE__ */_jsx(ParentSheetContext.Provider, {
-          value: nextParentContext,
-          children: /* @__PURE__ */_jsx(SheetProvider, {
-            ...providerProps,
-            setHasScrollView,
-            children: /* @__PURE__ */_jsxs(GestureSheetProvider, {
-              isDragging,
-              blockPan,
-              setBlockPan,
-              panGesture,
-              panGestureRef,
-              children: [/* @__PURE__ */_jsx(AnimatePresence, {
-                custom: {
-                  open
-                },
-                children: shouldHideParentSheet || !open ? null : overlayComponent
-              }), snapPointsMode !== "percent" && /* @__PURE__ */_jsx(View, {
-                style: {
-                  opacity: 0,
-                  position: "absolute",
-                  top: 0,
-                  left: 0,
-                  right: 0,
-                  bottom: 0,
-                  pointerEvents: "none"
-                },
-                onLayout: handleMaxContentViewLayout
-              }), /* @__PURE__ */_jsx(AnimatedView, {
-                ref,
-                onLayout: handleAnimationViewLayout,
-                // @ts-ignore for CSS driver this is necessary to attach the transition
-                // also motion driver at least though i suspect all drivers?
-                transition: isDragging || disableAnimation ? null : transition,
-                // @ts-ignore
-                disableClassName: !0,
-                style: [{
-                  position: "absolute",
-                  zIndex,
-                  width: "100%",
-                  height: forcedContentHeight,
-                  minHeight: forcedContentHeight,
-                  opacity: shouldHideParentSheet ? 0 : opacity,
-                  ...((shouldHideParentSheet || !open) && {
-                    pointerEvents: "none"
-                  })
-                }, animatedStyle],
-                children: (/* wrap children with plain RN View for panResponder - tamagui views no longer handle responder events on web */
-                gestureHandlerEnabled && panGesture ? /* @__PURE__ */_jsx(GestureDetectorWrapper, {
-                  gesture: panGesture,
-                  style: {
-                    flex: 1
-                  },
-                  children: props.children
-                }) : /* @__PURE__ */_jsx(View, {
-                  ...panResponder?.panHandlers,
-                  style: {
-                    flex: 1,
-                    width: "100%",
-                    height: "100%"
-                  },
-                  children: props.children
-                }))
-              })]
-            })
-          })
-        })
+      setPosition(closestPoint);
+      animateTo(closestPoint);
+    };
+    var finish = function (_e, state2) {
+      release({
+        vy: state2.vy,
+        dragAt: state2.dy
       });
-    if (needsPortalRepropagation()) {
-      var adaptContext = useAdaptContext();
-      contents = /* @__PURE__ */_jsx(ProvideAdaptContext, {
-        ...adaptContext,
-        children: (/* @ts-ignore */
-        contents)
+    };
+    var previouslyScrolling = false;
+    var onMoveShouldSet = function (e, param) {
+      var {
+        dy
+      } = param;
+      function getShouldSet() {
+        if (e.target === providerProps.handleRef.current) return true;
+        if (scrollBridge.scrollNodeTouched) return false;
+        if (scrollBridge.hasScrollableContent === true) {
+          if (scrollBridge.scrollLock) return false;
+          var isScrolled = scrollBridge.y !== 0;
+          var isDraggingUp = dy < 0;
+          var isNearTop = scrollBridge.paneY - 5 <= scrollBridge.paneMinY;
+          if (isScrolled) return false;
+          if (isNearTop) {
+            if (hasScrollView.current && isDraggingUp) return false;
+          }
+        }
+        return Math.abs(dy) > 10;
+      }
+      var granted = getShouldSet();
+      if (granted) scrollBridge.setParentDragging(true);
+      return granted;
+    };
+    var grant = function () {
+      setPanning(true);
+      stopSpring();
+      startY = at.current;
+    };
+    var isExternalDrag = false;
+    scrollBridge.startPanDrag = function () {
+      isExternalDrag = true;
+      grant();
+    };
+    scrollBridge.drag = function (dy) {
+      if (!isExternalDrag) {
+        isExternalDrag = true;
+        grant();
+      }
+      var to = dy + startY;
+      animatedNumber.setValue(resisted(to, minY), {
+        type: "direct"
       });
+    };
+    scrollBridge.release = release;
+    scrollBridge.snapToPosition = function (positionIndex) {
+      isExternalDrag = false;
+      setPanning(false);
+      setPosition(positionIndex);
+      animateTo(positionIndex);
+    };
+    return PanResponder.create({
+      onMoveShouldSetPanResponder: onMoveShouldSet,
+      onPanResponderGrant: grant,
+      onPanResponderMove: function (_e, param) {
+        var {
+          dy
+        } = param;
+        var to = resisted(dy + startY, minY);
+        if (to <= minY) scrollBridge.setParentDragging(false);else scrollBridge.setParentDragging(true);
+        animatedNumber.setValue(to, {
+          type: "direct"
+        });
+      },
+      onPanResponderEnd: finish,
+      onPanResponderTerminate: finish,
+      onPanResponderRelease: finish
+    });
+  }, [disableDrag, isShowingInnerSheet, animateTo, frameSize, activePositions, setPosition]);
+  React.useEffect(function () {
+    if (isWeb) return;
+    if (isDragging || isHidden || !open || disableAnimation) return;
+    if (!frameSize || !screenSize) return;
+    animateTo(position, {
+      type: "timing",
+      duration: 250
+    });
+  }, [isKeyboardVisible, keyboardHeight]);
+  var wasDragging = React.useRef(false);
+  React.useEffect(function () {
+    if (isDragging) {
+      wasDragging.current = true;
+      return;
     }
-    var shouldMountChildren = unmountChildrenWhenHidden ? !!opacity : !0;
-    if (modal) {
-      var modalContents = /* @__PURE__ */_jsx(Portal, {
-        stackZIndex: zIndex,
-        ...portalProps,
-        children: shouldMountChildren && /* @__PURE__ */_jsx(ContainerComponent, {
-          children: /* @__PURE__ */_jsx(Theme, {
-            contain: !0,
-            forceClassName: !0,
-            name: themeName,
-            children: contents
-          })
-        })
-      });
-      return isWeb ? modalContents : /* @__PURE__ */_jsx(SheetInsideSheetContext.Provider, {
-        value: onInnerSheet,
-        children: modalContents
+    if (!wasDragging.current) return;
+    wasDragging.current = false;
+    if (!frameSize || !screenSize || isHidden || !open) return;
+    animateTo(position);
+  }, [isDragging]);
+  React.useEffect(function () {
+    if (!open && isKeyboardVisible) {
+      dismissKeyboard();
+      pauseKeyboardHandler.current = false;
+      flushPendingHide();
+    }
+  }, [open]);
+  var {
+    panGesture,
+    panGestureRef,
+    gestureHandlerEnabled
+  } = useGestureHandlerPan({
+    positions: activePositions,
+    frameSize,
+    setPosition,
+    animateTo,
+    stopSpring,
+    scrollBridge,
+    setIsDragging,
+    getCurrentPosition: function () {
+      return at.current;
+    },
+    resisted,
+    disableDrag,
+    isShowingInnerSheet,
+    setAnimatedPosition: function (val) {
+      at.current = val;
+      animatedNumber.setValue(val, {
+        type: "direct"
       });
+    },
+    pauseKeyboardHandler
+  });
+  var ignoreLayoutForKeyboard = useEvent(function () {
+    return isWeb && moveOnKeyboardChange && getWebKeyboardHeight() >= MIN_KEYBOARD_HEIGHT;
+  });
+  var shouldSeedKbFrame = useEvent(function () {
+    return isWebKbSheet && !hasCleanKbBaseline.current && !seedSettled.current && ignoreLayoutForKeyboard();
+  });
+  var shouldSeedKbScreen = useEvent(function () {
+    return isWebKbSheet && !hasCleanKbBaseline.current && ignoreLayoutForKeyboard();
+  });
+  var handleAnimationViewLayout = useEvent(function (e) {
+    var _e_nativeEvent;
+    if (!open && stableFrameSize.current !== 0) return;
+    var seeding = shouldSeedKbFrame();
+    if (!seeding && ignoreLayoutForKeyboard()) return;
+    var layoutHeight = (_e_nativeEvent = e.nativeEvent) === null || _e_nativeEvent === void 0 ? void 0 : _e_nativeEvent.layout.height;
+    var next = modal || seeding ? Math.min(layoutHeight, getStableViewportHeight()) : layoutHeight;
+    if (!next) return;
+    var rounded = Math.round(next);
+    if (seeding) {
+      if (rounded > stableKbGeom.current.frame) stableKbGeom.current.frame = rounded;else if (stableKbGeom.current.frame > 0) seedSettled.current = true;
     }
-    return contents;
+    setFrameSize(rounded);
   });
+  var handleMaxContentViewLayout = React.useCallback(function (e) {
+    var _e_nativeEvent;
+    if (shouldSeedKbScreen()) {
+      setMaxContentSize(Math.round(getStableViewportHeight()));
+      return;
+    }
+    if (ignoreLayoutForKeyboard()) return;
+    var next = Math.min((_e_nativeEvent = e.nativeEvent) === null || _e_nativeEvent === void 0 ? void 0 : _e_nativeEvent.layout.height, getStableViewportHeight());
+    if (!next) return;
+    setMaxContentSize(Math.round(next));
+  }, [ignoreLayoutForKeyboard, shouldSeedKbScreen]);
+  var animatedStyle = useAnimatedNumberStyle(animatedNumber, React.useCallback(function (val) {
+    "worklet";
+
+    return {
+      transform: [{
+        translateY: frameSize === 0 ? hiddenSize : val
+      }]
+    };
+  }, [frameSize]));
+  var [opacity, setOpacity] = React.useState(open ? 1 : 0);
+  if (open && opacity === 0) {
+    setOpacity(1);
+    if (opacityFallbackTimer.current) {
+      clearTimeout(opacityFallbackTimer.current);
+      opacityFallbackTimer.current = null;
+    }
+  }
+  var forcedContentHeight = hasFit ? void 0 : snapPointsMode === "percent" ? `${maxSnapPoint}${isWeb ? modal ? "dvh" : "%" : "%"}` : maxSnapPoint;
+  var setHasScrollView = React.useCallback(function (val) {
+    hasScrollView.current = val;
+  }, []);
+  var contents = /* @__PURE__ */_jsx(LayoutMeasurementController, {
+    disable: !open,
+    children: /* @__PURE__ */_jsx(ParentSheetContext.Provider, {
+      value: nextParentContext,
+      children: /* @__PURE__ */_jsx(SheetProvider, {
+        ...providerProps,
+        keyboardOccludedHeight,
+        isKeyboardVisible,
+        keyboardStableFrameHeight,
+        isKeyboardSeeding: seedingKbBaseline,
+        setHasScrollView,
+        children: /* @__PURE__ */_jsxs(GestureSheetProvider, {
+          isDragging,
+          blockPan,
+          setBlockPan,
+          panGesture,
+          panGestureRef,
+          children: [/* @__PURE__ */_jsx(AnimatePresence, {
+            custom: {
+              open
+            },
+            children: shouldHideParentSheet || !open ? null : overlayComponent
+          }), snapPointsMode !== "percent" && /* @__PURE__ */_jsx(View, {
+            style: {
+              opacity: 0,
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              bottom: 0,
+              pointerEvents: "none"
+            },
+            onLayout: handleMaxContentViewLayout
+          }), /* @__PURE__ */_jsx(AnimatedView, {
+            ref,
+            onLayout: handleAnimationViewLayout,
+            transition: isDragging || disableAnimation ? null : transition,
+            disableClassName: true,
+            style: [{
+              position: "absolute",
+              zIndex,
+              width: "100%",
+              height: forcedContentHeight,
+              minHeight: forcedContentHeight,
+              opacity: !shouldHideParentSheet ? opacity : 0,
+              ...((shouldHideParentSheet || !open) && {
+                pointerEvents: "none"
+              })
+            }, animatedStyle],
+            children: gestureHandlerEnabled && panGesture ? /* @__PURE__ */_jsx(GestureDetectorWrapper, {
+              gesture: panGesture,
+              style: {
+                flex: 1
+              },
+              children: props.children
+            }) : /* @__PURE__ */_jsx(View, {
+              ...(panResponder === null || panResponder === void 0 ? void 0 : panResponder.panHandlers),
+              style: {
+                flex: 1,
+                width: "100%",
+                height: "100%"
+              },
+              children: props.children
+            })
+          })]
+        })
+      })
+    })
+  });
+  if (needsPortalRepropagation()) contents = /* @__PURE__ */_jsx(ProvideAdaptContext, {
+    ...useAdaptContext(),
+    children: contents
+  });
+  var shouldMountChildren = unmountChildrenWhenHidden ? !!opacity : true;
+  if (modal) {
+    var RNGHRoot = getGestureHandlerState().RootView;
+    var mountedContents = shouldMountChildren ? /* @__PURE__ */_jsx(ContainerComponent, {
+      children: contents
+    }) : null;
+    var modalContents = /* @__PURE__ */_jsx(Portal, {
+      stackZIndex: zIndex,
+      ...portalProps,
+      children: mountedContents && RNGHRoot ? /* @__PURE__ */_jsx(RNGHRoot, {
+        style: open ? rnghRootStyleOpen : rnghRootStyleClosed,
+        children: mountedContents
+      }) : mountedContents
+    });
+    if (isWeb) return modalContents;
+    return /* @__PURE__ */_jsx(SheetInsideSheetContext.Provider, {
+      value: onInnerSheet,
+      children: modalContents
+    });
+  }
+  return contents;
+});
 function getYPositions(mode, point, screenSize, frameSize) {
   if (!screenSize || !frameSize) return 0;
   if (mode === "mixed") {
-    if (typeof point == "number") return screenSize - Math.min(screenSize, Math.max(0, point));
+    if (typeof point === "number") return screenSize - Math.min(screenSize, Math.max(0, point));
     if (point === "fit") return screenSize - Math.min(screenSize, frameSize);
     if (point.endsWith("%")) {
       var pct = Math.min(100, Math.max(0, Number(point.slice(0, -1)))) / 100;
-      return Number.isNaN(pct) ? (console.warn("Invalid snapPoint percentage string"), 0) : Math.round(screenSize - pct * screenSize);
+      if (Number.isNaN(pct)) {
+        console.warn("Invalid snapPoint percentage string");
+        return 0;
+      }
+      return Math.round(screenSize - pct * screenSize);
     }
-    return console.warn("Invalid snapPoint unknown value"), 0;
+    console.warn("Invalid snapPoint unknown value");
+    return 0;
   }
-  if (mode === "fit") return point === 0 ? screenSize : screenSize - Math.min(screenSize, frameSize);
-  if (mode === "constant" && typeof point == "number") return screenSize - Math.min(screenSize, Math.max(0, point));
+  if (mode === "fit") {
+    if (point === 0) return screenSize;
+    return screenSize - Math.min(screenSize, frameSize);
+  }
+  if (mode === "constant" && typeof point === "number") return screenSize - Math.min(screenSize, Math.max(0, point));
   var pct1 = Math.min(100, Math.max(0, Number(point))) / 100;
-  return Number.isNaN(pct1) ? (console.warn("Invalid snapPoint percentage"), 0) : Math.round(screenSize - pct1 * screenSize);
+  if (Number.isNaN(pct1)) {
+    console.warn("Invalid snapPoint percentage");
+    return 0;
+  }
+  return Math.round(screenSize - pct1 * screenSize);
 }
 export { SheetImplementationCustom };
 //# sourceMappingURL=SheetImplementationCustom.native.js.map