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

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

@@ -176,12 +176,18 @@ 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;
+}
+
 // 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;
   }
 
@@ -232,7 +238,15 @@ 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;
   }
 

package/ios/TrueSheetView.mm

@@ -244,6 +244,8 @@ using namespace facebook::react;
   _controller.blurIntensity = blurOpts.intensity >= 0 ? @(blurOpts.intensity) : nil;
   _controller.blurInteraction = blurOpts.interaction;
 
+  _controller.glass = newProps.glass;
+
   // Corner radius
   _controller.cornerRadius = newProps.cornerRadius < 0 ? nil : @(newProps.cornerRadius);
 
@@ -253,8 +255,7 @@ using namespace facebook::react;
   // Content width
   _controller.maxContentWidth = newProps.maxContentWidth != 0.0 ? @(newProps.maxContentWidth) : nil;
 
-  // Anchor
-  _controller.anchor = newProps.anchor;
+  _controller.placement = newProps.placement;
 
   _controller.grabber = newProps.grabber;
 
@@ -300,36 +301,35 @@ using namespace facebook::react;
   _scrollableHandle = newProps.scrollableHandle;
 
   const auto &scrollableOpts = newProps.scrollableOptions;
-  BOOL scrollingExpandsSheet = scrollableOpts.scrollingExpandsSheet;
-  BOOL contentInsetAdjustment = scrollableOpts.contentInsetAdjustmentBehavior;
-  auto topEdgeEffect = scrollableOpts.topScrollEdgeEffect;
-  auto bottomEdgeEffect = scrollableOpts.bottomScrollEdgeEffect;
-  BOOL hasScrollableOptions = scrollableOpts.keyboardScrollOffset > 0 || scrollableOpts.keyboardOffset != 0 ||
-                              !scrollingExpandsSheet || !contentInsetAdjustment ||
-                              topEdgeEffect != TrueSheetViewTopScrollEdgeEffect::Hidden ||
-                              bottomEdgeEffect != TrueSheetViewBottomScrollEdgeEffect::Hidden;
-
-  if (hasScrollableOptions) {
-    ScrollableOptions *options = [[ScrollableOptions alloc] init];
-    options.contentInsetAdjustment = contentInsetAdjustment;
-    options.keyboardScrollOffset = scrollableOpts.keyboardScrollOffset;
-    options.keyboardOffset = scrollableOpts.keyboardOffset;
-    options.scrollingExpandsSheet = scrollingExpandsSheet;
-    options.topScrollEdgeEffect = topEdgeEffect;
-    options.bottomScrollEdgeEffect = bottomEdgeEffect;
-    _scrollableOptions = options;
-  } else {
-    _scrollableOptions = nil;
-  }
-
-  _controller.scrollingExpandsSheet = scrollingExpandsSheet;
+  ScrollableOptions *options = [[ScrollableOptions alloc] init];
+  options.contentInsetAdjustment = scrollableOpts.contentInsetAdjustment;
+  options.keyboardScrollOffset = scrollableOpts.keyboardScrollOffset;
+  options.keyboardOffset = scrollableOpts.keyboardOffset;
+  options.scrollingExpandsSheet = scrollableOpts.scrollingExpandsSheet;
+  options.topScrollEdgeEffect = scrollableOpts.topScrollEdgeEffect;
+  options.bottomScrollEdgeEffect = scrollableOpts.bottomScrollEdgeEffect;
+
+  // nil while every option is at its default
+  BOOL hasScrollableOptions = options.keyboardScrollOffset > 0 || options.keyboardOffset != 0 ||
+                              !options.scrollingExpandsSheet ||
+                              options.contentInsetAdjustment != TrueSheetViewContentInsetAdjustment::Automatic ||
+                              options.topScrollEdgeEffect != TrueSheetViewTopScrollEdgeEffect::Hidden ||
+                              options.bottomScrollEdgeEffect != TrueSheetViewBottomScrollEdgeEffect::Hidden;
+  _scrollableOptions = hasScrollableOptions ? options : nil;
+
+  _controller.scrollingExpandsSheet = options.scrollingExpandsSheet;
 
   _controller.absoluteHeader = newProps.headerOptions.position == TrueSheetViewPosition::Absolute;
   _controller.absoluteFooter = newProps.footerOptions.footerPosition == TrueSheetViewFooterPosition::Absolute;
