@lodev09/react-native-true-sheet 4.0.0-beta.14 → 4.0.0-beta.15

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

@@ -5,7 +5,6 @@ import android.view.View
 import android.view.ViewGroup
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.events.EventDispatcher
-import com.facebook.react.util.RNLog
 import com.facebook.react.views.view.ReactViewGroup
 
 interface TrueSheetContainerViewDelegate {
@@ -15,6 +14,7 @@ interface TrueSheetContainerViewDelegate {
   fun containerViewScrollViewDidChange()
   fun containerViewHeaderDidChangeSize(width: Int, height: Int)
   fun containerViewFooterDidChangeSize(width: Int, height: Int)
+  fun containerViewFooterDidLayout()
   fun containerViewPeekDidChangeSize(width: Int, height: Int)
 }
 
@@ -62,6 +62,18 @@ class TrueSheetContainerView(reactContext: ThemedReactContext) :
     }
 
   var absoluteFooter: Boolean = false
+    set(value) {
+      if (field == value) return
+      field = value
+      contentView?.updateContentInset()
+    }
+
+  override var footerAvoidsKeyboard: Boolean = true
+    set(value) {
+      if (field == value) return
+      field = value
+      contentView?.updateContentInset()
+    }
 
   /**
    * Bottom safe-area inset the footer absorbs as padding — the footer
@@ -189,10 +201,9 @@ class TrueSheetContainerView(reactContext: ThemedReactContext) :
   fun attachPeekView(view: TrueSheetPeekView) {
     if (peekView === view) return
 
-    if (peekView != null) {
-      RNLog.w(context as ThemedReactContext, "TrueSheet: Sheet can only have one peek component.")
-      return
-    }
+    // Last-attached wins. During a screen transition the incoming peek mounts
+    // before the outgoing one detaches, and the outgoing detach is a no-op.
+    peekView?.delegate = null
 
     peekView = view
     view.delegate = this
@@ -217,6 +228,12 @@ class TrueSheetContainerView(reactContext: ThemedReactContext) :
   override val footerKeyboardOcclusion: Int
     get() = if (absoluteFooter) footerView?.keyboardOcclusionHeight ?: 0 else -(footerView?.height ?: 0)
 
+  override val absoluteFooterHeight: Int
+    get() = if (absoluteFooter) footerView?.height ?: 0 else 0
+
+  override val absoluteFooterTop: Int
+    get() = footerView?.y?.toInt() ?: height
+
   override val hasRelativeFooter: Boolean
     get() = footerView != null && !absoluteFooter
 
@@ -236,10 +253,15 @@ class TrueSheetContainerView(reactContext: ThemedReactContext) :
   override fun footerViewDidChangeSize(width: Int, height: Int) {
     footerHeight = height
     delegate?.containerViewFooterDidChangeSize(width, height)
-    // A relative footer takes over the bottom inset — drop the scrollable's
+    // A relative footer takes over the bottom inset — drop the scrollable's;
+    // an absolute one may pad the scrollable by its height
     contentView?.updateContentInset()
   }
 
+  override fun footerViewDidLayout() {
+    delegate?.containerViewFooterDidLayout()
+  }
+
   override fun peekViewDidChangeSize(width: Int, height: Int) {
     delegate?.containerViewPeekDidChangeSize(width, height)
   }

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

@@ -18,11 +18,32 @@ import com.lodev09.truesheet.utils.ScreenUtils
 import com.lodev09.truesheet.utils.isDescendantOf
 import com.lodev09.truesheet.utils.smoothScrollTo
 
+/**
+ * What the sheet insets the bottom of the scroll content for — the safe area
+ * while it can scroll, and/or an absolute footer floating over it.
+ */
+enum class TrueSheetContentInsetAdjustment(val safeArea: Boolean, val footer: Boolean) {
+  AUTOMATIC(safeArea = true, footer = true),
+  SAFE_AREA(safeArea = true, footer = false),
+  FOOTER(safeArea = false, footer = true),
+  NEVER(safeArea = false, footer = false);
+
+  companion object {
+    fun fromString(value: String?): TrueSheetContentInsetAdjustment =
+      when (value) {
+        "safe-area" -> SAFE_AREA
+        "footer" -> FOOTER
+        "never" -> NEVER
+        else -> AUTOMATIC
+      }
+  }
+}
+
 data class ScrollableOptions(
   val keyboardScrollOffset: Float = 0f,
   val keyboardOffset: Float = 0f,
   val scrollingExpandsSheet: Boolean = true,
-  val contentInsetAdjustment: Boolean = true
+  val contentInsetAdjustment: TrueSheetContentInsetAdjustment = TrueSheetContentInsetAdjustment.AUTOMATIC
 )
 
 /**
@@ -41,6 +62,21 @@ interface TrueSheetContentViewDelegate {
    */
   val footerKeyboardOcclusion: Int
 
