@lodev09/react-native-true-sheet 4.0.0-beta.2 → 4.0.0-beta.4

package/android/src/main/java/com/lodev09/truesheet/TrueSheetView.kt

@@ -101,13 +101,30 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
+    presentInitialIfNeeded()
+  }
 
-    if (initialDetentIndex >= 0 && !didInitiallyPresent) {
-      didInitiallyPresent = true
-      if (initialDetentAnimated) {
-        present(initialDetentIndex, true) { }
-      } else {
-        post { present(initialDetentIndex, false) { } }
+  /**
+   * JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+   * navigation footer set via setOptions) commits together with it. The prop then
+   * arrives after attach, so the ViewManager triggers this on prop update too.
+   * Posted so sibling mounts from the current transaction land before measuring.
+   */
+  fun presentInitialIfNeeded() {
+    if (initialDetentIndex < 0 || didInitiallyPresent || !isAttachedToWindow) return
+
+    didInitiallyPresent = true
+    post {
+      // The view may have been dropped (flag reset) or detached before this
+      // ran — roll back so a later attach retries instead of presenting a
+      // sheet with no live host.
+      if (!didInitiallyPresent) return@post
+      if (!isAttachedToWindow) {
+        didInitiallyPresent = false
+        return@post
+      }
+      if (!viewController.isPresented) {
+        present(initialDetentIndex, initialDetentAnimated) { }
       }
     }
   }
@@ -287,6 +304,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     setupScrollable()
   }
 
+  fun setScrollableHandle(handle: Int) {
+    if (viewController.scrollableHandle == handle) return
+    viewController.scrollableHandle = handle
+    setupScrollable()
+  }
+
   fun setAbsoluteHeader(absolute: Boolean) {
     viewController.absoluteHeader = absolute
   }
@@ -302,9 +325,9 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
 
   private fun setupScrollable() {
     viewController.containerView?.let {
-      it.insetAdjustment = viewController.insetAdjustment
-      it.scrollViewBottomInset = viewController.contentBottomInset
       it.scrollableOptions = viewController.scrollableOptions
+      it.scrollableHandle = viewController.scrollableHandle
+      it.scrollableBottomInset = viewController.contentBottomInset
       it.hasAutoDetent = viewController.detents.contains(-1.0)
       it.footerBottomInset = viewController.contentBottomInset
       it.absoluteFooter = viewController.absoluteFooter
@@ -469,7 +492,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
       if (viewController.containerView == null) return@post
 
       viewController.setupSheetDetentsForSizeChange()
-      TrueSheetStackManager.updateParentTranslation(this)
+      // While settling, onSlide drives the parent translation in realtime —
+      // an animated update here would race it frame-by-frame, staggering the
+      // emitted position
+      if (!viewController.isSettling) {
+        TrueSheetStackManager.updateParentTranslation(this)
+      }
     }
   }
 
@@ -497,14 +525,46 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     }
   }
 
+  /**
+   * Realtime counterpart of updateTranslationForChild, driven by the child's
+   * onSlide frames so stacked sheets move in lockstep instead of on
+   * independently-timed animations.
+   */
+  fun syncTranslationForChild(childSheetTop: Int, childMinSheetTop: Int) {
+    if (!viewController.isSheetVisible || viewController.isExpanded) return
+
+    val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
+    val targetTranslation = maxOf(0, childMinSheetTop - mySheetTop)
+    val actualTranslation = maxOf(0, childSheetTop - mySheetTop)
+    val currentTranslation = viewController.currentTranslationY
+
+    // Ride the child's actual position, but only between the current
+    // translation and the settled target — tracks the child frame-by-frame
+    // when the alignment changes (auto detent resize) while staying put when
+    // the child moves between detents above its minimum. Returning early on
+    // no-ops avoids cancelling an in-flight realign animation.
+    val newTranslation = actualTranslation.coerceIn(
+      minOf(currentTranslation, targetTranslation),
+      maxOf(currentTranslation, targetTranslation)
+    )
+    if (newTranslation == currentTranslation) return
+
+    viewController.translateSheet(newTranslation, animated = false)
+
+    val additionalTranslation = newTranslation - currentTranslation
+    if (additionalTranslation > 0) {
+      TrueSheetStackManager.getParentSheet(this)?.addTranslation(additionalTranslation, animated = false)
+    }
+  }
+
   /**
    * Recursively adds translation to this sheet and all parent sheets.
    */
