@tamagui/sheet 2.1.0 → 2.2.0

package/src/SheetImplementationCustom.tsx

@@ -10,7 +10,6 @@ import {
   useEvent,
   useThemeName,
 } from '@tamagui/core'
-import { getSafeArea } from '@tamagui/native'
 import { needsPortalRepropagation, Portal } from '@tamagui/portal'
 import React, { useState } from 'react'
 import type {
@@ -25,16 +24,23 @@ import { GestureDetectorWrapper } from './GestureDetectorWrapper'
 import { getGestureHandlerState } from './gestureState'
 import { GestureSheetProvider } from './GestureSheetContext'
 import { resisted } from './helpers'
-import { getKeyboardOccludedHeight } from './keyboardAvoidance'
 import {
+  getKeyboardAdjustedSheetY,
+  getKeyboardOccludedHeight,
+  getSheetReleasePosition,
+} from './keyboardAvoidance'
+import {
+  getWebKeyboardResizeHeight,
+  getMaxViewportHeight,
   getStableLayoutViewportHeight,
-  getWebKeyboardHeight,
+  getWebVisualViewportOffsetTop,
   MIN_KEYBOARD_HEIGHT,
 } from './webViewport'
 import { SheetProvider } from './SheetContext'
 import type { SheetProps, SnapPointsMode } from './types'
 import { useGestureHandlerPan } from './useGestureHandlerPan'
 import { useKeyboardControllerSheet } from './useKeyboardControllerSheet'
+import { SafeAreaInsetsContext, useSafeAreaInsets } from './useSafeAreaInsets'
 import { useSheetOpenState } from './useSheetOpenState'
 import { useSheetProviderProps } from './useSheetProviderProps'
 
@@ -48,15 +54,6 @@ const hiddenSize = 10_000.1
 const rnghRootStyleOpen = { width: '100%', height: '100%' } as const
 const rnghRootStyleClosed = { width: '100%', height: 0 } as const
 
-// safe area top inset, cached per-session (device-constant value)
-let _cachedSafeAreaTop: number | undefined
-function getSafeAreaTopInset(): number {
-  if (_cachedSafeAreaTop !== undefined) return _cachedSafeAreaTop
-  // use @tamagui/native abstraction - returns 0 when not enabled
-  _cachedSafeAreaTop = getSafeArea().getInsets().top
-  return _cachedSafeAreaTop
-}
-
 let sheetHiddenStyleSheet: HTMLStyleElement | null = null
 
 // on web we are always relative to window, on to screen
@@ -79,6 +76,16 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
   function SheetImplementationCustom(props, forwardedRef) {
     const parentSheet = React.useContext(ParentSheetContext)
 
+    // live safe-area insets (notch / status bar). read here in the component
+    // body — which renders INSIDE the app's SafeAreaProvider — so it is correct
+    // even though a modal sheet's CONTENT is teleported out through the portal.
+    // the keyboard-avoidance clamp below uses the top inset so a keyboard-shifted
+    // sheet tops out at the notch instead of sliding under it. web has no native
+    // safe-area context (CSS env() handles it) and uses the visual-viewport
+    // offset instead.
+    const safeAreaInsets = useSafeAreaInsets()
+    const safeAreaTopInset = safeAreaInsets?.top ?? 0
+
     const {
       transition,
       transitionConfig: transitionConfigProp,
@@ -100,6 +107,7 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
     const {
       frameSize,
       setFrameSize,
+      dismissOnSnapToBottom,
       snapPoints,
       snapPointsMode,
       hasFit,
@@ -183,75 +191,34 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       }
     }, [open, frameSize])
 
-    // WEB keyboard anchor freeze. on real iOS Safari opening the keyboard shrinks
+    // WEB keyboard frame freeze. on real iOS Safari opening the keyboard shrinks
     // the visual viewport AND innerHeight AND the measured layout, which would
     // re-derive screenSize/frameSize smaller, recompute the fit positions, and
     // fly the frame up then back down ("goes back down after the keyboard opens").
     // so we snapshot the pre-keyboard geometry — captured every render while the
     // keyboard is CLOSED, which dodges the open-transition race where a shrunk
-    // onLayout lands before isKeyboardVisible flips — and use it for the anchor
-    // math while the keyboard is open. the sheet then stays put; only the scroll
-    // content shifts to clear the keyboard (keyboardOccludedHeight padding below
-    // + SheetScrollView's frozen height).
-    // this sheet is the kind the web keyboard anchor freeze is designed for — a
+    // onLayout lands before isKeyboardVisible flips — and use it for frame-size
+    // math while the keyboard is open. the active snap position still shifts up
+    // by the keyboard height, capped at the safe-area top; the scroll view gets
+    // keyboardOccludedHeight padding for any tail left behind the keyboard.
+    // this sheet is the kind the web keyboard frame freeze is designed for — a
     // fit-mode web sheet opted into keyboard handling. percent/constant sheets
-    // keep the live geometry (their height isn't pinned, so a frozen anchor
-    // would mismatch).
+    // keep the live geometry (their height isn't pinned, so a frozen frame
+    // height would mismatch).
     const isWebKbSheet = isWeb && hasFit && moveOnKeyboardChange
 
-    // whether we ever captured geometry while the keyboard was CLOSED. that's the
-    // authoritative baseline; until we have it, the autofocus-on-open seed below
-    // reconstructs one from keyboard-up measurements.
-    const hasCleanKbBaseline = React.useRef(false)
-    // the autofocus-on-open seed has settled on a stable frame height (the
-    // unclipped content stopped growing). until then we keep the seed phase open.
-    const seedSettled = React.useRef(false)
-    const stableKbGeom = React.useRef({ frame: 0, screen: 0 })
-    if ((!isWeb || !isKeyboardVisible) && frameSize > 0 && screenSize > 0) {
-      // keyboard-free render — the authoritative baseline. mutate in place: the
-      // ref is only ever read field-by-field, never identity-compared, so this
-      // avoids a per-render allocation.
-      stableKbGeom.current.frame = frameSize
-      stableKbGeom.current.screen = screenSize
-      hasCleanKbBaseline.current = true
-    } else if (
-      isWebKbSheet &&
-      isKeyboardVisible &&
-      !hasCleanKbBaseline.current &&
-      screenSize > 0
-    ) {
-      // AUTOFOCUS-ON-OPEN seed. when the input autofocuses as the sheet animates
-      // in, the keyboard rises BEFORE any keyboard-free layout lands, so the
-      // branch above never runs (frameSize/screenSize were 0 the whole time the
-      // keyboard was up) and freezeForKb stays false, collapsing the sheet to the
-      // shrunk consumer maxHeight. instead, reconstruct the baseline from the
-      // keyboard-up render: screen = the stable layout viewport
-      // (keyboard-independent). the frame is grown by the seeding layout path
-      // below: while seeding, the tail padding is suppressed and the scroll view
-      // is unclipped (via keyboardStableFrameHeight = stable screen), so the frame
-      // converges on its pure pre-keyboard content height across a couple layout
-      // passes. a real keyboard-free render later replaces it with the exact value
-      // (branch above).
-      stableKbGeom.current.screen = Math.max(stableKbGeom.current.screen, screenSize)
-    }
-    // are we still reconstructing the baseline from a keyboard-up render? true
-    // until either a clean baseline lands or the seeded frame settles.
-    const seedingKbBaseline =
-      isWebKbSheet &&
-      isKeyboardVisible &&
-      !hasCleanKbBaseline.current &&
-      !seedSettled.current
-    const freezeForKb =
-      isWebKbSheet && isKeyboardVisible && stableKbGeom.current.frame > 0
-    const effScreenSize = freezeForKb ? stableKbGeom.current.screen : screenSize
-
-    // use stableFrameSize when closing to prevent position jumps during exit animation
-    // but when opening, always use the current frameSize so positions update correctly
-    const effectiveFrameSize = freezeForKb
-      ? stableKbGeom.current.frame
-      : open
-        ? frameSize
-        : stableFrameSize.current || frameSize
+    // the space the snap positions are built against. WEB: the stable layout
+    // viewport (document.documentElement.clientHeight), which the soft keyboard
+    // never shrinks (unlike the measured screenSize / visualViewport). NATIVE:
+    // the measured screenSize. activePositions shift up by keyboardHeight below
+    // so a small fit sheet keeps its natural height and moves with the keyboard;
+    // a tall fit sheet moves until capped at the safe-area top, leaving its tail
+    // behind the keyboard for the ScrollView padding to expose.
+    const effScreenSize = isWebKbSheet ? getStableViewportHeight() : screenSize
+
+    // use stableFrameSize when closing to prevent position jumps during the exit
+    // animation; while open use the live frameSize.
+    const effectiveFrameSize = open ? frameSize : stableFrameSize.current || frameSize
 
     const positions = React.useMemo(
       () =>
@@ -284,17 +251,9 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
 
     // keyboard-adjusted snap positions.
     //
-    // WEB: the sheet stays ANCHORED at the bottom and keeps its full pre-keyboard
-    // height — it does NOT shift up or resize. Shifting/resizing with the
-    // translateY model detaches the bottom from the screen edge or teleports it.
-    // Instead the frame's anchor geometry is frozen (effScreenSize/effectiveFrameSize
-    // above) and its height is pinned (keyboardStableFrameHeight -> SheetScrollView);
-    // the scroll content is padded by keyboardOccludedHeight and the browser
-    // scroll-into-view lifts the focused input above the keyboard. So
-    // activePositions === positions on web.
-    //
-    // NATIVE: shift snap points up by keyboard height (the native keyboard is
-    // opaque and pushes content), capped at the safe-area top inset.
+    // WEB + NATIVE: shift snap points up by keyboard height, capped at the
+    // safe-area top inset. web fit sheets keep their frozen pre-keyboard height
+    // and add bottom spacer padding when the safe-area cap leaves a hidden tail.
     //
     // IMPORTANT: frozen during drag to prevent gesture handler recreation —
     // when a TextInput blurs mid-drag the keyboard state would otherwise revert
@@ -304,55 +263,51 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       if (isDragging || isDraggingRef.current) return activePositionsRef.current
 
       let result: number[]
-      if (isWeb || !isKeyboardVisible || keyboardHeight <= 0) {
+
+      if (!isKeyboardVisible || keyboardHeight <= 0) {
         result = positions
       } else {
-        const safeAreaTop = getSafeAreaTopInset()
-        result = positions.map((p) => {
-          // don't adjust the off-screen/close position (from dismissOnSnapToBottom's 0% snap)
-          // — it must stay at screenSize so the user can drag between real snap points
-          // without accidentally closing the sheet
-          if (screenSize && p >= screenSize) return p
-          return Math.max(safeAreaTop, p - keyboardHeight)
-        })
+        result = positions.map((p) =>
+          getKeyboardAdjustedSheetY({
+            sheetY: p,
+            screenSize: effScreenSize,
+            isKeyboardVisible,
+            keyboardHeight,
+            shouldTranslate: true,
+            safeAreaTop: isWeb ? getWebVisualViewportOffsetTop() : safeAreaTopInset,
+          })
+        )
       }
       activePositionsRef.current = result
       return result
-    }, [positions, isKeyboardVisible, keyboardHeight, screenSize, isDragging])
-
-    const keyboardOccludedHeight = seedingKbBaseline
-      ? // while seeding, suppress the keyboard tail padding so the frame measures
-        // its PURE pre-keyboard content height (the padding would otherwise inflate
-        // it toward the full screen). re-enabled once the baseline is captured.
-        0
-      : getKeyboardOccludedHeight({
-          frameSize: effectiveFrameSize,
-          isKeyboardVisible,
-          keyboardHeight,
-          screenSize: effScreenSize,
-          sheetY: position >= 0 ? activePositions[position] : undefined,
-        })
+    }, [
+      positions,
+      isKeyboardVisible,
+      keyboardHeight,
+      effScreenSize,
+      isDragging,
+      safeAreaTopInset,
+    ])
 
