@lodev09/react-native-true-sheet 4.0.0-beta.3 → 4.0.0-beta.30

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
@@ -17,6 +18,7 @@ import com.facebook.react.viewmanagers.TrueSheetViewManagerInterface
 import com.lodev09.truesheet.core.AccessibilityOptions
 import com.lodev09.truesheet.core.GrabberOptions
 import com.lodev09.truesheet.events.*
+import com.lodev09.truesheet.utils.getColorOrNull
 
 /**
  * ViewManager for TrueSheetView - Fabric architecture
@@ -55,6 +57,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 +82,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 +115,15 @@ class TrueSheetViewManager :
     view.setDetents(detents)
   }
 
+  @ReactProp(name = "detentBackgrounds")
+  override fun setDetentBackgrounds(view: TrueSheetView, value: ReadableArray?) {
+    view.setDetentBackgrounds(
+      (0 until (value?.size() ?: 0)).map { index ->
+        value?.getMap(index)?.getColorOrNull("color", view.context)
+      }
+    )
+  }
+
   @ReactProp(name = "backgroundColor", customType = "Color")
   override fun setBackgroundColor(view: TrueSheetView, color: Int?) {
     view.setSheetBackgroundColor(color)
@@ -131,7 +157,7 @@ class TrueSheetViewManager :
       } else {
         null
       },
-      color = if (options.hasKey("color") && !options.isNull("color")) options.getInt("color") else null,
+      color = options.getColorOrNull("color", view.context),
       adaptive = if (options.hasKey("adaptive")) options.getBoolean("adaptive") else true
     )
     view.setGrabberOptions(grabberOptions)
@@ -166,11 +192,26 @@ 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)
   }
 
+  @ReactProp(name = "dimColor", customType = "Color")
+  override fun setDimColor(view: TrueSheetView, color: Int?) {
+    view.setDimColor(color)
+  }
+
+  @ReactProp(name = "dimOpacity", defaultDouble = -1.0)
+  override fun setDimOpacity(view: TrueSheetView, opacity: Double) {
+    view.setDimOpacity(opacity.toFloat())
+  }
+
   @ReactProp(name = "dimmedDetentIndex", defaultInt = 0)
   override fun setDimmedDetentIndex(view: TrueSheetView, index: Int) {
     view.setDimmedDetentIndex(index)
@@ -197,14 +238,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")
@@ -212,8 +253,8 @@ class TrueSheetViewManager :
     // iOS-specific prop - no-op on Android
   }
 
-  @ReactProp(name = "blurOptions")
-  override fun setBlurOptions(view: TrueSheetView, options: ReadableMap?) {
+  @ReactProp(name = "foldOptions")
+  override fun setFoldOptions(view: TrueSheetView, options: ReadableMap?) {
     // iOS-specific prop - no-op on Android
   }
 
@@ -232,6 +273,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) {
@@ -241,7 +287,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)
   }
@@ -260,6 +310,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/RNScreensEventObserver.kt

@@ -22,6 +22,15 @@ class RNScreensEventObserver : EventDispatcherListener {
   private var eventDispatcher: EventDispatcher? = null
   var presenterScreenTag: Int = 0
 
+  // Screens enclosing the presenter. react-native-screens only dispatches lifecycle
+  // events for stack screens, so a presenter inside a plain screen container (e.g. a
+  // bottom tab) never receives them and an enclosing stack screen has to stand in.
+  var ancestorScreenTags: Set<Int> = emptySet()
+
+  // Only the screen that hid the sheet brings it back. An enclosing screen reappearing
+  // must not reveal a sheet whose own screen is still covered inside it.
+  private var disappearedScreenTag: Int = 0
+
   fun startObserving(dispatcher: EventDispatcher?) {
     if (eventDispatcher != null || dispatcher == null) return
 
@@ -35,29 +44,37 @@ class RNScreensEventObserver : EventDispatcherListener {
   }
 
   fun capturePresenterScreenFromView(view: View?) {
-    presenterScreenTag = 0
-
-    var current: View? = view
-    while (current != null) {
-      if (isScreenView(current)) {
-        presenterScreenTag = current.id
-        break
-      }
-      current = (current.parent as? View)
-    }
+    val tags = screenTags(view).toList()
+    presenterScreenTag = tags.firstOrNull() ?: 0
+    ancestorScreenTags = tags.drop(1).toSet()
   }
 
   override fun onEventDispatch(event: Event<*>) {
-    // Only process events for the presenter screen
-    if (presenterScreenTag == 0 || event.viewTag != presenterScreenTag) return
+    // Only process events for the presenter screen and the screens enclosing it
+    if (presenterScreenTag == 0) return
+    if (event.viewTag != presenterScreenTag && event.viewTag !in ancestorScreenTags) return
 
     when (event.eventName) {
-      "topWillDisappear" -> delegate?.presenterScreenWillDisappear()
-      "topWillAppear" -> delegate?.presenterScreenWillAppear()
+      "topWillDisappear" -> {
+        if (disappearedScreenTag != 0) return
+        disappearedScreenTag = event.viewTag
+        delegate?.presenterScreenWillDisappear()
+      }
+
+      "topWillAppear" -> {
+        if (event.viewTag != disappearedScreenTag) return
+        disappearedScreenTag = 0
+        delegate?.presenterScreenWillAppear()
+      }
     }
   }
 
   companion object {
     private fun isScreenView(view: View): Boolean = view.javaClass.name == RN_SCREENS_VIEW_CLASS
+
+    // Tags of the screens enclosing the view, innermost first
+    private fun screenTags(view: View?): Sequence<Int> = generateSequence(view) { it.parent as? View }.filter(::isScreenView).map { it.id }
+
+    fun findPresenterScreenTag(view: View?): Int = screenTags(view).firstOrNull() ?: 0
   }
 }

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

@@ -1,11 +1,82 @@
 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
+  }
+
+  // Material's first layout registers an IME callback that rides the sheet's translationY
+  // with the keyboard. TrueSheet positions sheets for the keyboard itself, and the callback
+  // overwrites a parent's stack translation when the keyboard rises mid-translation.
+  override fun onLayoutChild(parent: CoordinatorLayout, child: V, layoutDirection: Int): Boolean {
+    val handled = super.onLayoutChild(parent, child, layoutDirection)
+    ViewCompat.setWindowInsetsAnimationCallback(child, null)
+    return handled
+  }
+
+  // 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 +91,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 +107,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

@@ -1,7 +1,6 @@
 package com.lodev09.truesheet.core
 
 import android.annotation.SuppressLint
-import android.content.res.Configuration
 import android.graphics.Color
 import android.graphics.Outline
 import android.graphics.Rect
@@ -18,8 +17,9 @@ 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
+import com.lodev09.truesheet.utils.isDarkMode
 
 interface TrueSheetBottomSheetViewDelegate {
   val isTopmostSheet: Boolean
@@ -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?
@@ -81,26 +81,24 @@ class TrueSheetBottomSheetView(private val reactContext: ThemedReactContext) : F
     clipToPadding = false
   }
 
-  override fun setTranslationY(translationY: Float) {
-    // This prevents keyboard inset animations from resetting parent sheet translation
-    if (translationY == 0f && this.translationY != 0f) {
-      return
-    }
-    super.setTranslationY(translationY)
-  }
-
   // =============================================================================
   // MARK: - Layout
   // =============================================================================
 
   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,14 +171,16 @@ class TrueSheetBottomSheetView(private val reactContext: ThemedReactContext) : F
     clipToOutline = true
   }
 
-  private fun getDefaultBackgroundColor(): Int {
-    val isNight = (
-      reactContext.resources.configuration.uiMode and
-        Configuration.UI_MODE_NIGHT_MASK
-      ) == Configuration.UI_MODE_NIGHT_YES
-    return if (isNight) COLOR_SURFACE_CONTAINER_LOW_DARK else COLOR_SURFACE_CONTAINER_LOW_LIGHT
+  fun updateBackgroundColor(color: Int) {
+    (background as? ShapeDrawable)?.let {
+      it.paint.color = color
+      it.invalidateSelf()
+    }
   }
 
+  fun getDefaultBackgroundColor(): Int =
+    if (reactContext.isDarkMode) COLOR_SURFACE_CONTAINER_LOW_DARK else COLOR_SURFACE_CONTAINER_LOW_LIGHT
+
   fun setupElevation() {
     val value = delegate?.sheetElevation ?: DEFAULT_ELEVATION
     val effectiveElevation = if (value < 0) DEFAULT_ELEVATION else value