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

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

@@ -1,10 +1,13 @@
 package com.lodev09.truesheet
 
 import android.view.WindowManager
+import com.facebook.react.bridge.ColorPropConverter
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 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 +58,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
@@ -66,6 +83,7 @@ class TrueSheetViewManager :
       DidPresentEvent.EVENT_NAME to hashMapOf("registrationName" to DidPresentEvent.REGISTRATION_NAME),
       WillDismissEvent.EVENT_NAME to hashMapOf("registrationName" to WillDismissEvent.REGISTRATION_NAME),
       DidDismissEvent.EVENT_NAME to hashMapOf("registrationName" to DidDismissEvent.REGISTRATION_NAME),
+      DismissAttemptEvent.EVENT_NAME to hashMapOf("registrationName" to DismissAttemptEvent.REGISTRATION_NAME),
       DetentChangeEvent.EVENT_NAME to hashMapOf("registrationName" to DetentChangeEvent.REGISTRATION_NAME),
       DragBeginEvent.EVENT_NAME to hashMapOf("registrationName" to DragBeginEvent.REGISTRATION_NAME),
       DragChangeEvent.EVENT_NAME to hashMapOf("registrationName" to DragChangeEvent.REGISTRATION_NAME),
@@ -98,6 +116,21 @@ class TrueSheetViewManager :
     view.setDetents(detents)
   }
 
+  @ReactProp(name = "detentBackgrounds")
+  override fun setDetentBackgrounds(view: TrueSheetView, value: ReadableArray?) {
+    view.setDetentBackgrounds(
+      (0 until (value?.size() ?: 0)).map { index ->
+        val entry = value?.getMap(index)
+        if (entry != null && entry.hasKey("color") && !entry.isNull("color")) {
+          val color = if (entry.getType("color") == ReadableType.Map) entry.getMap("color") else entry.getDouble("color")
+          ColorPropConverter.getColor(color, view.context)
+        } else {
+          null
+        }
+      }
+    )
+  }
+
   @ReactProp(name = "backgroundColor", customType = "Color")
   override fun setBackgroundColor(view: TrueSheetView, color: Int?) {
     view.setSheetBackgroundColor(color)
@@ -179,6 +212,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)
@@ -196,14 +230,14 @@ class TrueSheetViewManager :
     view.setMaxContentWidth(if (width > 0) width.dpToPx().toInt() else null)
   }
 
-  @ReactProp(name = "anchor")
-  override fun setAnchor(view: TrueSheetView, anchor: String?) {
-    view.setAnchor(anchor)
+  @ReactProp(name = "placement")
+  override fun setPlacement(view: TrueSheetView, placement: String?) {
+    view.setPlacement(placement)
   }
 
-  @ReactProp(name = "anchorOffset", defaultDouble = 0.0)
-  override fun setAnchorOffset(view: TrueSheetView, offset: Double) {
-    view.setAnchorOffset(if (offset > 0) offset.dpToPx().toInt() else 0)
+  @ReactProp(name = "placementOffset", defaultDouble = 0.0)
+  override fun setPlacementOffset(view: TrueSheetView, offset: Double) {
+    view.setPlacementOffset(if (offset > 0) offset.dpToPx().toInt() else 0)
   }
 
   @ReactProp(name = "backgroundBlur")
@@ -211,11 +245,6 @@ class TrueSheetViewManager :
     // iOS-specific prop - no-op on Android
   }
 
-  @ReactProp(name = "blurOptions")
-  override fun setBlurOptions(view: TrueSheetView, options: ReadableMap?) {
-    // iOS-specific prop - no-op on Android
-  }
-
   @ReactProp(name = "insetAdjustment")
   override fun setInsetAdjustment(view: TrueSheetView, insetAdjustment: String?) {
     view.setInsetAdjustment(insetAdjustment ?: "automatic")
@@ -231,6 +260,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 +274,11 @@ 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 = TrueSheetContentInsetAdjustment.fromString(
+        if (options.hasKey("contentInsetAdjustment")) options.getString("contentInsetAdjustment") else null
+      )
     )
     view.setScrollableOptions(scrollableOptions)
   }
@@ -259,6 +297,10 @@ class TrueSheetViewManager :
     val keyboardOffset =
       if (options != null && options.hasKey("keyboardOffset")) options.getDouble("keyboardOffset").toFloat() else 0f
     view.setFooterKeyboardOffset(keyboardOffset)