-    // the authoritative pre-keyboard frame height to pin the scroll view to while
-    // the keyboard is open (web). stableKbGeom.frame is captured every render the
-    // keyboard is closed, so it survives the open transition; SheetScrollView
-    // gates application on its own live keyboard check.
-    //
-    // AUTOFOCUS-ON-OPEN seed: while still reconstructing the baseline (seeding,
-    // not yet settled) we use the STABLE SCREEN SIZE — a safe upper bound (a fit
-    // frame never exceeds the screen) that is > 0, so SheetScrollView's height
-    // override engages and UNCLIPS the scroll view from the shrunk consumer
-    // maxHeight. with the tail padding suppressed (above) the content then lays
-    // out to its pure intrinsic height, which the seeding layout grows the frame
-    // baseline toward across a couple passes. once settled (or once a real
-    // keyboard-free baseline lands) we pin that exact frame height.
-    const keyboardStableFrameHeight = !isWebKbSheet
-      ? 0
-      : seedingKbBaseline
-        ? stableKbGeom.current.screen || screenSize
-        : stableKbGeom.current.frame > 0
-          ? stableKbGeom.current.frame
-          : 0
+    // bottom spacer for the part of the sheet hidden by the keyboard after the
+    // keyboard translation and safe-area clamping. if a small sheet fits above
+    // the keyboard this is 0; if a tall sheet is capped at the safe-area top, the
+    // spacer makes the remaining hidden tail scrollable.
+    const keyboardOccludedHeight = getKeyboardOccludedHeight({
+      frameSize: effectiveFrameSize,
+      isKeyboardVisible,
+      keyboardHeight,
+      screenSize: effScreenSize,
+      sheetY: position >= 0 ? activePositions[position] : undefined,
+    })
+
+    // pin the scroll view to the held (pre-keyboard) frame height while the
+    // keyboard is up on web. on older iOS the consumer's window-derived maxHeight
+    // shrinks with the keyboard, which would clip the scroll view (and the frame)
+    // smaller; this override keeps it at the full height so the frame translates
+    // with the keyboard but never resizes. 0 = no override (use the consumer maxHeight).
+    const keyboardStableFrameHeight =
+      isWebKbSheet && isKeyboardVisible && frameSize > 0 ? frameSize : 0
 
     const { useAnimatedNumber, useAnimatedNumberStyle, useAnimatedNumberReaction } =
       animationDriver