+  /**
+   * Layout height of an absolute footer floating over the content, including
+   * its absorbed safe-area inset — 0 for a relative footer.
+   */
+  val absoluteFooterHeight: Int
+
+  // Includes the controller's translation during sheet transitions.
+  val absoluteFooterTop: Int
+
+  /**
+   * false when an absolute footer stays behind the keyboard instead of rising
+   * above it.
+   */
+  val footerAvoidsKeyboard: Boolean
+
   /**
    * A relative footer sits below the content and absorbs the bottom safe-area
    * inset — the scrollable doesn't reach the sheet's bottom edge, so no
@@ -122,6 +158,13 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
   private var baseBottomInset = 0
   private var keyboardBottomInset = 0
 
+  /**
+   * Height of the absolute footer the scroll content is padded by (see
+   * ScrollableOptions.contentInsetAdjustment), applied on top of the
+   * safe-area or keyboard inset.
+   */
+  private var footerBottomInset = 0
+
   private val scrollableLayoutListener = ViewTreeObserver.OnGlobalLayoutListener {
     updateContentInset()
   }
@@ -203,12 +246,12 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
   /**
    * Re-applies the base content inset — the bottom safe-area inset while the
    * content can scroll, no relative footer absorbs it, and
-   * `contentInsetAdjustmentBehavior` isn't disabled.
+   * `contentInsetAdjustment` includes the safe area.
    */
   fun updateContentInset() {
     val scrollView = detectedScrollView ?: return
 
-    val enabled = scrollableOptions?.contentInsetAdjustment ?: true
+    val enabled = scrollableOptions?.contentInsetAdjustment?.safeArea ?: true
     baseBottomInset = if (enabled && delegate?.hasRelativeFooter != true && canScrollContent(scrollView)) {
       bottomInset
     } else {
@@ -226,7 +269,44 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
 
   // The keyboard covers the safe-area region, so the larger inset wins over a sum
   private fun applyBottomInset() {
-    setScrollContentInset(maxOf(baseBottomInset, keyboardBottomInset))
+    val safeAreaInset = maxOf(baseBottomInset, keyboardBottomInset)
+    footerBottomInset = footerInsetAbove(safeAreaInset)
+    setScrollContentInset(safeAreaInset + footerBottomInset)
+  }
+
+  // A pinned footer uses its positioned top so overlap follows the sheet's
+  // animation, even before the container reaches its final height. A rising
+  // footer uses its layout top because the keyboard inset carries its rise.
+  // The safe-area inset baked into the footer is already
+  // covered by the safe-area or keyboard inset when one applies — only the
+  // footer's occlusion above it stacks on top. A pinned footer adds only the
+  // overlap not already covered by the safe-area or keyboard inset.
+  private fun footerInsetAbove(safeAreaInset: Int): Int {
+    if (scrollableOptions?.contentInsetAdjustment?.footer == false) return 0
+    val scrollView = detectedScrollView ?: return 0
+    val container = parent as? View ?: return 0
+    val footerHeight = delegate?.absoluteFooterHeight ?: 0
+    if (footerHeight <= 0) return 0
+
+    var scrollBottom = scrollView.bottom
+    var view: View = scrollView.parent as? View ?: return 0
+    while (view !== container) {
+      scrollBottom += view.top
+      view = view.parent as? View ?: return 0
+    }
+
+    val footerTop = if (delegate?.footerAvoidsKeyboard == false) {
+      delegate?.absoluteFooterTop ?: return 0
+    } else {
+      container.height - footerHeight
+    }
+    var inset = scrollBottom - footerTop
+    if (delegate?.footerAvoidsKeyboard == false) {
+      inset -= safeAreaInset
+    } else if (safeAreaInset > 0) {
+      inset -= footerHeight - maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
+    }
+    return maxOf(0, inset)
   }
 
   private fun setScrollContentInset(inset: Int) {
@@ -247,6 +327,7 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
     detectedScrollView = null
     baseBottomInset = 0
     keyboardBottomInset = 0
+    footerBottomInset = 0
     appliedKeyboardOffset = 0
   }
 
@@ -344,6 +425,10 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
       val baseInset = maxOf(0, location[1] + scrollView.height - keyboardTop)
       val adjustedInset = maxOf(0, baseInset + keyboardOffset.toInt())
       appliedKeyboardOffset = adjustedInset - baseInset
+      if (delegate?.footerAvoidsKeyboard == false) {
+        appliedKeyboardOffset += footerInsetAbove(maxOf(baseBottomInset, adjustedInset)) -
+          footerInsetAbove(maxOf(baseBottomInset, baseInset))
+      }
       adjustedInset
     } else {
       appliedKeyboardOffset = 0
@@ -394,11 +479,18 @@ class TrueSheetContentView(private val reactContext: ThemedReactContext) : React
     }
 
     // An absolute footer floats over the viewport's bottom edge — extend the
-    // caret target so it clears the footer, not just the keyboard.
-    val footerOcclusion = maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
+    // caret target so it clears the footer, not just the keyboard. Not needed
+    // while the footer inset is applied (the visible range already ends above
+    // it) or when the footer stays behind the keyboard.
+    val footerOcclusion = if (footerBottomInset > 0 || delegate?.footerAvoidsKeyboard == false) {
+      0
+    } else {
+      maxOf(0, delegate?.footerKeyboardOcclusion ?: 0)
+    }
 
     val offset = keyboardScrollOffset.toInt()
-    val visibleHeight = scrollView.height - scrollView.paddingBottom - maxOf(baseBottomInset, keyboardBottomInset) + appliedKeyboardOffset
+    val appliedInset = maxOf(baseBottomInset, keyboardBottomInset) + footerBottomInset
+    val visibleHeight = scrollView.height - scrollView.paddingBottom - appliedInset + appliedKeyboardOffset
     val visibleTop = scrollView.scrollY
     val visibleBottom = scrollView.scrollY + visibleHeight
 

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

@@ -22,6 +22,7 @@ import com.lodev09.truesheet.utils.TouchEventDeduper
  */
 interface TrueSheetFooterViewDelegate {
   fun footerViewDidChangeSize(width: Int, height: Int)
+  fun footerViewDidLayout()
   val eventDispatcher: EventDispatcher?
 }
 
@@ -97,6 +98,17 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
     }
   }
 
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int
+  ) {
+    super.onLayout(changed, left, top, right, bottom)
+    delegate?.footerViewDidLayout()
+  }
+
   // ==================== RootView Implementation ====================
 
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {

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

@@ -224,15 +224,15 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.maxContentWidth = width
   }
 
