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

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

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

@@ -72,6 +72,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
   // 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
@@ -196,6 +197,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
   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))
@@ -215,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
     }
 
@@ -297,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

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

@@ -18,6 +18,15 @@ 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?
@@ -53,6 +62,14 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   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.
    * An absolute (floating) header or footer overlaps the content, so it contributes no height.
@@ -60,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
@@ -105,7 +122,17 @@ 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)
   }

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()

package/ios/TrueSheetContainerView.h

@@ -16,13 +16,19 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface ScrollableOptions : NSObject
 
-@property (nonatomic, assign) BOOL contentInsetAdjustment;
+@property (nonatomic, assign) facebook::react::TrueSheetViewContentInsetAdjustment contentInsetAdjustment;
 @property (nonatomic, assign) CGFloat keyboardScrollOffset;
 @property (nonatomic, assign) CGFloat keyboardOffset;
 @property (nonatomic, assign) BOOL scrollingExpandsSheet;
 @property (nonatomic, assign) facebook::react::TrueSheetViewTopScrollEdgeEffect topScrollEdgeEffect;
 @property (nonatomic, assign) facebook::react::TrueSheetViewBottomScrollEdgeEffect bottomScrollEdgeEffect;
 
+/**
+ * Derived from `contentInsetAdjustment` — which of the two bottom insets apply
+ */
+@property (nonatomic, readonly) BOOL safeAreaInsetAdjustment;
+@property (nonatomic, readonly) BOOL footerInsetAdjustment;
+
 @end
 
 @class TrueSheetPeekView;
@@ -58,10 +64,17 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) NSInteger scrollableHandle;
 
 /**
- * Whether the resolved scrollable's `contentInsetAdjustmentBehavior` is set to
- * `automatic` — already gated by the sheet's `insetAdjustment`
+ * Whether the resolved scrollable gets the bottom safe-area inset (UIKit's
+ * `contentInsetAdjustmentBehavior` set to `automatic`) — already gated by the
+ * sheet's `insetAdjustment`
+ */
+@property (nonatomic, assign) BOOL safeAreaInsetAdjustment;
+
+/**
+ * Whether the resolved scrollable is padded by the absolute footer's height —
+ * already gated by the footer position and a plugged scrollable
  */
-@property (nonatomic, assign) BOOL contentInsetAdjustment;
+@property (nonatomic, assign) BOOL footerInsetAdjustment;
 
 /**
  * Bottom safe-area inset the footer absorbs as padding — the footer

package/ios/TrueSheetContainerView.mm

@@ -32,7 +32,7 @@ using namespace facebook::react;
 
 - (instancetype)init {
   if (self = [super init]) {
-    _contentInsetAdjustment = YES;
+    _contentInsetAdjustment = TrueSheetViewContentInsetAdjustment::Automatic;
     _keyboardScrollOffset = 0;
     _keyboardOffset = 0;
     _scrollingExpandsSheet = YES;
@@ -42,6 +42,16 @@ using namespace facebook::react;
   return self;
 }
 
+- (BOOL)safeAreaInsetAdjustment {
+  return _contentInsetAdjustment == TrueSheetViewContentInsetAdjustment::Automatic ||
+         _contentInsetAdjustment == TrueSheetViewContentInsetAdjustment::SafeArea;
+}
+
+- (BOOL)footerInsetAdjustment {
+  return _contentInsetAdjustment == TrueSheetViewContentInsetAdjustment::Automatic ||
+         _contentInsetAdjustment == TrueSheetViewContentInsetAdjustment::Footer;
+}
+
 @end
 
 @interface TrueSheetContainerView () <TrueSheetContentViewDelegate,
@@ -153,10 +163,16 @@ using namespace facebook::react;
   _contentView.keyboardOffset = scrollableOptions ? scrollableOptions.keyboardOffset : 0;
 }
 
+- (void)setFooterInsetAdjustment:(BOOL)footerInsetAdjustment {
+  _footerInsetAdjustment = footerInsetAdjustment;
+  _contentView.footerInsetAdjustment = footerInsetAdjustment;
+}
+
 - (void)setupScrollable {
   if (_contentView) {
     _contentView.scrollableHandle = _scrollableHandle;
-    _contentView.contentInsetAdjustment = _contentInsetAdjustment;
+    _contentView.safeAreaInsetAdjustment = _safeAreaInsetAdjustment;
+    _contentView.footerInsetAdjustment = _footerInsetAdjustment;
     [_contentView setupScrollable];
     [_contentView applyScrollEdgeEffects:_scrollableOptions];
     if (@available(iOS 26.0, *)) {
@@ -202,6 +218,7 @@ using namespace facebook::react;
     _contentView = (TrueSheetContentView *)childComponentView;
     _contentView.delegate = self;
     _contentView.footerView = _footerView;
+    _contentView.footerInsetAdjustment = _footerInsetAdjustment;
 
     // Children mount bottom-up, so the content subtree is complete here.
     // Late-mounted peek views attach themselves instead (see TrueSheetPeekView).
@@ -283,6 +300,7 @@ using namespace facebook::react;
 
 - (void)footerViewDidChangeSize:(CGSize)newSize {
   [self.delegate containerViewFooterDidChangeSize:newSize];
+  [_contentView updateBottomInset];
   if (@available(iOS 26.0, *)) {
     [self setupEdgeInteractions];
   }
@@ -310,10 +328,9 @@ using namespace facebook::react;
     return;
   }
 
-  if (_peekView != nil) {
-    RCTLogWarn(@"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 = nil;
 
   _peekView = peekView;
   peekView.delegate = self;

package/ios/TrueSheetContentView.h

@@ -69,10 +69,22 @@ NS_ASSUME_NONNULL_BEGIN
  * `automatic` while plugged so UIKit applies the bottom safe-area inset to
  * the scroll content. The previous behavior is restored on clear.
  */