+
+    val avoidKeyboard =
+      if (options != null && options.hasKey("avoidKeyboard")) options.getBoolean("avoidKeyboard") else true
+    view.setFooterAvoidsKeyboard(avoidKeyboard)
   }
 
   companion object {

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

@@ -18,7 +18,7 @@ import androidx.core.view.ViewCompat
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.ThemedReactContext
 import com.google.android.material.bottomsheet.BottomSheetBehavior
-import com.lodev09.truesheet.TrueSheetAnchor
+import com.lodev09.truesheet.TrueSheetPlacement
 import com.lodev09.truesheet.utils.ScreenUtils
 
 interface TrueSheetBottomSheetViewDelegate {
@@ -27,8 +27,8 @@ interface TrueSheetBottomSheetViewDelegate {
   val sheetElevation: Float
   val sheetBackgroundColor: Int?
   val maxContentWidth: Int?
-  val anchor: TrueSheetAnchor
-  val anchorOffset: Int
+  val placement: TrueSheetPlacement
+  val placementOffset: Int
   val grabber: Boolean
   val grabberOptions: GrabberOptions?
   val accessibilityOptions: AccessibilityOptions?
@@ -94,13 +94,19 @@ class TrueSheetBottomSheetView(private val reactContext: ThemedReactContext) : F
   // =============================================================================
 
   private fun resolveAnchor(): Pair<Int, Int> {
-    val anchor = if (ScreenUtils.isPortraitPhone(reactContext)) null else delegate?.anchor
-    val gravity = when (anchor) {
-      TrueSheetAnchor.LEFT -> Gravity.START
-      TrueSheetAnchor.RIGHT -> Gravity.END
+    val placement = if (ScreenUtils.isPortraitPhone(reactContext)) null else delegate?.placement
+    val gravity = when (placement) {
+      TrueSheetPlacement.LEADING -> Gravity.START
+      TrueSheetPlacement.TRAILING -> Gravity.END
       else -> Gravity.CENTER_HORIZONTAL
     } or Gravity.BOTTOM
-    val margin = if (anchor == TrueSheetAnchor.LEFT || anchor == TrueSheetAnchor.RIGHT) delegate?.anchorOffset ?: 0 else 0
+    val margin = if (placement == TrueSheetPlacement.LEADING ||
+      placement == TrueSheetPlacement.TRAILING
+    ) {
+      delegate?.placementOffset ?: 0
+    } else {
+      0
+    }
     return Pair(gravity, margin)
   }
 
@@ -173,7 +179,14 @@ class TrueSheetBottomSheetView(private val reactContext: ThemedReactContext) : F
     clipToOutline = true
   }
 
-  private fun getDefaultBackgroundColor(): Int {
+  fun updateBackgroundColor(color: Int) {
+    (background as? ShapeDrawable)?.let {
+      it.paint.color = color
+      it.invalidateSelf()
+    }
+  }
+
+  fun getDefaultBackgroundColor(): Int {
     val isNight = (
       reactContext.resources.configuration.uiMode and
         Configuration.UI_MODE_NIGHT_MASK

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

@@ -10,9 +10,11 @@ import android.view.ViewGroup
 import android.widget.EditText
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.uimanager.ReactPointerEventsView
 import com.facebook.react.uimanager.TouchTargetHelper
+import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.isDescendantOf
 
 interface TrueSheetCoordinatorLayoutDelegate {
@@ -20,6 +22,12 @@ interface TrueSheetCoordinatorLayoutDelegate {
   fun coordinatorLayoutDidChangeConfiguration()
   fun findScrollView(): ViewGroup?
   fun findSheetView(): TrueSheetBottomSheetView?
+
+  /**
+   * A downward pull the sheet couldn't follow ended; `overdragPx` is the travel it
+   * didn't follow, `keyboardWasVisible` whether the keyboard was up when it began.
+   */
+  fun coordinatorLayoutDidPullDown(overdragPx: Int, keyboardWasVisible: Boolean)
 }
 
 /**
@@ -57,13 +65,26 @@ 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
   // manually.
   private var streamSheetDraggable = false
   private var streamDraggableEditText = false
+  private var streamScrollsIndependently = false
+
+  // Pull-down tracking. BottomSheetBehavior gives no callback when a downward drag
+  // is clamped by `isHideable = false` — the sheet stays put (or the scrollable
+  // overscrolls) and no state change fires. Accumulate the downward finger travel
+  // neither the sheet nor its scrollable followed and report it on release so the
+  // controller can surface a blocked dismiss attempt.
+  private var pullTracking = false
+  private var pullStartX = 0f
+  private var pullStartY = 0f
+  private var pullLastY = 0f
+  private var pullOverdrag = 0f
+  private var pullKeyboardVisible = false
 
   init {
     layoutParams = LayoutParams(
@@ -94,6 +115,49 @@ class TrueSheetCoordinatorLayout(context: Context) :
   override val pointerEvents: PointerEvents
     get() = PointerEvents.BOX_NONE
 
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    when (ev.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        val sheet = delegate?.findSheetView()
+        pullTracking = sheet != null && isTouchInside(sheet, ev)
+        pullStartX = ev.rawX
+        pullStartY = ev.rawY
+        pullLastY = ev.rawY
+        pullOverdrag = 0f
+        pullKeyboardVisible = pullTracking && KeyboardUtils.isKeyboardVisible(this)
+      }
+
+      MotionEvent.ACTION_MOVE -> if (pullTracking) {
+        val sheet = delegate?.findSheetView()
+        val topBefore = sheet?.top
+        val handled = super.dispatchTouchEvent(ev)
+        val step = ev.rawY - pullLastY
+        pullLastY = ev.rawY
+        // Finger moved down but the sheet stayed put and the scrollable is at
+        // its top — the pull was clamped
+        if (step > 0 && sheet != null && sheet.top == topBefore && delegate?.findScrollView()?.canScrollVertically(-1) != true) {
+          pullOverdrag += step
+        }
+        return handled
+      }
+
+      MotionEvent.ACTION_UP -> if (pullTracking) {
+        pullTracking = false
+        val dx = kotlin.math.abs(ev.rawX - pullStartX)
+        val dy = ev.rawY - pullStartY
+        // Let the behavior settle first so the controller sees the resting position.
+        val handled = super.dispatchTouchEvent(ev)
+        if (dy > dx && pullOverdrag > PULL_DOWN_THRESHOLD_DP.dpToPx()) {
+          delegate?.coordinatorLayoutDidPullDown(pullOverdrag.toInt(), pullKeyboardVisible)
+        }
+        return handled
+      }
+
+      MotionEvent.ACTION_CANCEL -> pullTracking = false
+    }
+    return super.dispatchTouchEvent(ev)
+  }
+
   /**
    * Clears stale `nestedScrollingChildRef` from BottomSheetBehavior.
    *
@@ -127,19 +191,20 @@ 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) {
     streamSheetDraggable = false
     streamDraggableEditText = false
+    streamScrollsIndependently = false
 
     val sheet = delegate?.findSheetView() ?: return
     val target = TouchTargetHelper.findTargetPathAndCoordinatesForTouch(ev.x, ev.y, this, FloatArray(2))
       .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
@@ -152,7 +217,10 @@ class TrueSheetCoordinatorLayout(context: Context) :
 
     var view: View? = target
     while (view != null && view !== this) {
-      if (view.canScrollVertically(1) || view.canScrollVertically(-1)) return
+      if (view.canScrollVertically(1) || view.canScrollVertically(-1)) {
+        streamScrollsIndependently = !view.isNestedScrollingEnabled
+        return
+      }
       view = view.parent as? View
     }
 
@@ -160,6 +228,14 @@ class TrueSheetCoordinatorLayout(context: Context) :
     streamDraggableEditText = target is EditText
   }
 
+  private fun isTouchInside(view: View, ev: MotionEvent): Boolean {
+    val loc = IntArray(2)
+    view.getLocationOnScreen(loc)
+    val x = ev.rawX.toInt()
+    val y = ev.rawY.toInt()
+    return x >= loc[0] && x <= loc[0] + view.width && y >= loc[1] && y <= loc[1] + view.height
+  }
+
   private fun findDescendantViewAt(view: View, rawX: Int, rawY: Int, predicate: (View) -> Boolean): View? {
     val loc = IntArray(2)
     view.getLocationOnScreen(loc)
@@ -174,7 +250,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
   }
 
   /**
-   * Called by descendant RootView implementations (controller, footer) when a child
+   * Called by the descendant RootView (controller) when a child
    * starts a native gesture — e.g. an RNGH handler activated or a scrollable began
    * scrolling. Yields sheet interception for the rest of the touch stream.
    */
@@ -226,6 +302,8 @@ class TrueSheetCoordinatorLayout(context: Context) :
       return false
     }
 
+    if (streamScrollsIndependently) return false
+
     if (streamGestureClaimed) {
       if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
         streamGestureClaimed = false
@@ -299,5 +377,6 @@ class TrueSheetCoordinatorLayout(context: Context) :
   companion object {
     private const val GESTURE_HANDLER_ROOT_VIEW_CLASS = "com.swmansion.gesturehandler.react.RNGestureHandlerRootView"
     private const val GESTURE_CLAIM_SLOP_FACTOR = 3
+    private const val PULL_DOWN_THRESHOLD_DP = 24f
   }
 }

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

@@ -18,11 +18,27 @@ interface TrueSheetDetentCalculatorDelegate {
   val absoluteHeader: Boolean
   val footerHeight: Int
   val absoluteFooter: Boolean
+
+  /**
+   * True while the plugged scrollable is padded by the absolute footer's
+   * height (see ScrollableOptions.footerInsetAdjustment) — the footer then
+   * counts toward the auto detent like a relative one, so the content ends
+   * above it.
+   */
+  val footerInsetAdjustment: Boolean
+  val footerAvoidsKeyboard: Boolean
   val peekContentHeight: Int
   val contentBottomInset: Int
   val maxContentHeight: Int?
   val keyboardInset: Int
   val topInset: Int
+
+  /**
+   * True while the keyboard holds the sheet up: the collapsed stop then sits at
+   * the keyboard-free first detent (the "floor") so a drag-down dismisses the
+   * keyboard before it can dismiss the sheet.
+   */
+  val hasKeyboardFloor: Boolean
 }
 
 /**
@@ -44,6 +60,15 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val maxContentHeight: Int? get() = delegate?.maxContentHeight
   private val keyboardInset: Int get() = delegate?.keyboardInset ?: 0
   private val topInset: Int get() = delegate?.topInset ?: 0
+  private val hasKeyboardFloor: Boolean get() = delegate?.hasKeyboardFloor == true
+
+  /**
+   * An absolute footer floats over the content and contributes no height to
+   * the auto detent — unless it pads the scrollable, then the content ends
+   * above it like a relative footer.
+   */
+  private val footerInAuto: Boolean
+    get() = delegate?.absoluteFooter == false || delegate?.footerInsetAdjustment == true
 
   /**
    * Height for auto (-1.0) detents: content + header + footer height.
@@ -52,14 +77,14 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val autoDetentHeight: Int
     get() = contentHeight +
       (if (delegate?.absoluteHeader == true) 0 else headerHeight) +
-      (if (delegate?.absoluteFooter == true) 0 else footerHeight)
+      (if (footerInAuto) footerHeight else 0)
 
   /**
-   * Bottom inset for auto detents. A relative footer owns the sheet's bottom
-   * edge, so it absorbs the inset instead of adding it to the auto height.
+   * Bottom inset for auto detents. A footer counted in the auto height owns
+   * the sheet's bottom edge, so it absorbs the inset instead of adding it.
    */
   private val autoDetentBottomInset: Int
-    get() = if (footerHeight > 0 && delegate?.absoluteFooter == false) 0 else contentBottomInset
+    get() = if (footerHeight > 0 && footerInAuto) 0 else contentBottomInset
 
   /**
    * Bottom inset for peek detents. An absolute footer counts toward the peek
@@ -97,11 +122,37 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
       (detent * screenHeight).toInt() + contentBottomInset
     }
 
-    val height = if (includeKeyboard) baseHeight + keyboardInset else baseHeight
+    val keyboardHeight = if (includeKeyboard) keyboardInset else 0
+    val footerKeyboardOverlap = if (detent == -1.0 &&
+      delegate?.absoluteFooter == true &&
+      footerInAuto &&
+      delegate?.footerAvoidsKeyboard == false
+    ) {
+      minOf(keyboardHeight, maxOf(0, footerHeight - contentBottomInset))
+    } else {
+      0
+    }
+    val height = baseHeight + keyboardHeight - footerKeyboardOverlap
     val maxAllowedHeight = screenHeight + contentBottomInset
     return maxContentHeight?.let { minOf(height, it, maxAllowedHeight) } ?: minOf(height, maxAllowedHeight)
   }
 
+  fun getBackgroundIndex(sheetTop: Int, displayedIndex: Int): Int {
+    if (detents.isEmpty()) return -1
+
+    val height = getVisibleSheetHeight(sheetTop)
+    var nextIndex = displayedIndex.coerceIn(0, detents.size - 1)
+    var distance = kotlin.math.abs(height - getVisibleSheetHeight(getSheetTopForDetentIndex(nextIndex)))
+    for (index in detents.indices) {
+      val nextDistance = kotlin.math.abs(height - getVisibleSheetHeight(getSheetTopForDetentIndex(index)))
+      if (nextDistance < distance) {
+        nextIndex = index
+        distance = nextDistance
+      }
+    }
+    return nextIndex
+  }
+
   /**
    * Get the expected sheet top position for a detent index.
    */
@@ -110,12 +161,31 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
       RNLog.w(reactContext, "TrueSheet: Detent index ($index) is out of bounds (0..${detents.size - 1})")
       return realScreenHeight
     }
-    // Clamp to the space the sheet can actually occupy — matching
-    // setupSheetDetents. A keyboard-inflated detent height can exceed it,
-    // placing the expected top above the screen while the real sheet stops
-    // at the top inset.
+    // With a keyboard floor only the last detent stays keyboard-shifted — it's
+    // the keyboard-expanded resting position; the stops below it are keyboard-free
+    val isKeyboardFreeStop = hasKeyboardFloor && index != detents.size - 1
+    return getSheetTop(detents[index], includeKeyboard = !isKeyboardFreeStop)
+  }
+
+  /**
+   * Top of the lowest stop the sheet can rest at: the keyboard floor while it's
+   * active, else the first detent.
+   */
+  fun getLowestSheetTop(): Int = if (hasKeyboardFloor) getSheetTop(detents[0], includeKeyboard = false) else getSheetTopForDetentIndex(0)
+
+  /**
+   * Top of the half stop while the keyboard floor is active: the keyboard-free
+   * second detent, or the floor itself for a single detent.
+   */
+  fun getKeyboardHalfStopTop(): Int = getSheetTop(detents[minOf(1, detents.size - 1)], includeKeyboard = false)
+
+  // Clamp to the space the sheet can actually occupy — matching
+  // setupSheetDetents. A keyboard-inflated detent height can exceed it,
+  // placing the expected top above the screen while the real sheet stops
+  // at the top inset.
+  private fun getSheetTop(detent: Double, includeKeyboard: Boolean = true): Int {
     val maxAvailableHeight = realScreenHeight - topInset
-    return realScreenHeight - minOf(getDetentHeight(detents[index]), maxAvailableHeight)
+    return realScreenHeight - minOf(getDetentHeight(detent, includeKeyboard), maxAvailableHeight)
   }
 
   /**
@@ -152,6 +222,9 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    */
   fun getStateForDetentIndex(index: Int): Int {
     val stateMap = getDetentStateMap() ?: return BottomSheetBehavior.STATE_HIDDEN
+    // With a keyboard floor the keyboard-expanded last detent lives at the
+    // expanded stop — the half stop (which may share its index) is keyboard-free
+    if (hasKeyboardFloor && index == detents.size - 1) return BottomSheetBehavior.STATE_EXPANDED
     return stateMap.entries.find { it.value == index }?.key ?: BottomSheetBehavior.STATE_HIDDEN
   }
 
@@ -169,8 +242,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,16 +274,18 @@ 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
 
-    val firstPos = getSheetTopForDetentIndex(0)
+    // A single keyboard-shifted detent can rest down at its keyboard floor —
+    // that range is still index 0, not a dismissal
+    val floorPos = getLowestSheetTop()
 
-    // Position is below first detent (sheet is being dragged down to dismiss)
-    if (positionPx > firstPos) {
-      val range = realScreenHeight - firstPos
-      val progress = if (range > 0) (positionPx - firstPos).toFloat() / range else 0f
+    // Position is below the lowest stop (sheet is being dragged down to dismiss)
+    if (positionPx > floorPos) {
+      val range = realScreenHeight - floorPos
+      val progress = if (range > 0) (positionPx - floorPos).toFloat() / range else 0f
       return Triple(-1, 0, progress)
     }
 
@@ -238,37 +317,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/core/TrueSheetDimView.kt

@@ -139,6 +139,9 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
 
   override fun onTouchEvent(event: MotionEvent): Boolean {
     if (blockGestures) {
+      if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+        parent?.requestDisallowInterceptTouchEvent(true)
+      }
       // When dimmed, consume touch and trigger click on ACTION_UP
       if (event.action == MotionEvent.ACTION_UP) {
         performClick()