@@ -442,8 +397,16 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       // use effScreenSize (the frozen anchor space the positions were built in) for
       // the off-screen/close target too, so a close while the keyboard is still up
       // animates fully out instead of to a mismatched live screenSize.
-      let toValue =
-        isHidden || position === -1 ? effScreenSize : activePositions[position]
+      //
+      // web: clear the maximum the viewport can ever reveal, not just the current
+      // layout viewport. iOS Safari retracts its chrome on scroll and exposes area
+      // below the current viewport, so a sheet parked at effScreenSize would peek
+      // back in as the page scrolls. getMaxViewportHeight floors the target past
+      // anything Safari can expose.
+      const closeTarget = isWeb
+        ? Math.max(effScreenSize, getMaxViewportHeight())
+        : effScreenSize
+      let toValue = isHidden || position === -1 ? closeTarget : activePositions[position]
 
       if (at.current === toValue) return
 
@@ -571,6 +534,10 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
           scrollBridge.setScrollEnabled?.(false)
         }
       }
+      // NOTE: effScreenSize/effectiveFrameSize are intentionally NOT deps. With the
+      // spacer approach the frame's position target is frozen across keyboard
+      // open/close (same stable baseline), so it must NOT re-animate — keyboard
+      // avoidance is the bottom spacer + scroll, not a frame move.
     }, [hasntMeasured, disableAnimation, isHidden, frameSize, screenSize, open, position])
 
     const disableDrag = props.disableDrag ?? controller?.disableDrag