-@property (nonatomic, assign) BOOL contentInsetAdjustment;
+@property (nonatomic, assign) BOOL safeAreaInsetAdjustment;
+
+/**
+ * Pads the resolved ScrollView's bottom content inset by the absolute
+ * footer's height so the last item scrolls into view above it. Stacks with
+ * the keyboard inset.
+ */
+@property (nonatomic, assign) BOOL footerInsetAdjustment;
 
 - (RCTScrollViewComponentView *_Nullable)findScrollView;
 
+/**
+ * Re-applies the footer and keyboard insets — call when the footer's size changes
+ */
+- (void)updateBottomInset;
+
 /**
  * Resolve the ScrollView from `scrollableHandle`, wiring keyboard handling
  */

package/ios/TrueSheetContentView.mm

@@ -30,7 +30,7 @@ using namespace facebook::react;
   CGFloat _appliedKeyboardOffset;
   BOOL _observingTextChanges;
   UIScrollViewContentInsetAdjustmentBehavior _originalInsetAdjustmentBehavior;
-  BOOL _appliedContentInsetAdjustment;
+  BOOL _appliedSafeAreaInsetAdjustment;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -69,29 +69,38 @@ using namespace facebook::react;
   [self clearScrollable];
 }
 
-- (void)setContentInsetAdjustment:(BOOL)contentInsetAdjustment {
-  if (_contentInsetAdjustment == contentInsetAdjustment) {
+- (void)setSafeAreaInsetAdjustment:(BOOL)safeAreaInsetAdjustment {
+  if (_safeAreaInsetAdjustment == safeAreaInsetAdjustment) {
     return;
   }
-  _contentInsetAdjustment = contentInsetAdjustment;
-  [self applyContentInsetAdjustment];
+  _safeAreaInsetAdjustment = safeAreaInsetAdjustment;
+  [self applySafeAreaInsetAdjustment];
+  [self updateBottomInset];
+}
+
+- (void)setFooterInsetAdjustment:(BOOL)footerInsetAdjustment {
+  if (_footerInsetAdjustment == footerInsetAdjustment) {
+    return;
+  }
+  _footerInsetAdjustment = footerInsetAdjustment;
+  [self updateBottomInset];
 }
 
 // Hands the bottom safe-area inset to UIKit — `automatic` only insets while
 // the content can scroll, which the Android counterpart mirrors manually.
-- (void)applyContentInsetAdjustment {
+- (void)applySafeAreaInsetAdjustment {
   if (!_detectedScrollView) {
     return;
   }
 
   UIScrollView *scrollView = _detectedScrollView.scrollView;
-  if (_contentInsetAdjustment && !_appliedContentInsetAdjustment) {
+  if (_safeAreaInsetAdjustment && !_appliedSafeAreaInsetAdjustment) {
     _originalInsetAdjustmentBehavior = scrollView.contentInsetAdjustmentBehavior;
     scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAutomatic;
-    _appliedContentInsetAdjustment = YES;
-  } else if (!_contentInsetAdjustment && _appliedContentInsetAdjustment) {
+    _appliedSafeAreaInsetAdjustment = YES;
+  } else if (!_safeAreaInsetAdjustment && _appliedSafeAreaInsetAdjustment) {
     scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
-    _appliedContentInsetAdjustment = NO;
+    _appliedSafeAreaInsetAdjustment = NO;
   }
 }
 
@@ -169,14 +178,16 @@ using namespace facebook::react;
     [self.delegate contentViewScrollViewDidChange];
   }
 
-  [self updateKeyboardInset];
+  // Layout has settled for the whole tree — the footer overlap (sheet height,
+  // scroll view frame) and the keyboard inset are current here
+  [self updateBottomInset];
 }
 
 #pragma mark - Scrollable
 
 // The scroll indicator follows automatically — UIKit derives its insets from
 // the content inset while `automaticallyAdjustsScrollIndicatorInsets` is set.
-- (void)setKeyboardInset:(CGFloat)inset {
+- (void)setBottomInset:(CGFloat)inset {
   if (!_detectedScrollView)
     return;
 
@@ -189,19 +200,57 @@ using namespace facebook::react;
   _detectedScrollView.scrollView.contentInset = contentInset;
 }
 
-- (void)updateKeyboardInset {
+// How much of the absolute footer covers the scroll view — measured from the
+// footer's layout position (pinned to the container's bottom edge; its
+// keyboard rise is a transform) so a short scroll view ending above the footer
+// gets no inset. UIKit stacks the safe area on top of contentInset while the
+// adjustment behavior is automatic — take out the inset baked into the
+// footer's height so the total lands on the footer's top edge. Stays constant
+// across keyboard transitions: the footer drops its inset as it rises, and
+// the baked value drops with it. A pinned footer adds only the overlap not
+// already covered by the keyboard inset.
+- (CGFloat)footerInsetAbove:(CGFloat)keyboardInset {
+  if (!_footerInsetAdjustment || !self.footerView || !_detectedScrollView) {
+    return 0;
+  }
+
+  UIView *container = self.footerView.superview;
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  CGRect scrollFrame = [scrollView convertRect:scrollView.bounds toView:container];
+  CGFloat footerTop = container.bounds.size.height - self.footerView.bounds.size.height;
+
+  CGFloat inset = CGRectGetMaxY(scrollFrame) - footerTop;
+  if (_appliedSafeAreaInsetAdjustment) {
+    inset -= self.footerView.appliedBottomInset;
+  }
+  if (!_keyboardObserver.viewController.footerAvoidsKeyboard) {
+    inset -= keyboardInset;
+  }
+  return MAX(0, inset);
+}
+
+- (CGFloat)keyboardInset {
   CGFloat keyboardHeight = _keyboardObserver.currentHeight;
-  if (_detectedScrollView && keyboardHeight > 0) {
-    [self setKeyboardInset:[self keyboardInsetWithHeight:keyboardHeight]];
+  return keyboardHeight > 0 ? [self keyboardInsetWithHeight:keyboardHeight] : 0;
+}
+
+// Safe to call mid keyboard animation: the target matches the animation's
+// model value (the footer inset doesn't change with the keyboard), so the
+// early-out in setBottomInset: leaves the animation alone.
+- (void)updateBottomInset {
+  if (!_detectedScrollView) {
+    return;
   }
+  CGFloat keyboardInset = [self keyboardInset];
+  [self setBottomInset:[self footerInsetAbove:keyboardInset] + keyboardInset];
 }
 
 - (void)clearScrollable {
-  [self setKeyboardInset:0];
+  [self setBottomInset:0];
   _appliedKeyboardOffset = 0;
-  if (_appliedContentInsetAdjustment) {
+  if (_appliedSafeAreaInsetAdjustment) {
     _detectedScrollView.scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
-    _appliedContentInsetAdjustment = NO;
+    _appliedSafeAreaInsetAdjustment = NO;
   }
   _detectedScrollView = nil;
 }
@@ -223,10 +272,10 @@ using namespace facebook::react;
 
   _detectedScrollView = scrollView;
 
-  [self applyContentInsetAdjustment];
+  [self applySafeAreaInsetAdjustment];
 
-  // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
-  [self updateKeyboardInset];
+  // Apply the footer inset, and the keyboard inset if it's currently showing
+  [self updateBottomInset];
 }
 
 // Short or nested scroll views can end above the sheet's bottom edge.
@@ -240,18 +289,21 @@ using namespace facebook::react;
 
   // UIKit stacks the safe area on top of contentInset while the adjustment
   // behavior is automatic — take it out so the total lands on the keyboard edge.
-  if (_appliedContentInsetAdjustment) {
+  if (_appliedSafeAreaInsetAdjustment) {
     inset = MAX(0, inset - scrollView.safeAreaInsets.bottom);
   }
 
   // Track how much of keyboardOffset actually lands in the inset so the caret
   // reveal can compensate — the offset shifts the inset, not the keyboard edge.
   CGFloat adjustedInset = MAX(0, inset + self.keyboardOffset);
-  _appliedKeyboardOffset = adjustedInset - inset;
-
-  // Content that already fits above the keyboard has nothing to reveal — the
-  // inset would only open blank scroll range below it (huge gap at the bottom).
-  if (scrollView.contentSize.height <= scrollView.bounds.size.height - adjustedInset) {
+  _appliedKeyboardOffset =
+    adjustedInset + [self footerInsetAbove:adjustedInset] - (inset + [self footerInsetAbove:inset]);
+
+  // Content that already fits above the keyboard (and footer) has nothing to
+  // reveal — the inset would only open blank scroll range below it (huge gap
+  // at the bottom).
+  if (scrollView.contentSize.height + [self footerInsetAbove:adjustedInset] <=
+      scrollView.bounds.size.height - adjustedInset) {
     _appliedKeyboardOffset = 0;
     return 0;
   }
@@ -260,9 +312,13 @@ using namespace facebook::react;
 }
 
 // An absolute footer floats over the viewport's bottom edge — extend the
-// caret target so it clears the footer, not just the keyboard.
+// caret target so it clears the footer, not just the keyboard. Not needed
+// while the footer inset is applied (the visible rect already ends above it)
+// or when the footer stays behind the keyboard.
 - (CGFloat)footerOcclusion {
-  if (self.footerView && _keyboardObserver.viewController.absoluteFooter) {
+  TrueSheetViewController *controller = _keyboardObserver.viewController;
+  if (self.footerView && controller.absoluteFooter && controller.footerAvoidsKeyboard &&
+      [self footerInsetAbove:0] <= 0) {
     return [self.footerView keyboardOcclusionHeight];
   }
   return 0;
@@ -340,15 +396,16 @@ using namespace facebook::react;
   TrueSheetViewController *sheetController = _keyboardObserver.viewController;
   UIView *firstResponder = sheetController ? [sheetController.view findFirstResponder] : nil;
 
-  CGFloat inset = [self keyboardInsetWithHeight:height];
+  CGFloat keyboardInset = [self keyboardInsetWithHeight:height];
+  CGFloat inset = [self footerInsetAbove:keyboardInset] + keyboardInset;
   [UIView animateWithDuration:duration
     delay:0
     options:curve | UIViewAnimationOptionBeginFromCurrentState
     animations:^{
-      [self setKeyboardInset:inset];
+      [self setBottomInset:inset];
     }
     completion:^(BOOL finished) {
-      [self updateKeyboardInset];
+      [self updateBottomInset];
     }];
 
   // Defer scroll until the next run loop so content insets are applied first
@@ -373,7 +430,7 @@ using namespace facebook::react;
   dispatch_async(dispatch_get_main_queue(), ^{
     // Typing can grow the content (e.g. a multiline input) past the fits-above-
     // the-keyboard threshold — keep the inset in sync before revealing the caret.
-    [self updateKeyboardInset];
+    [self updateBottomInset];
     [self scrollToFocusedCaretAnimated:YES];
   });
 }
@@ -422,7 +479,7 @@ using namespace facebook::react;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setKeyboardInset:0];
+                     [self setBottomInset:[self footerInsetAbove:0]];
                    }
                    completion:nil];
 }
@@ -435,7 +492,8 @@ using namespace facebook::react;
   [self clearScrollable];
   _state.reset();
   _scrollableHandle = 0;
-  _contentInsetAdjustment = NO;
+  _safeAreaInsetAdjustment = NO;
+  _footerInsetAdjustment = NO;
   _lastReportedNaturalHeight = 0;
 }
 

package/ios/TrueSheetFooterView.mm

@@ -155,6 +155,8 @@ using namespace facebook::react;
     _lastHeight = height;
     [self.delegate footerViewDidChangeSize:CGSizeMake(layoutMetrics.frame.size.width, height)];
   }
+
+  [self applyKeyboardOffset];
 }
 
 - (void)prepareForRecycle {
@@ -176,29 +178,50 @@ using namespace facebook::react;
 
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
+// Only an absolute footer floats above the keyboard — a relative footer stays
+// in the layout flow behind it, and an absolute one opts out via
+// footerOptions.avoidKeyboard.
+- (BOOL)floatsAboveKeyboard {
+  TrueSheetViewController *controller = self.keyboardObserver.viewController;
+  return controller.absoluteFooter && controller.footerAvoidsKeyboard;
+}
+
+- (CGFloat)keyboardSlideForHeight:(CGFloat)height {
+  UIWindow *window = self.window;
+  if (!window) {
+    return 0;
+  }
+
+  // Measure in the transform's coordinate space, excluding the footer's current slide.
+  CGFloat footerBottom = self.center.y + self.bounds.size.height / 2;
+  CGPoint keyboardTopInWindow = CGPointMake(CGRectGetMidX(window.bounds), CGRectGetMaxY(window.bounds) - height);
+  CGFloat keyboardTop = [self.superview convertPoint:keyboardTopInWindow fromView:window].y;
+  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
+  return MAX(0, footerBottom - keyboardTop + keyboardOffset);
+}
+
 // Yoga owns the footer's frame (pinned to the container's bottom edge), so the
-// keyboard slide is carried by a transform instead of layout. Only an absolute
-// footer floats above the keyboard — a relative footer stays in the layout
-// flow behind it.
+// keyboard slide is carried by a transform instead of layout.
 - (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!self.keyboardObserver.viewController.absoluteFooter) {
+  if (![self floatsAboveKeyboard]) {
     return;
   }
 
   [self setKeyboardVisible:YES];
 
-  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
-  CGFloat slide = MAX(0, height + keyboardOffset);
+  CGFloat slide = [self keyboardSlideForHeight:height];
   _currentKeyboardOffset = slide;
 
   [UIView animateWithDuration:duration
-                        delay:0
-                      options:curve | UIViewAnimationOptionBeginFromCurrentState
-                   animations:^{
-                     self.transform = CGAffineTransformMakeTranslation(0, -slide);
-                     [self syncEdgeEffect];
-                   }
-                   completion:nil];
+    delay:0
+    options:curve | UIViewAnimationOptionBeginFromCurrentState
+    animations:^{
+      self.transform = CGAffineTransformMakeTranslation(0, -slide);
+      [self syncEdgeEffect];
+    }
+    completion:^(BOOL finished) {
+      [self applyKeyboardOffset];
+    }];
 }
 
 - (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
@@ -232,14 +255,21 @@ using namespace facebook::react;
 
 - (void)applyKeyboardOffset {
   CGFloat height = self.keyboardObserver.currentHeight;
-  if (height <= 0 || !self.keyboardObserver.viewController.absoluteFooter) {
+  if (height <= 0) {
+    return;
+  }
+
+  // avoidKeyboard flipped off mid-keyboard — drop the slide already applied
+  if (![self floatsAboveKeyboard]) {
+    [self setKeyboardVisible:NO];
+    _currentKeyboardOffset = 0;
+    self.transform = CGAffineTransformIdentity;
     return;
   }
 
   [self setKeyboardVisible:YES];
 
-  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
-  CGFloat slide = MAX(0, height + keyboardOffset);
+  CGFloat slide = [self keyboardSlideForHeight:height];
   _currentKeyboardOffset = slide;
   self.transform = CGAffineTransformMakeTranslation(0, -slide);
 }