@tamagui/sheet 2.0.0-rc.9 → 2.0.0

package/src/SheetImplementationCustom.tsx

@@ -5,7 +5,6 @@ import { isWeb, useIsomorphicLayoutEffect } from '@tamagui/constants'
 import {
   LayoutMeasurementController,
   View as TamaguiView,
-  Theme,
   useConfiguration,
   useDidFinishSSR,
   useEvent,
@@ -23,8 +22,10 @@ import type {
 import { Dimensions, PanResponder, View } from 'react-native'
 import { ParentSheetContext, SheetInsideSheetContext } from './contexts'
 import { GestureDetectorWrapper } from './GestureDetectorWrapper'
+import { getGestureHandlerState } from './gestureState'
 import { GestureSheetProvider } from './GestureSheetContext'
 import { resisted } from './helpers'
+import { getKeyboardOccludedHeight } from './keyboardAvoidance'
 import { SheetProvider } from './SheetContext'
 import type { SheetProps, SnapPointsMode } from './types'
 import { useGestureHandlerPan } from './useGestureHandlerPan'
@@ -34,6 +35,14 @@ import { useSheetProviderProps } from './useSheetProviderProps'
 
 const hiddenSize = 10_000.1
 
+// the re-established rngh root for a modal sheet (see modal branch below).
+// GestureHandlerRootView does its own native touch interception and ignores
+// pointerEvents, so it would block the whole app while the sheet sits closed
+// but mounted. instead it stays full-width for correct child layout/measurement
+// and collapses to 0 height when closed so it has no hit area.
+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 {
@@ -61,6 +70,7 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       unmountChildrenWhenHidden = false,
       portalProps,
       containerComponent: ContainerComponent = React.Fragment,
+      onAnimationComplete,
     } = props
 
     const state = useSheetOpenState(props)
@@ -83,6 +93,8 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       maxSnapPoint,
     } = providerProps
     const { open, controller, isHidden } = state
+    const openRef = React.useRef(open)
+    openRef.current = open
 
     const sheetRef = React.useRef<View>(undefined as unknown as View)
     const ref = useComposedRefs(forwardedRef, sheetRef, providerProps.contentRef as any)
@@ -220,6 +232,14 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       return result
     }, [positions, isKeyboardVisible, keyboardHeight, screenSize, isDragging])
 
+    const keyboardOccludedHeight = getKeyboardOccludedHeight({
+      frameSize,
+      isKeyboardVisible: !isWeb && isKeyboardVisible,
+      keyboardHeight,
+      screenSize,
+      sheetY: position >= 0 ? activePositions[position] : undefined,
+    })
+
     const { useAnimatedNumber, useAnimatedNumberStyle, useAnimatedNumberReaction } =
       animationDriver
     const AnimatedView = (animationDriver.View ?? TamaguiView) as typeof Animated.View
@@ -254,6 +274,9 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
 
     const hasScrollView = React.useRef(false)
 
+    // safety fallback timer for sheet close opacity
+    const opacityFallbackTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null)
+
     useAnimatedNumberReaction(
       {
         value: animatedNumber,
@@ -273,6 +296,12 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
             // when reaching top, enable scroll; when leaving top, disable scroll
             // this preemptively sets scroll state before any gestures start
             if (nowAtTop) {
+              // if scroll drifted during drag (e.g. fast swipe from position 1),
+              // reset it to 0 before enabling free scroll
+              if (scrollBridge.y > 0) {
+                scrollBridge.forceScrollTo?.(0)
+                scrollBridge.y = 0
+              }
               scrollBridge.scrollLockY = undefined
               scrollBridge.setScrollEnabled?.(true)
             } else {
@@ -303,10 +332,50 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       at.current = toValue
       stopSpring()
 
+      const isOpenAnimation = position !== -1 && !isHidden
+
+      // clear any pending fallback timer
+      if (opacityFallbackTimer.current) {
+        clearTimeout(opacityFallbackTimer.current)
+        opacityFallbackTimer.current = null
+      }
+
+      const animationCompleteCallback = () => {
+        if (opacityFallbackTimer.current) {
+          clearTimeout(opacityFallbackTimer.current)
+          opacityFallbackTimer.current = null
+        }
+        // use openRef (live) not open (stale closure) — if the sheet
+        // was reopened before this callback fires (e.g. cancelled close
+        // animation), we must not hide it
+        if (!isOpenAnimation && !openRef.current) {
+          setOpacity(0)
+        }
+        onAnimationComplete?.({ open: isOpenAnimation })
+        // also notify the SheetController so a parent (e.g. Dialog adapt)
+        // can hold the sheet's children mounted until the slide-out is done
+        controller?.onAnimationComplete?.({ open: isOpenAnimation })
+      }
+
+      // safety fallback: if animation callback never fires, still hide the sheet
+      if (!isOpenAnimation) {
+        opacityFallbackTimer.current = setTimeout(() => {
+          opacityFallbackTimer.current = null
+          // check live open state via ref — sheet may have reopened (e.g. adapt handoff)
+          if (!openRef.current) {
+            setOpacity(0)
+          }
+        }, 1000)
+      }
+
       // skip animation when adapting from dialog to sheet
       if (skipAdaptAnimation.current) {
         skipAdaptAnimation.current = false
-        animatedNumber.setValue(toValue, { type: 'timing', duration: 0 })
+        animatedNumber.setValue(
+          toValue,
+          { type: 'timing', duration: 0 },
+          animationCompleteCallback
+        )
         return
       }
 
@@ -315,7 +384,8 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
         animationOverride || {
           type: 'spring',
           ...transitionConfig,
-        }
+        },
+        animationCompleteCallback
       )
     })
 
