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

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)
@@ -166,6 +199,11 @@ class TrueSheetViewManager :
     view.setDraggable(draggable)
   }
 
+  @ReactProp(name = "dismissThreshold")
+  override fun setDismissThreshold(view: TrueSheetView, value: String?) {
+    view.setDismissThreshold(value)
+  }
+
   @ReactProp(name = "dimmed", defaultBoolean = true)
   override fun setDimmed(view: TrueSheetView, dimmed: Boolean) {
     view.setDimmed(dimmed)
@@ -179,6 +217,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 +235,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 +250,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 +265,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 +279,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 +302,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/TrueSheetBottomSheetBehavior.kt

@@ -1,11 +1,73 @@
 package com.lodev09.truesheet.core
 
+import android.view.MotionEvent
+import android.view.VelocityTracker
 import android.view.View
 import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.ViewCompat
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.google.android.material.bottomsheet.BottomSheetBehavior
+import kotlin.math.abs
+
+enum class TrueSheetDismissThreshold {
+  HALF,
+  SHORT;
+
+  companion object {
+    fun fromString(value: String?): TrueSheetDismissThreshold =
+      when (value) {
+        "short" -> SHORT
+        else -> HALF
+      }
+  }
+}
 
 class TrueSheetBottomSheetBehavior<V : View> : BottomSheetBehavior<V>() {
   var scrollingExpandsSheet: Boolean = true
+  var dismissThreshold: TrueSheetDismissThreshold = TrueSheetDismissThreshold.HALF
+  var lowestSheetTop: (() -> Int)? = null
+
+  private var nestedDragged = false
+  private var nestedReleaseVelocity = 0f
+  private var touchPointerId = MotionEvent.INVALID_POINTER_ID
+  private var trackedEventTime = -1L
+  private var trackedAction = -1
+  private var velocityTracker: VelocityTracker? = null
+
+  init {
+    // Material hides once the release point, projected by velocity * friction, passes half
+    // the lowest detent. A higher friction lets short flicks dismiss, closer to iOS sheets.
+    hideFriction = HIDE_FRICTION
+  }
+
+  // With the short threshold, settle at or below the lowest detent like
+  // Compose Material3's sheet instead of Material's half-height rule.
+  private fun releaseState(child: V, dragged: Boolean, velocityY: Float): Int? {
+    if (dismissThreshold != TrueSheetDismissThreshold.SHORT || !isDraggable || !dragged) return null
+    val lowestTop = lowestSheetTop?.invoke() ?: return null
+    if (child.top < lowestTop) return null
+    val hides = if (abs(velocityY) > DISMISS_VELOCITY_DP.dpToPx()) {
+      velocityY > 0
+    } else {
+      child.top - lowestTop > DISMISS_DISTANCE_DP.dpToPx()
+    }
+    return if (hides && isHideable) STATE_HIDDEN else STATE_COLLAPSED
+  }
+
+  override fun onStartNestedScroll(
+    coordinatorLayout: CoordinatorLayout,
+    child: V,
+    directTargetChild: View,
+    target: View,
+    axes: Int,
+    type: Int
+  ): Boolean {
+    if (type == ViewCompat.TYPE_TOUCH) {
+      nestedDragged = false
+      nestedReleaseVelocity = 0f
+    }
+    return super.onStartNestedScroll(coordinatorLayout, child, directTargetChild, target, axes, type)
+  }
 
   override fun onNestedPreScroll(
     coordinatorLayout: CoordinatorLayout,
@@ -20,6 +82,13 @@ class TrueSheetBottomSheetBehavior<V : View> : BottomSheetBehavior<V>() {
     // Block expansion from scroll, but allow if sheet is already being dragged
     if (!scrollingExpandsSheet && dy > 0 && state != STATE_DRAGGING) return
     super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type)
+    if (type == ViewCompat.TYPE_TOUCH) {
+      if (state == STATE_EXPANDED) {
+        nestedDragged = false
+      } else if (consumed[1] != 0) {
+        nestedDragged = true
+      }
+    }
   }
 
   override fun onNestedPreFling(
@@ -29,8 +98,65 @@ class TrueSheetBottomSheetBehavior<V : View> : BottomSheetBehavior<V>() {
     velocityX: Float,
     velocityY: Float
   ): Boolean {
+    nestedReleaseVelocity = -velocityY
+    if (releaseState(child, nestedDragged, nestedReleaseVelocity) != null) return true
     // Don't consume flings — let the ScrollView decelerate naturally
     if (!scrollingExpandsSheet) return false
     return super.onNestedPreFling(coordinatorLayout, child, target, velocityX, velocityY)
   }
+
+  override fun onStopNestedScroll(coordinatorLayout: CoordinatorLayout, child: V, target: View, type: Int) {
+    if (type == ViewCompat.TYPE_TOUCH) {
+      releaseState(child, nestedDragged, nestedReleaseVelocity)?.let {
+        nestedDragged = false
+        state = it
+        return
+      }
+    }
+    super.onStopNestedScroll(coordinatorLayout, child, target, type)
+  }
+
+  private fun trackTouch(event: MotionEvent) {
+    if (dismissThreshold != TrueSheetDismissThreshold.SHORT) return
+    if (event.eventTime == trackedEventTime && event.actionMasked == trackedAction) return
+    trackedEventTime = event.eventTime
+    trackedAction = event.actionMasked
+    if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+      velocityTracker?.recycle()
+      velocityTracker = VelocityTracker.obtain()
+      touchPointerId = event.getPointerId(0)
+    }
+    velocityTracker?.addMovement(event)
+  }
+
+  override fun onInterceptTouchEvent(parent: CoordinatorLayout, child: V, event: MotionEvent): Boolean {
+    trackTouch(event)
+    return super.onInterceptTouchEvent(parent, child, event)
+  }
+
+  override fun onTouchEvent(parent: CoordinatorLayout, child: V, event: MotionEvent): Boolean {
+    trackTouch(event)
+    val wasDragging = state == STATE_DRAGGING
+    val handled = super.onTouchEvent(parent, child, event)
+    if (event.actionMasked == MotionEvent.ACTION_UP) {
+      val velocityY = velocityTracker?.run {
+        computeCurrentVelocity(1000)
+        getYVelocity(touchPointerId)
+      } ?: 0f
+      releaseState(child, wasDragging, velocityY)?.let { state = it }
+    }
+    if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL) {
+      velocityTracker?.recycle()
+      velocityTracker = null
+    }
+    return handled
+  }
+
+  companion object {
+    private const val HIDE_FRICTION = 0.3f
+
+    // Compose Material3 SheetState's velocity and positional thresholds
+    private const val DISMISS_VELOCITY_DP = 125f
+    private const val DISMISS_DISTANCE_DP = 56f
+  }
 }

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
   }
 }