-  private fun addTranslation(amount: Int) {
+  private fun addTranslation(amount: Int, animated: Boolean = true) {
     if (viewController.isExpanded) return
 
-    viewController.translateSheet(viewController.currentTranslationY + amount)
-    TrueSheetStackManager.getParentSheet(this)?.addTranslation(amount)
+    viewController.translateSheet(viewController.currentTranslationY + amount, animated)
+    TrueSheetStackManager.getParentSheet(this)?.addTranslation(amount, animated)
   }
 
   /**
@@ -626,7 +686,7 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.commitKeyboardDetent()
   }
 
-  // When the ScrollView changes (e.g. conditional remount), re-pin the new ScrollView
+  // When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView
   // and request layout so BottomSheetBehavior re-discovers the nested scrolling child.
   override fun containerViewScrollViewDidChange() {
     setupScrollable()

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -37,6 +37,7 @@ import com.lodev09.truesheet.core.TrueSheetDimViewDelegate
 import com.lodev09.truesheet.core.TrueSheetKeyboardObserver
 import com.lodev09.truesheet.core.TrueSheetKeyboardObserverDelegate
 import com.lodev09.truesheet.core.TrueSheetStackManager
+import com.lodev09.truesheet.utils.Insets
 import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.ScreenUtils
 import com.lodev09.truesheet.utils.TouchEventDeduper
@@ -162,6 +163,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private var pendingDetentIndex: Int = -1
 
   private var interactionState: InteractionState = InteractionState.Idle
+
+  // A content/header/footer size change arrived mid-drag — reconfiguring then
+  // would reset behavior state and kill the gesture, so it's applied on settle.
+  private var hasPendingSizeChange = false
   internal var isBeingDismissed = false
     private set
   var wasHiddenByScreen = false
@@ -227,6 +232,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       behavior?.scrollingExpandsSheet = value?.scrollingExpandsSheet ?: true
     }
 
+  // React tag of the user-provided scrollable within the content (see the scrollableRef prop)
+  var scrollableHandle: Int = -1
+
   override var sheetCornerRadius: Float = DEFAULT_CORNER_RADIUS.dpToPx()
     set(value) {
       field = if (value < 0) DEFAULT_CORNER_RADIUS.dpToPx() else value
@@ -270,9 +278,29 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   val screenWidth: Int
     get() = ScreenUtils.getScreenWidth(reactContext)
 
+  // Cached per layout/configuration pass — the WindowManager and
+  // rootWindowInsets queries behind these allocate, and they're read many
+  // times per animation frame (position emission, detent interpolation,
+  // stacked sheet sync)
+  private var cachedRealScreenHeight: Int = 0
+  private var cachedInsets: Insets? = null
+
+  private fun invalidateScreenMetrics() {
+    cachedRealScreenHeight = 0
+    cachedInsets = null
+  }
+
   // Includes system bars for accurate positioning
   override val realScreenHeight: Int
-    get() = ScreenUtils.getRealScreenHeight(reactContext)
+    get() {
+      if (cachedRealScreenHeight == 0) {
+        cachedRealScreenHeight = ScreenUtils.getRealScreenHeight(reactContext)
+      }
+      return cachedRealScreenHeight
+    }
+
+  private val insets: Insets
+    get() = cachedInsets ?: ScreenUtils.getInsets(reactContext).also { cachedInsets = it }
 
   // Content Measurements
   // Cached values used during dismiss when container is unmounted
@@ -315,10 +343,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   val bottomInset: Int
-    get() = if (edgeToEdgeEnabled) ScreenUtils.getInsets(reactContext).bottom else 0
+    get() = if (edgeToEdgeEnabled) insets.bottom else 0
 
   override val topInset: Int
-    get() = if (edgeToEdgeEnabled) ScreenUtils.getInsets(reactContext).top else 0
+    get() = if (edgeToEdgeEnabled) insets.top else 0
 
   override val contentBottomInset: Int
     get() = if (insetAdjustment == TrueSheetInsetAdjustment.AUTOMATIC) bottomInset else 0
@@ -331,6 +359,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
   // Sheet State
+  val isSettling: Boolean
+    get() = behavior?.state == BottomSheetBehavior.STATE_SETTLING
+
   val isExpanded: Boolean
     get() {
       val sheetTop = sheetView?.top ?: return false
@@ -392,6 +423,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     sheetView = null
 
     interactionState = InteractionState.Idle
+    hasPendingSizeChange = false
     isBeingDismissed = false
     isPresented = false
     isSheetVisible = false
@@ -440,6 +472,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // =============================================================================
 
   override fun coordinatorLayoutDidLayout(changed: Boolean) {
+    if (changed) invalidateScreenMetrics()
+
     // Reposition footer when layout changes
     if (isPresented && changed) {
       positionFooter()
@@ -447,6 +481,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   override fun coordinatorLayoutDidChangeConfiguration() {
+    invalidateScreenMetrics()
     if (!isPresented) return
 
     sheetView?.updateGravity()
@@ -570,6 +605,14 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     emitChangePositionDelegate(sheetView.top)
 
+    // Drive the parent's stack translation from our actual frame position —
+    // an independently-timed animation lags behind (e.g. auto detent shrink)
+    // and reveals the parent above this sheet's top edge. Skipped while
+    // dragging so the parent stays put during drag-to-dismiss.
+    if (!isPresentAnimating && interactionState !is InteractionState.Dragging) {
+      syncParentTranslation(sheetView.top)
+    }
+
     // Position on every slide frame — during keyboard transitions the IME
     // animation callbacks are sparser than the sheet's settle frames, and the
     // footer rides the sheet between them, jittering against the keyboard.
@@ -589,7 +632,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     // whether settled at the target, interrupted by drag, or superseded.
     pendingDetentIndex = -1
 
-    val index = detentCalculator.getDetentIndexForState(newState) ?: return
+    val index = detentCalculator.getDetentIndexForState(newState) ?: run {
+      // Unmapped settle — end any drag anyway so deferred size changes aren't
+      // dropped forever (a leaked Dragging state skips every reconfigure)
+      if (interactionState is InteractionState.Dragging) {
+        interactionState = InteractionState.Idle
+      }
+      flushPendingSizeChange()
+      return
+    }
     val position = getPositionDpForView(sheetView)
     val detentInfo = DetentInfo(index, position)
 
@@ -637,6 +688,14 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
     TrueSheetStackManager.updateBackgroundAccessibility()
+
+    flushPendingSizeChange()
+  }
+
+  private fun flushPendingSizeChange() {
+    if (!hasPendingSizeChange) return
+    hasPendingSizeChange = false
+    setupSheetDetentsForSizeChange()
   }
 
   // =============================================================================
@@ -698,6 +757,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val sheet = this.sheetView ?: return
     if (isPresented) return
 
+    invalidateScreenMetrics()
     shouldAnimatePresent = animated
     currentDetentIndex = detentIndex
     interactionState = InteractionState.Idle
@@ -922,10 +982,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   fun setupSheetDetentsForSizeChange() {
-    // Skip while dragging — the size change is driven by the drag itself (the
+    // Defer while dragging — the size change is driven by the drag itself (the
     // container tracks the sheet's visible height), and reconfiguring resets
-    // behavior state, killing the gesture.
-    if (interactionState is InteractionState.Dragging) return
+    // behavior state, killing the gesture. Applied on settle so a real content
+    // change mid-drag (e.g. items removed from a list) isn't lost.
+    if (interactionState is InteractionState.Dragging) {
+      hasPendingSizeChange = true
+      return
+    }
+    hasPendingSizeChange = false
 
     setupSheetDetents()
     positionFooter()
@@ -1011,8 +1076,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val footerView = containerView?.footerView ?: return
     val sheet = sheetView ?: return
 
-    val keyboardShift = if (currentKeyboardInset > 0) maxOf(0, currentKeyboardInset + footerKeyboardOffset) else 0
-
     // A relative footer is laid out by Yoga (pinned to the container's bottom
     // edge) and stays in the layout flow behind the keyboard — only an
     // absolute footer floats above it
@@ -1021,6 +1084,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       return
     }
 
+    // The footer's absorbed safe-area inset rides below the keyboard's top
+    // edge — its content stays flush with the keyboard without dropping the
+    // inset padding from the layout, which would jump at the transition edges
+    val keyboardShift = if (currentKeyboardInset > 0) {
+      maxOf(0, currentKeyboardInset + footerKeyboardOffset - footerView.bottomInset)
+    } else {
+      0
+    }
+
     val footerHeight = footerView.height
     val sheetHeight = sheet.height
     val sheetTop = sheet.top
@@ -1079,9 +1151,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       delegate = object : TrueSheetKeyboardObserverDelegate {
         override fun keyboardWillShow(height: Int) {
           if (!shouldHandleKeyboard()) return
-          // An absolute footer rises above the keyboard, so it drops the bottom
-          // inset padding — before detents are configured against its height
-          if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
           // If a resize is in flight, restore to its target — not the stale current
           detentIndexBeforeKeyboard = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
           pendingDetentIndex = -1
@@ -1094,7 +1163,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun keyboardWillHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
-          containerView?.footerView?.keyboardVisible = false
           val restoring = !isBeingDismissed && detentIndexBeforeKeyboard >= 0
 
           // Skip reconfigure during interactive keyboard dismiss (e.g. keyboardDismissMode="on-drag")
@@ -1119,7 +1187,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun keyboardDidHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
-          containerView?.footerView?.keyboardVisible = false
           detentIndexBeforeKeyboard = -1
           isKeyboardDismissProgrammatic = false
           setupSheetDetents(applyState = false)
@@ -1141,7 +1208,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
           // Handle case where keyboard is already visible and focus moves into the sheet
           if (!shouldHandleKeyboard()) return
           if (detentIndexBeforeKeyboard < 0 && (keyboardObserver?.currentHeight ?: 0) > 0) {
-            if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
             detentIndexBeforeKeyboard = currentDetentIndex
             currentDetentIndex = detents.size - 1
             setupSheetDetents()
@@ -1256,8 +1322,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     lastEmittedPositionPx = currentTop
     val visibleHeight = realScreenHeight - currentTop
     val position = detentCalculator.getPositionDp(visibleHeight)
-    val interpolatedIndex = detentCalculator.getInterpolatedIndexForPosition(currentTop)
-    val detent = detentCalculator.getInterpolatedDetentForPosition(currentTop)
+    val (interpolatedIndex, detent) = detentCalculator.getInterpolatedPositionInfo(currentTop)
     delegate?.viewControllerDidChangePosition(interpolatedIndex, position, detent, realtime)
   }
 
@@ -1336,9 +1401,27 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     delegate?.viewControllerDidChangeSize(width, height)
   }
 
-  fun translateSheet(translationY: Int, onEnd: (() -> Unit)? = null) {
+  /**
+   * Realtime (non-animated) counterpart of TrueSheetStackManager.updateParentTranslation,
+   * driven by onSlide so the parent tracks this sheet's actual position.
+   */
+  private fun syncParentTranslation(sheetTop: Int) {
+    val parent = parentSheetView ?: return
+    val minSheetTop = detentCalculator.getSheetTopForDetentIndex(0)
+    parent.syncTranslationForChild(sheetTop, minSheetTop)
+  }
+
+  fun translateSheet(translationY: Int, animated: Boolean = true, onEnd: (() -> Unit)? = null) {
     val sheet = sheetView ?: return
 
+    if (!animated) {
+      sheet.animate().cancel()
+      sheet.translationY = translationY.toFloat()
+      emitChangePositionDelegate(sheet.top + translationY)
+      onEnd?.invoke()
+      return
+    }
+
     sheet.animate()
       .translationY(translationY.toFloat())
       .setDuration(TRANSLATE_ANIMATION_DURATION)

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewManager.kt

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.uimanager.ReactStylesDiffMap
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
@@ -55,6 +56,20 @@ class TrueSheetViewManager :
 
   override fun getDelegate(): ViewManagerDelegate<TrueSheetView> = delegate
 
+  // The codegen delegate drops props outside the spec (pointerEvents comes from the
+  // host's style), so apply it here after the delegate pass.
+  override fun updateProperties(viewToUpdate: TrueSheetView, props: ReactStylesDiffMap) {
+    super.updateProperties(viewToUpdate, props)
+    if (props.hasKey("pointerEvents")) {
+      setPointerEvents(viewToUpdate, props.getString("pointerEvents"))
+    }
+  }
+
+  @ReactProp(name = "pointerEvents")
+  fun setPointerEvents(view: TrueSheetView, pointerEventsStr: String?) {
+    view.pointerEvents = PointerEvents.parsePointerEvents(pointerEventsStr)
+  }
+
   /**
    * Export custom direct event types for Fabric
    * Uses Kotlin native collections with decoupled event classes
@@ -179,6 +194,7 @@ class TrueSheetViewManager :
   @ReactProp(name = "initialDetentIndex", defaultInt = -1)
   override fun setInitialDetentIndex(view: TrueSheetView, index: Int) {
     view.initialDetentIndex = index
+    view.presentInitialIfNeeded()
   }
 
   @ReactProp(name = "initialDetentAnimated", defaultBoolean = true)
@@ -231,6 +247,11 @@ class TrueSheetViewManager :
     view.setSheetElevation(elevation.toFloat())
   }
 
+  @ReactProp(name = "scrollableHandle", defaultInt = -1)
+  override fun setScrollableHandle(view: TrueSheetView, handle: Int) {
+    view.setScrollableHandle(handle)
+  }
+
   @ReactProp(name = "scrollableOptions")
   override fun setScrollableOptions(view: TrueSheetView, options: ReadableMap?) {
     if (options == null) {
@@ -240,7 +261,10 @@ class TrueSheetViewManager :
 
     val scrollableOptions = ScrollableOptions(
       keyboardScrollOffset = if (options.hasKey("keyboardScrollOffset")) options.getDouble("keyboardScrollOffset").toFloat() else 0f,
-      scrollingExpandsSheet = if (options.hasKey("scrollingExpandsSheet")) options.getBoolean("scrollingExpandsSheet") else true
+      keyboardOffset = if (options.hasKey("keyboardOffset")) options.getDouble("keyboardOffset").toFloat() else 0f,
+      scrollingExpandsSheet = if (options.hasKey("scrollingExpandsSheet")) options.getBoolean("scrollingExpandsSheet") else true,
+      contentInsetAdjustment = !options.hasKey("contentInsetAdjustmentBehavior") ||
+        options.getBoolean("contentInsetAdjustmentBehavior")
     )
     view.setScrollableOptions(scrollableOptions)
   }

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetCoordinatorLayout.kt

@@ -57,7 +57,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
   private var streamGestureClaimed = false
 
   // Whether the sheet owns vertical drags for this stream: the touch target is inside
-  // the sheet but outside the pinned scrollable (e.g. a header overlaying it), with
+  // the sheet but outside the detected scrollable (e.g. a header overlaying it), with
   // nothing vertically scrollable along its chain. Such targets consume the stream
   // natively (no nested scroll), and BottomSheetBehavior won't intercept because the
   // scrollable's bounds still contain the point (touchingScrollingChild) — intercept
@@ -127,7 +127,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
 
   /**
    * Resolves the stream's touch target (respecting zIndex and pointerEvents) and
-   * decides whether the sheet may drag from it — inside the sheet, outside the pinned
+   * decides whether the sheet may drag from it — inside the sheet, outside the detected
    * scrollable, and nothing along the target's chain scrolls vertically.
    */
   private fun updateStreamTargetFlags(ev: MotionEvent) {
@@ -139,7 +139,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
       .firstNotNullOfOrNull { it.getView() } ?: return
     if (target !== sheet && !target.isDescendantOf(sheet)) return
 
-    // A pinned scrollable that can scroll (or hosts pull-to-refresh) owns its
+    // A detected scrollable that can scroll (or hosts pull-to-refresh) owns its
     // touches — nested scrolling drags the sheet. When it can't scroll (e.g.
     // the sheet is fully expanded and the content fits) it eats the gesture
     // instead, so fall through and let the sheet drag from it — an EditText

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDetentCalculator.kt

@@ -169,8 +169,12 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    */
   private fun getDetentStateMap(): Map<Int, Int>? =
     when (detents.size) {
+      // With one detent halfExpandedRatio matches the peek height, so the
+      // behavior can settle HALF_EXPANDED at the same position (e.g. an upward
+      // drag release) — map it too, or the settle is unmappable
       1 -> mapOf(
         BottomSheetBehavior.STATE_COLLAPSED to 0,
+        BottomSheetBehavior.STATE_HALF_EXPANDED to 0,
         BottomSheetBehavior.STATE_EXPANDED to 0
       )
 
@@ -197,7 +201,7 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    * Find which segment the position falls into for interpolation.
    * @return Triple(fromIndex, toIndex, progress) where progress is 0-1, or null if no detents
    */
-  fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
+  private fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
     val count = detents.size
     if (count == 0) return null
 
@@ -238,37 +242,23 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   }
 
   /**
-   * Returns continuous index (e.g., 0.5 = halfway between detent 0 and 1).
+   * Returns interpolated continuous index (e.g., 0.5 = halfway between detent
+   * 0 and 1) and screen fraction for a position, sharing a single segment
+   * lookup — this runs on every position frame.
    */
-  fun getInterpolatedIndexForPosition(positionPx: Int): Float {
-    val count = detents.size
-    if (count == 0) return -1f
-
-    val segment = findSegmentForPosition(positionPx) ?: return 0f
-    val (fromIndex, _, progress) = segment
-
-    if (fromIndex == -1) return -progress
-    return fromIndex + progress
-  }
-
-  /**
-   * Returns interpolated screen fraction for position.
-   */
-  fun getInterpolatedDetentForPosition(positionPx: Int): Float {
-    val count = detents.size
-    if (count == 0) return 0f
+  fun getInterpolatedPositionInfo(positionPx: Int): Pair<Float, Float> {
+    if (detents.isEmpty()) return Pair(-1f, 0f)
 
-    val segment = findSegmentForPosition(positionPx) ?: return getDetentValueForIndex(0)
-    val (fromIndex, toIndex, progress) = segment
+    val (fromIndex, toIndex, progress) = findSegmentForPosition(positionPx)
+      ?: return Pair(0f, getDetentValueForIndex(0))
 
     if (fromIndex == -1) {
-      val firstDetent = getDetentValueForIndex(0)
-      return maxOf(0f, firstDetent * (1 - progress))
+      return Pair(-progress, maxOf(0f, getDetentValueForIndex(0) * (1 - progress)))
     }
 
     val fromDetent = getDetentValueForIndex(fromIndex)
     val toDetent = getDetentValueForIndex(toIndex)
-    return fromDetent + progress * (toDetent - fromDetent)
+    return Pair(fromIndex + progress, fromDetent + progress * (toDetent - fromDetent))
   }
 
   companion object {

package/android/src/main/java/com/lodev09/truesheet/utils/ViewUtils.kt

@@ -15,13 +15,6 @@ fun View.isDescendantOf(ancestor: View): Boolean {
   return false
 }
 
-fun ViewGroup.smoothScrollBy(dx: Int, dy: Int) {
-  when (this) {
-    is ScrollView -> smoothScrollBy(dx, dy)
-    is NestedScrollView -> smoothScrollBy(dx, dy)
-  }
-}
-
 fun ViewGroup.smoothScrollTo(x: Int, y: Int) {
   when (this) {
     is ScrollView -> smoothScrollTo(x, y)

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.cpp

@@ -1,6 +1,10 @@
 #include "TrueSheetContentViewShadowNode.h"
 
+#include <limits>
+
 #include <react/renderer/components/view/conversions.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 
 namespace facebook::react {
 
@@ -8,6 +12,10 @@ using namespace yoga;
 
 extern const char TrueSheetContentViewComponentName[] = "TrueSheetContentView";
 
+// measure() lays out a clone of this node, which re-enters layout() on the
+// clone — guard so the measurement pass doesn't measure again recursively.
+static thread_local bool gIsMeasuringNaturalHeight = false;
+
 void TrueSheetContentViewShadowNode::adjustLayoutWithState() {
   ensureUnsealed();
 
@@ -17,12 +25,12 @@ void TrueSheetContentViewShadowNode::adjustLayoutWithState() {
 
   auto &props = getConcreteProps();
 
-  // When a ScrollView is pinned under an auto detent, fill the container so
+  // When a ScrollView is detected under an auto detent, fill the container so
   // descendant flex layouts (flex:1 wrappers, the ScrollView itself) resolve
   // against a definite height and the viewport is bounded — natural layout is
-  // circular there since the sheet height derives from the ScrollView's content
-  // size instead (see ContentView's naturalHeight on each platform). For fixed
-  // detents, content lays out naturally like a regular view.
+  // circular there since the sheet height derives from the content's natural
+  // height instead (see updateNaturalHeightIfNeeded). For fixed detents,
+  // content lays out naturally like a regular view.
   auto flexGrow = stateData.scrollableBounded
       ? FloatOptional{1.0f}
       : props.yogaStyle.flexGrow();
@@ -40,4 +48,42 @@ void TrueSheetContentViewShadowNode::adjustLayoutWithState() {
   }
 }
 
+void TrueSheetContentViewShadowNode::layout(LayoutContext layoutContext) {
+  ConcreteViewShadowNode::layout(layoutContext);
+  updateNaturalHeightIfNeeded(layoutContext);
+}
+
+// The natural height is the height the content wants when unbounded — the
+// source for the auto detent. Once the container bounds the content
+// (scrollableBounded), the committed layout no longer reflects it, so lay out
+// a clone of the subtree with an unconstrained height. Yoga respects the
+// user's styles: an explicit-height ScrollView keeps its height while a
+// flexible one expands to its content — no ScrollView discovery involved.
+void TrueSheetContentViewShadowNode::updateNaturalHeightIfNeeded(
+    const LayoutContext &layoutContext) {
+  if (gIsMeasuringNaturalHeight) {
+    return;
+  }
+
+  auto stateData = getStateData();
+  auto size = getLayoutMetrics().frame.size;
+
+  Float naturalHeight = size.height;
+  if (stateData.scrollableBounded) {
+    auto constraints = LayoutConstraints{};
+    constraints.minimumSize = {size.width, 0};
+    constraints.maximumSize = {size.width, std::numeric_limits<Float>::infinity()};
+    constraints.layoutDirection = getLayoutMetrics().layoutDirection;
+
+    gIsMeasuringNaturalHeight = true;
+    naturalHeight = measure(layoutContext, constraints).height;
+    gIsMeasuringNaturalHeight = false;
+  }
+
+  if (stateData.naturalHeight != naturalHeight) {
+    stateData.naturalHeight = naturalHeight;
+    setStateData(std::move(stateData));
+  }
+}
+
 } // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.h

@@ -23,6 +23,13 @@ class JSI_EXPORT TrueSheetContentViewShadowNode final
 
  public:
   void adjustLayoutWithState();
+
+#pragma mark - LayoutableShadowNode
+
+  void layout(LayoutContext layoutContext) override;
+
+ private:
+  void updateNaturalHeightIfNeeded(const LayoutContext &layoutContext);
 };
 
 } // namespace facebook::react