@@ -601,24 +671,21 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       pauseKeyboardHandler,
     })
 
-    const handleAnimationViewLayout = React.useCallback(
-      (e: LayoutChangeEvent) => {
-        // FIX: Don't update frameSize during exit animation to prevent position jumps
-        if (!open && stableFrameSize.current !== 0) {
-          return
-        }
+    const handleAnimationViewLayout = useEvent((e: LayoutChangeEvent) => {
+      // don't update frameSize during exit animation to prevent position jumps
+      if (!open && stableFrameSize.current !== 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
-        const next = modal
-          ? Math.min(layoutHeight, Dimensions.get(relativeDimensionTo).height)
-          : layoutHeight
-        if (!next) return
-        setFrameSize(next)
-      },
-      [open, modal]
-    )
+      // 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
+      const next = modal
+        ? Math.min(layoutHeight, Dimensions.get(relativeDimensionTo).height)
+        : layoutHeight
+      if (!next) return
+      setFrameSize(next)
+    })
 
     const handleMaxContentViewLayout = React.useCallback((e: LayoutChangeEvent) => {
       // avoid bugs where it grows forever for whatever reason
@@ -630,32 +697,31 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
       setMaxContentSize(next)
     }, [])
 
-    const animatedStyle = useAnimatedNumberStyle(animatedNumber, (val) => {
-      'worklet'
-      const translateY = frameSize === 0 ? hiddenSize : val
+    const getAnimatedNumberStyle = React.useCallback(
+      (val: number) => {
+        'worklet'
+        const translateY = frameSize === 0 ? hiddenSize : val
 
-      return {
-        transform: [{ translateY }],
-      }
-    })
+        return {
+          transform: [{ translateY }],
+        }
+      },
+      [frameSize]
+    )
+
+    const animatedStyle = useAnimatedNumberStyle(animatedNumber, getAnimatedNumberStyle)
 
     // we need to set this *after* fully closed to 0, to avoid it overlapping
     // the page when resizing quickly on web for example
     const [opacity, setOpacity] = React.useState(open ? 1 : 0)
     if (open && opacity === 0) {
       setOpacity(1)
-    }
-    React.useEffect(() => {
-      if (!open) {
-        // need to wait for animation complete, for now lets just do it naively
-        const tm = setTimeout(() => {
-          setOpacity(0)
-        }, 400)
-        return () => {
-          clearTimeout(tm)
-        }
+      // cancel any pending close fallback — sheet is reopening
+      if (opacityFallbackTimer.current) {
+        clearTimeout(opacityFallbackTimer.current)
+        opacityFallbackTimer.current = null
       }
-    }, [open])
+    }
 
     const forcedContentHeight = hasFit
       ? undefined
@@ -676,7 +742,11 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
     let contents = (
       <LayoutMeasurementController disable={!open}>
         <ParentSheetContext.Provider value={nextParentContext}>
-          <SheetProvider {...providerProps} setHasScrollView={setHasScrollView}>
+          <SheetProvider
+            {...providerProps}
+            keyboardOccludedHeight={keyboardOccludedHeight}
+            setHasScrollView={setHasScrollView}
+          >
             <GestureSheetProvider
               isDragging={isDragging}
               blockPan={blockPan}
@@ -761,14 +831,30 @@ export const SheetImplementationCustom = React.forwardRef<View, SheetProps>(
     const shouldMountChildren = unmountChildrenWhenHidden ? !!opacity : true
 
     if (modal) {
+      // a modal sheet is teleported through <Portal> to the root portal host.
+      // that host is mounted by TamaguiProvider, which may sit ABOVE the app's
+      // GestureHandlerRootView - so the teleported content lands outside any
+      // rngh root and every gesture inside the sheet (the drag pan, pressables
+      // on the rngh press path) silently goes dead. re-establish an rngh root
+      // around the teleported content so it works regardless of where the app
+      // mounts GestureHandlerRootView.
+      //
+      // the root stays mounted and full-width whenever the sheet content is
+      // (so child layout/measurement/close-animation are unaffected) and only
+      // collapses to 0 height while closed so it occupies no hit area - see
+      // rnghRootStyleOpen/Closed above for why pointerEvents can't be used.
+      const RNGHRoot = getGestureHandlerState().RootView
+      const mountedContents = shouldMountChildren ? (
+        <ContainerComponent>{contents}</ContainerComponent>
+      ) : null
       const modalContents = (
         <Portal stackZIndex={zIndex} {...portalProps}>
-          {shouldMountChildren && (
-            <ContainerComponent>
-              <Theme contain forceClassName name={themeName}>
-                {contents}
-              </Theme>
-            </ContainerComponent>
+          {mountedContents && RNGHRoot ? (
+            <RNGHRoot style={open ? rnghRootStyleOpen : rnghRootStyleClosed}>
+              {mountedContents}
+            </RNGHRoot>
+          ) : (
+            mountedContents
           )}
         </Portal>
       )

package/src/SheetScrollView.tsx

@@ -29,13 +29,36 @@ export const SheetScrollView = React.forwardRef<
   ) => {
     const context = useSheetContext(SHEET_SCROLL_VIEW_NAME, __scopeSheet)
     const gestureContext = useGestureSheetContext()
-    const { scrollBridge, setHasScrollView } = context
+    const { scrollBridge, setHasScrollView, hasFit, screenSize } = context
+    const keyboardOccludedHeight = Math.max(0, context.keyboardOccludedHeight || 0)
     const [scrollEnabled] = useControllableState({
       prop: scrollEnabledProp,
       defaultProp: true,
     })
     const scrollRef = React.useRef<RNScrollView | null>(null)
 
+    const [hasScrollableContent, setHasScrollableContent] = useState(true)
+    const parentHeight = useRef(0)
+    const contentHeight = useRef(0)
+
+    // with snapPointsMode="fit", Frame is content-sized (flex: 0, flex-basis: auto, height: undefined).
+    // a flex: 1 child can't grow inside a content-sized parent, so the ScrollView (and the Frame
+    // around it) collapse to 0 height. instead, let the ScrollView size to its content and cap it
+    // at the available viewport (screenSize / maxContentSize) so scrolling kicks in for tall content.
+    // when the keyboard forces the sheet against the top safe area, preserve the measured viewport
+    // height while adding scrollable tail padding so content can move above the keyboard.
+    const keyboardFrozenHeight =
+      hasFit && keyboardOccludedHeight > 0 && parentHeight.current
+        ? parentHeight.current
+        : undefined
+    const fitSizingStyle = hasFit
+      ? {
+          flex: undefined as undefined,
+          height: keyboardFrozenHeight,
+          maxHeight: screenSize || undefined,
+        }
+      : { flex: 1 }
+
     const panGestureRef = gestureContext?.panGestureRef
     const { ScrollView: RNGHScrollView } = getGestureHandlerState()
     const useRNGHScrollView = isGestureHandlerEnabled() && RNGHScrollView && panGestureRef
@@ -73,10 +96,6 @@ export const SheetScrollView = React.forwardRef<
       }
     }, [])
 
-    const [hasScrollableContent, setHasScrollableContent] = useState(true)
-    const parentHeight = useRef(0)
-    const contentHeight = useRef(0)
-
     const updateScrollable = () => {
       if (parentHeight.current && contentHeight.current) {
         setHasScrollableContent(contentHeight.current > parentHeight.current)
@@ -108,6 +127,13 @@ export const SheetScrollView = React.forwardRef<
         }}
       >
         {children}
+        {keyboardOccludedHeight > 0 && (
+          <View
+            data-sheet-keyboard-scroll-pad
+            height={keyboardOccludedHeight}
+            width="100%"
+          />
+        )}
       </View>
     )
 
@@ -117,7 +143,7 @@ export const SheetScrollView = React.forwardRef<
       return (
         <RNGHComponent
           ref={composeRefs(scrollRef as any, ref)}
-          style={{ flex: 1 }}
+          style={fitSizingStyle}
           scrollEventThrottle={1}
           scrollEnabled={scrollEnabled}
           simultaneousHandlers={[panGestureRef]}
@@ -174,7 +200,7 @@ export const SheetScrollView = React.forwardRef<
           updateScrollable()
         }}
         ref={composeRefs(scrollRef as any, ref)}
-        flex={1}
+        {...fitSizingStyle}
         scrollEventThrottle={1}
         className="_ovs-contain"
         scrollEnabled={scrollEnabled}

package/src/keyboardAvoidance.ts

@@ -0,0 +1,30 @@
+export function getKeyboardOccludedHeight({
+  frameSize,
+  isKeyboardVisible,
+  keyboardHeight,
+  screenSize,
+  sheetY,
+}: {
+  frameSize: number
+  isKeyboardVisible: boolean
+  keyboardHeight: number
+  screenSize: number
+  sheetY: number | undefined
+}) {
+  if (
+    !isKeyboardVisible ||
+    keyboardHeight <= 0 ||
+    screenSize <= 0 ||
+    frameSize <= 0 ||
+    sheetY === undefined ||
+    sheetY >= screenSize
+  ) {
+    return 0
+  }
+
+  const keyboardTop = screenSize - keyboardHeight
+  const sheetBottom = sheetY + frameSize
+  const occludedHeight = Math.ceil(sheetBottom - keyboardTop)
+
+  return Math.min(frameSize, Math.max(0, occludedHeight))
+}

package/src/nativeSheet.tsx

@@ -59,7 +59,12 @@ export function setupNativeSheet(
 
       return (
         <>
-          <SheetProvider setHasScrollView={emptyFn} {...providerProps} onlyShowFrame>
+          <SheetProvider
+            setHasScrollView={emptyFn}
+            keyboardOccludedHeight={0}
+            {...providerProps}
+            onlyShowFrame
+          >
             <ModalSheetView ref={ref} onModalDidDismiss={() => setOpenInternal(false)}>
               <ModalSheetViewMainContent>
                 <View style={{ flex: 1 }}>{props.children}</View>

package/src/types.tsx

@@ -79,6 +79,11 @@ export type SheetProps = ScopedProps<
      */
     moveOnKeyboardChange?: boolean
     containerComponent?: React.ComponentType<any>
+
+    /**
+     * Called when the sheet open/close animation completes.
+     */
+    onAnimationComplete?: (info: { open: boolean }) => void
   },
   'Sheet'
 >

package/src/useGestureHandlerPan.tsx

@@ -122,7 +122,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
 
     // simultaneousHandlers pattern from react-native-actions-sheet
     // both gestures run simultaneously, we use blockPan to decide who handles
-    // console.warn('[RNGH-Pan] CREATING gesture, minY:', minY, 'frameSize:', frameSize)
     const gesture = Gesture.Pan()
       .withRef(panGestureRef)
       // NO manualActivation - let both gestures run via simultaneousHandlers
@@ -148,7 +147,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
         const pos = getCurrentPosition()
         const atTop = pos <= minY + AT_TOP_THRESHOLD
         const currentScrollY = scrollBridge.y
-        // console.warn('[RNGH-Pan] onBegin', { pos, minY, atTop, currentScrollY })
         gs.startY = pos
         gs.lastPanTranslationY = 0
         gs.accumulatedOffset = 0
@@ -171,7 +169,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
         gs.panStarted = true
         setIsDragging(true)
 
-        // console.warn('[RNGH-Pan] onStart', { startY: gs.startY, minY })
         scrollBridge.initialPosition = gs.startY
         onStart()
       })