-  fun setAnchor(anchor: String?) {
-    val value = TrueSheetAnchor.fromString(anchor)
-    if (viewController.anchor == value) return
-    viewController.anchor = value
+  fun setPlacement(placement: String?) {
+    val value = TrueSheetPlacement.fromString(placement)
+    if (viewController.placement == value) return
+    viewController.placement = value
   }
 
-  fun setAnchorOffset(offset: Int) {
-    if (viewController.anchorOffset == offset) return
-    viewController.anchorOffset = offset
+  fun setPlacementOffset(offset: Int) {
+    if (viewController.placementOffset == offset) return
+    viewController.placementOffset = offset
   }
 
   fun setDimmed(dimmed: Boolean) {
@@ -323,6 +323,12 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.positionFooter()
   }
 
+  fun setFooterAvoidsKeyboard(avoids: Boolean) {
+    viewController.footerAvoidsKeyboard = avoids
+    viewController.containerView?.footerAvoidsKeyboard = avoids
+    viewController.positionFooter()
+  }
+
   private fun setupScrollable() {
     viewController.containerView?.let {
       it.scrollableOptions = viewController.scrollableOptions
@@ -330,6 +336,7 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
       it.scrollableBottomInset = viewController.contentBottomInset
       it.footerBottomInset = viewController.contentBottomInset
       it.absoluteFooter = viewController.absoluteFooter
+      it.footerAvoidsKeyboard = viewController.footerAvoidsKeyboard
       it.setupScrollable()
     }
 
@@ -697,6 +704,10 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     viewController.positionFooter()
   }
 
+  override fun containerViewFooterDidLayout() {
+    viewController.positionFooter()
+  }
+
   override fun containerViewPeekDidChangeSize(width: Int, height: Int) {
     // Peek content height affects peek detents
     updateSheetIfNeeded()

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

@@ -80,17 +80,19 @@ interface TrueSheetViewControllerDelegate {
  * enabling touch pass-through to underlying views. Handles detent configuration, drag interactions,
  * keyboard avoidance, dimmed backgrounds, back button, and lifecycle events for stacked sheets.
  */
-enum class TrueSheetAnchor {
-  LEFT,
+enum class TrueSheetPlacement {
+  AUTOMATIC,
+  LEADING,
   CENTER,
-  RIGHT;
+  TRAILING;
 
   companion object {
-    fun fromString(value: String?): TrueSheetAnchor =
+    fun fromString(value: String?): TrueSheetPlacement =
       when (value) {
-        "left" -> LEFT
-        "right" -> RIGHT
-        else -> CENTER
+        "leading" -> LEADING
+        "center" -> CENTER
+        "trailing" -> TRAILING
+        else -> AUTOMATIC
       }
   }
 }
@@ -120,7 +122,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   companion object {
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
-    private const val DEFAULT_ANCHOR_OFFSET = 16 // dp
+    private const val DEFAULT_PLACEMENT_OFFSET = 16 // dp
     private const val TRANSLATE_ANIMATION_DURATION = 200L
     private const val DISMISS_DURATION = 200L
     private const val SCREEN_FADE_DURATION = 150L
@@ -221,8 +223,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // Detent Configuration
   override var maxContentHeight: Int? = null
   override var maxContentWidth: Int? = null
-  override var anchor: TrueSheetAnchor = TrueSheetAnchor.CENTER
-  override var anchorOffset: Int = DEFAULT_ANCHOR_OFFSET.dpToPx().toInt()
+  override var placement: TrueSheetPlacement = TrueSheetPlacement.AUTOMATIC
+  override var placementOffset: Int = DEFAULT_PLACEMENT_OFFSET.dpToPx().toInt()
   override var detents: MutableList<Double> = mutableListOf(0.5, 1.0)
 
   // Appearance Configuration
@@ -330,6 +332,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override var absoluteFooter: Boolean = false
 
+  override val footerInsetAdjustment: Boolean
+    get() = absoluteFooter && scrollableHandle > 0 && scrollableOptions?.contentInsetAdjustment?.footer != false
+
   override val peekContentHeight: Int
     get() = containerView?.peekContentHeight ?: cachedPeekContentHeight
 
@@ -496,9 +501,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   override fun coordinatorLayoutDidLayout(changed: Boolean) {
     if (changed) invalidateScreenMetrics()
 
-    // Reposition footer when layout changes
     if (isPresented && changed) {
-      positionFooter()
+      setupSheetDetentsForSizeChange()
     }
   }
 
@@ -581,19 +585,19 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         delegate?.viewControllerDidAttemptDismiss()
       }
     } else {
-      setStateForDetentIndex(nextIndex)
+      resize(nextIndex)
     }
   }
 
   override fun bottomSheetViewDidAccessibilityIncrement() {
     if (currentDetentIndex < detents.size - 1) {
-      setStateForDetentIndex(currentDetentIndex + 1)
+      resize(currentDetentIndex + 1)
     }
   }
 
   override fun bottomSheetViewDidAccessibilityDecrement() {
     if (currentDetentIndex > 0) {
-      setStateForDetentIndex(currentDetentIndex - 1)
+      resize(currentDetentIndex - 1)
     } else if (dismissible) {
       dismiss(animated = true)
     } else {
@@ -646,6 +650,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     val behavior = behavior ?: return
 
+    if (interactionState is InteractionState.Dragging || pendingDetentIndex >= 0) {
+      updateStateDimensionsForPosition(sheetView.top)
+    }
+
     when (behavior.state) {
       BottomSheetBehavior.STATE_DRAGGING -> handleDragChange(sheetView)
 
@@ -752,7 +760,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       // the detents (and the container) to it.
       commitDetentAndDismissKeyboard(index, sheetView)
     } else {
-      // Settled — resize the container to the settled detent (applies deferred shrinks)
       updateStateDimensions()
     }
 
@@ -880,7 +887,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
     pendingDetentIndex = detentIndex
-    updateStateDimensions(deferShrink = true)
     setupDimmedBackground()
     setStateForDetentIndex(detentIndex)
     resizePromise?.invoke()
@@ -1066,11 +1072,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   fun setupSheetDetentsForSizeChange() {
-    // 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. 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) {
+    // Reconfiguring while the container tracks the sheet can interrupt its
+    // motion. Apply content size changes once the drag or resize settles.
+    if (interactionState is InteractionState.Dragging || isSettling) {
       hasPendingSizeChange = true
       return
     }
@@ -1127,7 +1131,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   fun updateDimAmount(sheetTop: Int? = null, animated: Boolean = false) {
     if (!dimmed) return
-    if (contentHeight == 0) return
 
     // While keyboard is active or transitioning, use the target detent position for dim
     val top = if (isKeyboardActive) {
@@ -1155,6 +1158,12 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   var footerKeyboardOffset: Int = 0
 
+  /**
+   * false keeps an absolute footer pinned to the sheet's bottom edge behind
+   * the keyboard instead of rising above it.
+   */
+  override var footerAvoidsKeyboard: Boolean = true
+
   fun positionFooter() {
     if (!isPresented) return
     val footerView = containerView?.footerView ?: return
@@ -1171,7 +1180,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     // 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) {
+    val keyboardShift = if (currentKeyboardInset > 0 && footerAvoidsKeyboard) {
       maxOf(0, currentKeyboardInset + footerKeyboardOffset - footerView.bottomInset)
     } else {
       0
@@ -1189,6 +1198,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     // Clamp to prevent footer going above safe area
     val maxAllowedY = (sheetHeight - topInset - footerHeight).toFloat()
     footerView.y = minOf(footerY, maxAllowedY)
+    if (!footerAvoidsKeyboard) {
+      containerView?.contentView?.updateContentInset()
+    }
   }
 
   // =============================================================================
@@ -1253,11 +1265,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
           // Skip reconfigure during interactive keyboard dismiss (e.g. keyboardDismissMode="on-drag")
           // to prevent the sheet from jumping. keyboardDidHide will reconfigure after.
           if (restoring || isKeyboardDismissProgrammatic) {
-            setupSheetDetents()
             if (restoring) {
               currentDetentIndex = detentIndexBeforeKeyboard
-              setStateForDetentIndex(currentDetentIndex)
             }
+            setupSheetDetents()
           }
 
           // Same-frame reposition — the reconfigure above shrinks the container
@@ -1374,8 +1385,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun handleDragChange(sheetView: View) {
     if (interactionState !is InteractionState.Dragging) return
 
-    updateStateDimensionsForDrag(sheetView.top)
-
     val position = getPositionDpForView(sheetView)
     val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
     delegate?.viewControllerDidDragChange(currentDetentIndex, position, detent)
@@ -1446,13 +1455,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   /**
    * Updates the Fabric state with the current/target detent size so Yoga sizes
    * the container to the sheet's visible height.
-   *
-   * Unlike iOS, resize animations run over multiple frames (ViewDragHelper), so
-   * shrinking is deferred to settle ([deferShrink]) when a resize animation is
-   * about to run — growing applies immediately so content is laid out before
-   * the sheet reveals it.
    */
-  private fun updateStateDimensions(deferShrink: Boolean = false) {
+  private fun updateStateDimensions() {
     if (detents.isEmpty()) return
 
     val targetIndex = (if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex)
@@ -1461,17 +1465,14 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val newHeight = minOf(detentCalculator.getDetentHeight(detents[targetIndex]), maxAvailableHeight)
     val newWidth = getStateWidth()
 
-    if (deferShrink && newWidth == lastStateWidth && newHeight < lastStateHeight) return
-
     setStateDimensions(newWidth, newHeight)
   }
 
   /**
-   * Tracks the sheet's visible height during drag (and the post-release settle
-   * animation) so the container resizes with the finger, like iOS. Clamped to the
+   * Tracks the sheet's visible height during drags and resize animations. Clamped to the
    * smallest detent — dragging below it slides the sheet out without resizing.
    */
-  private fun updateStateDimensionsForDrag(sheetTop: Int) {
+  private fun updateStateDimensionsForPosition(sheetTop: Int) {
     if (detents.isEmpty()) return
 
     val maxAvailableHeight = realScreenHeight - topInset

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

@@ -213,14 +213,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")
@@ -233,6 +233,11 @@ class TrueSheetViewManager :
     // iOS-specific prop - no-op on Android
   }
 
+  @ReactProp(name = "glass", defaultBoolean = true)
+  override fun setGlass(view: TrueSheetView, glass: Boolean) {
+    // iOS-specific prop - no-op on Android
+  }
+
   @ReactProp(name = "insetAdjustment")
   override fun setInsetAdjustment(view: TrueSheetView, insetAdjustment: String?) {
     view.setInsetAdjustment(insetAdjustment ?: "automatic")
@@ -264,8 +269,9 @@ class TrueSheetViewManager :
       keyboardScrollOffset = if (options.hasKey("keyboardScrollOffset")) options.getDouble("keyboardScrollOffset").toFloat() else 0f,
       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")
+      contentInsetAdjustment = TrueSheetContentInsetAdjustment.fromString(
+        if (options.hasKey("contentInsetAdjustment")) options.getString("contentInsetAdjustment") else null
+      )
     )
     view.setScrollableOptions(scrollableOptions)
   }
@@ -284,6 +290,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)
   }