+  _controller.footerInsetAdjustment =
+    options.footerInsetAdjustment && _controller.absoluteFooter && _scrollableHandle > 0;
 
   CGFloat footerKeyboardOffset = newProps.footerOptions.keyboardOffset;
-  if (_controller.footerKeyboardOffset != footerKeyboardOffset) {
+  BOOL footerAvoidsKeyboard = newProps.footerOptions.avoidKeyboard;
+  if (_controller.footerKeyboardOffset != footerKeyboardOffset ||
+      _controller.footerAvoidsKeyboard != footerAvoidsKeyboard) {
     _controller.footerKeyboardOffset = footerKeyboardOffset;
+    _controller.footerAvoidsKeyboard = footerAvoidsKeyboard;
     [_containerView updateFooterKeyboardOffset];
   }
 
@@ -900,8 +900,9 @@ using namespace facebook::react;
 
   _containerView.scrollableOptions = _scrollableOptions;
   _containerView.scrollableHandle = _scrollableHandle;
-  _containerView.contentInsetAdjustment = (_scrollableOptions ? _scrollableOptions.contentInsetAdjustment : YES) &&
-                                          _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  _containerView.safeAreaInsetAdjustment = (_scrollableOptions ? _scrollableOptions.safeAreaInsetAdjustment : YES) &&
+                                           _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  _containerView.footerInsetAdjustment = _controller.footerInsetAdjustment;
   [self refreshFooterBottomInset];
   [_containerView setupScrollable];
 }

package/ios/TrueSheetViewController.h

@@ -62,6 +62,13 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL absoluteHeader;
 @property (nonatomic, strong, nullable) NSNumber *footerHeight;
 @property (nonatomic, assign) BOOL absoluteFooter;
+
+/**
+ * YES while the plugged scrollable is padded by the absolute footer's height
+ * (see ScrollableOptions.contentInsetAdjustment) — the footer then counts
+ * toward the auto detent like a relative one, so the content ends above it.
+ */
+@property (nonatomic, assign) BOOL footerInsetAdjustment;
 @property (nonatomic, strong, nullable) NSNumber *peekContentHeight;
 @property (nonatomic, strong, nullable) UIColor *backgroundColor;
 @property (nonatomic, strong, nullable) NSNumber *cornerRadius;
@@ -74,11 +81,18 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) facebook::react::TrueSheetViewBackgroundBlur backgroundBlur;
 @property (nonatomic, strong, nullable) NSNumber *blurIntensity;
 @property (nonatomic, assign) BOOL blurInteraction;
+@property (nonatomic, assign) BOOL glass;
 @property (nonatomic, assign) facebook::react::TrueSheetViewPresentation presentation;
-@property (nonatomic, assign) facebook::react::TrueSheetViewAnchor anchor;
+@property (nonatomic, assign) facebook::react::TrueSheetViewPlacement placement;
 @property (nonatomic, assign) facebook::react::TrueSheetViewInsetAdjustment insetAdjustment;
 @property (nonatomic, assign) BOOL scrollingExpandsSheet;
 @property (nonatomic, assign) CGFloat footerKeyboardOffset;
+
+/**
+ * NO keeps an absolute footer pinned to the sheet's bottom edge behind the
+ * keyboard instead of rising above it.
+ */
+@property (nonatomic, assign) BOOL footerAvoidsKeyboard;
 @property (nonatomic, assign) BOOL dismissible;
 @property (nonatomic, assign) BOOL isPresented;
 @property (nonatomic, assign) NSInteger activeDetentIndex;
@@ -89,6 +103,12 @@ NS_ASSUME_NONNULL_BEGIN
  * ~keyboardHeight into the learned offset.
  */
 @property (nonatomic, assign) BOOL keyboardSheetGrown;
+
+/**
+ * Target keyboard height, set as soon as the keyboard frame change is
+ * announced — ahead of the grow/shrink animation, unlike keyboardSheetGrown.
+ */
+@property (nonatomic, assign) CGFloat keyboardHeight;
 @property (nonatomic, readonly) BOOL isTopmostPresentedController;
 @property (nonatomic, readonly) BOOL isStackedBehindChild;
 @property (nonatomic, weak, nullable) UIView *accessibilityContentView;