@@ -195,8 +192,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
         const isCurrentlyAtTop = currentPos <= minY + AT_TOP_THRESHOLD
         const nodeIsScrolling = scrollY > 0
 
-        // console.warn('[RNGH-Pan] onChange', { translationY: translationY.toFixed(1), deltaY: deltaY.toFixed(1), currentPos: currentPos.toFixed(1), minY, isCurrentlyAtTop, isSwipingDown, scrollY, scrollEngaged: gs.scrollEngaged })
-
         // decision matrix (from react-native-actions-sheet pattern)
         // each frame, decide who handles the movement based on current state
         //
@@ -229,7 +224,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
             } else if (gs.scrollEngaged && hasScrollableContent) {
               // scroll WAS > 0 but now is 0 -> handoff from scroll to pan
               // pan takes over to drag sheet down
-              // console.warn('[RNGH-Pan] *** HANDOFF FROM SCROLL TO PAN ***')
               panHandles = true
             } else {
               // scroll never engaged OR content not scrollable, just drag sheet down
@@ -249,13 +243,13 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
           }
         }
 
-        // console.warn('[RNGH-Pan] decision', { panHandles, isCurrentlyAtTop, isSwipingDown, nodeIsScrolling, scrollEngaged: gs.scrollEngaged, hasScrollableContent, currentPos: currentPos.toFixed(1), minY })
-
         if (panHandles) {
           // pan handles - disable scroll and move sheet
-          // when not at top: lock scroll to 0 (sheet is being dragged)
-          // when at top: lock at current position (handoff from scroll to pan)
-          const lockTo = isCurrentlyAtTop ? undefined : 0
+          // when swiping down at top after scroll was engaged: lock at current scroll position
+          //   (handoff from scroll to pan — preserve scroll offset)
+          // otherwise: always lock scroll to 0 (prevents scroll from firing during sheet drag)
+          const lockTo =
+            isCurrentlyAtTop && isSwipingDown && gs.scrollEngaged ? undefined : 0
           scrollBridge.setScrollEnabled?.(false, lockTo)
 
           // accumulate the delta for position calculation
@@ -276,8 +270,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
         const { velocityY } = event
         const currentPos = gs.startY + gs.accumulatedOffset
 
-        // console.warn('[RNGH-Pan] onEnd', { velocityY, currentPos, accumulatedOffset: gs.accumulatedOffset, scrollY: scrollBridge.y })
-
         // clear scroll lock
         scrollBridge.scrollLockY = undefined
 
@@ -315,7 +307,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
         onEnd(closestPoint)
       })
       .onFinalize(() => {
-        // console.warn('[RNGH-Pan] onFinalize', { panStarted: gs.panStarted })
         // clear scroll lock on finalize too (safety)
         scrollBridge.scrollLockY = undefined
         if (gs.panStarted) {
@@ -334,7 +325,6 @@ export function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult
     // if we have a scroll gesture ref, make pan simultaneous with it
     // this allows both gestures to run and we decide in onChange who handles it
     if (scrollGestureRef?.current) {
-      // console.warn('[RNGH-Pan] adding simultaneousWithExternalGesture for scroll')
       return gesture.simultaneousWithExternalGesture(scrollGestureRef.current)
     }
 

package/src/useSheetController.tsx

@@ -22,6 +22,10 @@ export type SheetControllerContextValue = {
   // hide without "closing" to prevent re-animation when shown again
   hidden?: boolean
   onOpenChange?: React.Dispatch<React.SetStateAction<boolean>> | ((val: boolean) => void)
+  // fired by the sheet after its open/close animation finishes. used by
+  // Dialog adapt to know when it's safe to tear down adapted children
+  // without cutting off the slide-out mid-animation.
+  onAnimationComplete?: (state: { open: boolean }) => void
   // when true, the sheet should skip its open animation (used for adapt handoff)
   skipNextAnimation?: boolean
 }

package/src/useSheetProviderProps.tsx

@@ -8,6 +8,7 @@ import type { ScrollBridge, SheetProps } from './types'
 import type { SheetOpenState } from './useSheetOpenState'
 
 export type SheetContextValue = ReturnType<typeof useSheetProviderProps> & {
+  keyboardOccludedHeight: number
   setHasScrollView: (val: boolean) => void
 }
 

package/test/keyboardAvoidance.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'vitest'
+
+import { getKeyboardOccludedHeight } from '../src/keyboardAvoidance'
+
+describe('getKeyboardOccludedHeight', () => {
+  const base = {
+    frameSize: 700,
+    isKeyboardVisible: true,
+    keyboardHeight: 300,
+    screenSize: 844,
+    sheetY: 59,
+  }
+
+  test('returns overflow below the keyboard top after the sheet is clamped', () => {
+    expect(getKeyboardOccludedHeight(base)).toBe(215)
+  })
+
+  test('returns zero when the keyboard-adjusted sheet clears the keyboard', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        frameSize: 400,
+        sheetY: 144,
+      })
+    ).toBe(0)
+  })
+
+  test('ignores hidden keyboard and offscreen sheet positions', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        isKeyboardVisible: false,
+      })
+    ).toBe(0)
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        sheetY: base.screenSize,
+      })
+    ).toBe(0)
+  })
+
+  test('clamps occlusion to the frame height', () => {
+    expect(
+      getKeyboardOccludedHeight({
+        ...base,
+        frameSize: 120,
+        keyboardHeight: 1000,
+        sheetY: 0,
+      })
+    ).toBe(120)
+  })
+})