@@ -626,17 +593,16 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
         // vy goes up to about 4 at most (+ is down, - is up)
         const end = currentPos + frameSize * vy * 0.2
 
-        let closestPoint = 0
-        let dist = Number.POSITIVE_INFINITY
-
-        for (let i = 0; i < activePositions.length; i++) {
-          const position = activePositions[i]
-          const curDist = end > position ? end - position : position - end
-          if (curDist < dist) {
-            dist = curDist
-            closestPoint = i
-          }
-        }
+        const closestPoint = getSheetReleasePosition({
+          positions: activePositions,
+          projectedEnd: end,
+          currentPosition: currentPos,
+          frameSize,
+          dismissOnSnapToBottom,
+          snapPointsMode,
+          isKeyboardVisible,
+          isWeb,
+        })
 
         // have to call both because state may not change but need to snap back
         setPosition(closestPoint)
@@ -750,6 +716,10 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
 
       return PanResponder.create({
         onMoveShouldSetPanResponder: onMoveShouldSet,
+        // once we own the drag, don't yield it to another responder
+        // (re-renders during the drag were cooperatively terminating it under
+        // load, killing the gesture mid-drag)
+        onPanResponderTerminationRequest: () => false,
         onPanResponderGrant: grant,
         onPanResponderMove: (_e, { dy }) => {
           const toFull = dy + startY
@@ -776,18 +746,18 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       frameSize,
       activePositions,
       setPosition,
+      dismissOnSnapToBottom,
+      snapPointsMode,
     ])
 
-    // animate to keyboard-adjusted position when keyboard state changes.
-    // WEB skips this: the sheet stays anchored at its frozen position/height
-    // (activePositions don't change with the keyboard, and the anchor geometry is
-    // frozen), so there's nothing to re-animate. Running a timing animation here
-    // would only introduce movement where the sheet should hold perfectly still.
+    // animate to the current keyboard-adjusted position when the keyboard state
+    // changes. activePositions shift the frame up by keyboardHeight, capped at
+    // the safe-area top; tall web fit sheets keep a frozen height and gain scroll
+    // padding for whatever tail remains behind the keyboard.
     React.useEffect(() => {
-      if (isWeb) return
       if (isDragging || isHidden || !open || disableAnimation) return
       if (!frameSize || !screenSize) return
-      // use timing animation to match iOS keyboard animation (~250ms)
+      // timing animation matches the iOS keyboard animation (~250ms)
       animateTo(position, { type: 'timing', duration: 250 })
     }, [isKeyboardVisible, keyboardHeight])
 
@@ -838,6 +808,9 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
         at.current = val
         animatedNumber.setValue(val, { type: 'direct' })
       },