package/tsconfig.json

@@ -0,0 +1,57 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "strict": true
+  },
+  "references": [
+    {
+      "path": "../../core/animations-react-native"
+    },
+    {
+      "path": "../../core/compose-refs"
+    },
+    {
+      "path": "../../core/constants"
+    },
+    {
+      "path": "../../core/core"
+    },
+    {
+      "path": "../../core/create-context"
+    },
+    {
+      "path": "../../core/helpers"
+    },
+    {
+      "path": "../../core/use-constant"
+    },
+    {
+      "path": "../../core/use-controllable-state"
+    },
+    {
+      "path": "../../core/use-keyboard-visible"
+    },
+    {
+      "path": "../animate-presence"
+    },
+    {
+      "path": "../portal"
+    },
+    {
+      "path": "../remove-scroll"
+    },
+    {
+      "path": "../scroll-view"
+    },
+    {
+      "path": "../stacks"
+    }
+  ],
+  "exclude": [
+    "types",
+    "dist",
+    "test",
+    "**/__tests__"
+  ]
+}

package/types/GestureDetectorWrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GestureDetectorWrapper.d.ts","sourceRoot":"","sources":["../src/GestureDetectorWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGnD,UAAU,2BAA2B;IACnC,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,QAAQ,EACR,KAAK,GACN,EAAE,2BAA2B,2CAsB7B"}
+{"version":3,"file":"GestureDetectorWrapper.d.ts","sourceRoot":"","sources":["../src/GestureDetectorWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAGnD,UAAU,2BAA2B;IACnC,OAAO,EAAE,GAAG,CAAA;IACZ,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,QAAQ,EACR,KAAK,GACN,EAAE,2BAA2B,2CAmB7B"}

package/types/Sheet.d.ts

@@ -43,6 +43,9 @@ export declare const Sheet: import("react").ForwardRefExoticComponent<{
     portalProps?: import("@tamagui/portal").PortalProps;
     moveOnKeyboardChange?: boolean;
     containerComponent?: React.ComponentType<any>;
+    onAnimationComplete?: (info: {
+        open: boolean;
+    }) => void;
 } & {
     __scopeSheet?: import("@tamagui/create-context").Scope<any>;
 } & import("react").RefAttributes<import("react-native").View>> & {

package/types/Sheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sheet.d.ts","sourceRoot":"","sources":["../src/Sheet.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,cAAc,SAAS,CAAA;AAMvB,eAAO,MAAM,MAAM;;;;;8CAmCjB,CAAA;AAMF,eAAO,MAAM,OAAO;;;;;8CA2BlB,CAAA;AAMF,eAAO,MAAM,KAAK;;;;8CAoBhB,CAAA;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}
+{"version":3,"file":"Sheet.d.ts","sourceRoot":"","sources":["../src/Sheet.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACjD,cAAc,SAAS,CAAA;AAMvB,eAAO,MAAM,MAAM;;;;;8CAmCjB,CAAA;AAMF,eAAO,MAAM,OAAO;;;;;8CA2BlB,CAAA;AAMF,eAAO,MAAM,KAAK;;;;8CAoBhB,CAAA;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIhB,CAAA"}

package/types/SheetContext.d.ts

@@ -32,6 +32,7 @@ export declare const SheetProvider: (props: {
     setPositionImmediate: import("react").Dispatch<import("react").SetStateAction<number>>;
     onlyShowFrame: boolean;
 } & {
+    keyboardOccludedHeight: number;
     setHasScrollView: (val: boolean) => void;
 } & {
     scope: import("@tamagui/create-context").Scope<SheetContextValue>;