+      dismissOnSnapToBottom,
+      snapPointsMode,
+      isKeyboardVisible,
       pauseKeyboardHandler,
     })
 
@@ -847,35 +820,12 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
     // recompute the fit anchor and fly the frame. a LIVE DOM check, NOT the
     // isKeyboardVisible React state, is required: the state lags the resize, so
     // the first shrunk onLayout lands before the flag flips. holding the measured
-    // sizes keeps the sheet anchored; the scroll content shifts to clear the kb.
+    // size keeps the fit geometry stable while the frame translates with the kb.
     const ignoreLayoutForKeyboard = useEvent(
-      () => isWeb && moveOnKeyboardChange && getWebKeyboardHeight() >= MIN_KEYBOARD_HEIGHT
-    )
-
-    // AUTOFOCUS-ON-OPEN seed gates. normally a layout measured while the keyboard
-    // is up is dropped (it's the shrunk/collapsed sheet). but if the keyboard rose
-    // before ANY keyboard-free baseline was captured (the autofocus race),
-    // dropping every measurement leaves frameSize/screenSize stuck at 0 forever
-    // and the freeze never engages.
-    //
-    // frame: while seeding (not settled) the scroll view is unclipped and the
-    // tail padding suppressed, so the frame measures toward its pure pre-keyboard
-    // content height. the first keyboard-up pass is still clipped at the consumer
-    // maxHeight; the override only unclips it the following pass, so the frame
-    // grows. we take the MAX and mark the seed SETTLED once it stops growing
-    // (handled in handleAnimationViewLayout) — then later keyboard-up layouts are
-    // dropped again so the re-enabled tail padding can't inflate the frame.
-    const shouldSeedKbFrame = useEvent(
       () =>
-        isWebKbSheet &&
-        !hasCleanKbBaseline.current &&
-        !seedSettled.current &&
-        ignoreLayoutForKeyboard()
-    )
-    // screen (= maxContentSize): keep reconstructing from the stable viewport for
-    // the whole keyboard-up-without-clean-baseline window.
-    const shouldSeedKbScreen = useEvent(
-      () => isWebKbSheet && !hasCleanKbBaseline.current && ignoreLayoutForKeyboard()
+        isWeb &&
+        moveOnKeyboardChange &&
+        getWebKeyboardResizeHeight() >= MIN_KEYBOARD_HEIGHT
     )
 
     const handleAnimationViewLayout = useEvent((e: LayoutChangeEvent) => {
@@ -884,58 +834,39 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
         return
       }
 
-      const seeding = shouldSeedKbFrame()
-      if (!seeding && ignoreLayoutForKeyboard()) return
+      const layoutHeight = e.nativeEvent?.layout.height
+      // drop a layout measured while the keyboard is up: on older iOS the web
+      // viewport shrinks and the frame would resize. keep the pre-keyboard frame
+      // height so the web frame translates without resizing.
+      // exception: if we have no frame height yet (sheet opened with the keyboard
+      // already up), accept it so the sheet can appear at all.
+      if (ignoreLayoutForKeyboard() && frameSize > 0) return
 
       // avoid bugs where it grows forever for whatever reason
       // For inline mode (non-modal), don't cap at window height - use actual layout
-      const layoutHeight = e.nativeEvent?.layout.height
-      // while seeding, the keyboardStableFrameHeight fallback has unclipped the
-      // scroll view (capped at the stable screen) and the tail padding is
-      // suppressed, so this measures the pure pre-keyboard content height — cap it
-      // at the stable viewport like modal does.
-      const next =
-        modal || seeding
-          ? Math.min(layoutHeight, getStableViewportHeight())
-          : layoutHeight
+      const next = modal
+        ? Math.min(layoutHeight, getStableViewportHeight())
+        : layoutHeight
       if (!next) return
       // round: web onLayout reports sub-pixel heights (e.g. 499.99996) that jitter
       // frame to frame as the view transforms; the raw float would re-fire every
       // effect that depends on frameSize on each drag move.
-      const rounded = Math.round(next)
-      // seeding the frame: grow the baseline toward the unclipped content height.
-      // the first keyboard-up pass is clipped; the scroll-view override unclips it
-      // the next pass so it grows. once a pass doesn't exceed the running max the
-      // content has settled — mark the seed done so the next render exits the seed
-      // phase (freezeForKb pins this height, tail padding re-enables for scroll).
-      if (seeding) {
-        if (rounded > stableKbGeom.current.frame) {
-          stableKbGeom.current.frame = rounded
-        } else if (stableKbGeom.current.frame > 0) {
-          seedSettled.current = true
-        }
-      }
-      setFrameSize(rounded)
+      setFrameSize(Math.round(next))
     })
 
     const handleMaxContentViewLayout = React.useCallback(
       (e: LayoutChangeEvent) => {
-        // same keyboard guard so screenSize (= maxContentSize) stays the full
-        // pre-keyboard viewport — except while seeding the baseline (see above),
-        // where we use the stable layout viewport directly so screenSize lands at
-        // the full pre-keyboard height instead of the shrunk visual viewport.
-        if (shouldSeedKbScreen()) {
-          setMaxContentSize(Math.round(getStableViewportHeight()))
-          return
-        }
-        if (ignoreLayoutForKeyboard()) return
+        // keep maxContentSize at the full pre-keyboard viewport: drop layouts
+        // measured while the keyboard is up (the shrunk viewport), unless we have
+        // none yet (keyboard-already-up open).
+        if (ignoreLayoutForKeyboard() && screenSize > 0) return
         // avoid bugs where it grows forever for whatever reason
         const next = Math.min(e.nativeEvent?.layout.height, getStableViewportHeight())
         if (!next) return
         // round to avoid sub-pixel churn re-firing size-dependent effects
         setMaxContentSize(Math.round(next))
       },
-      [ignoreLayoutForKeyboard, shouldSeedKbScreen]
+      [ignoreLayoutForKeyboard, screenSize]
     )
 
     const getAnimatedNumberStyle = React.useCallback(
@@ -988,7 +919,6 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
             keyboardOccludedHeight={keyboardOccludedHeight}
             isKeyboardVisible={isKeyboardVisible}
             keyboardStableFrameHeight={keyboardStableFrameHeight}
-            isKeyboardSeeding={seedingKbBaseline}
             setHasScrollView={setHasScrollView}
           >
             <GestureSheetProvider
@@ -1065,8 +995,13 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       const adaptContext = useAdaptContext()
       contents = (
         <ProvideAdaptContext {...adaptContext}>
-          {/* @ts-ignore */}
-          {contents}
+          {/* re-propagate safe-area insets across the teleport: the sheet content
+              renders at the portal host, OUTSIDE the app's SafeAreaProvider, so
+              without this useSafeAreaInsets() inside the sheet reads 0. */}
+          <SafeAreaInsetsContext.Provider value={safeAreaInsets}>
+            {/* @ts-ignore */}
+            {contents}
+          </SafeAreaInsetsContext.Provider>
         </ProvideAdaptContext>
       )
     }