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

package/ios/TrueSheetContentView.mm

@@ -17,25 +17,20 @@
 #import <react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.h>
 #import "TrueSheetContainerView.h"
 #import "TrueSheetFooterView.h"
-#import "TrueSheetView.h"
 #import "TrueSheetViewController.h"
 #import "utils/PlatformUtil.h"
 #import "utils/UIView+FirstResponder.h"
 
 using namespace facebook::react;
 
-static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
-
 @implementation TrueSheetContentView {
   TrueSheetContentViewShadowNode::ConcreteState::Shared _state;
-  RCTScrollViewComponentView *_pinnedScrollView;
-  UIScrollView *_observedScrollView;
-  CGSize _lastSize;
-  CGFloat _bottomInset;
-  CGFloat _originalIndicatorBottomInset;
+  RCTScrollViewComponentView *_detectedScrollView;
+  CGFloat _lastReportedNaturalHeight;
+  CGFloat _appliedKeyboardOffset;
   BOOL _observingTextChanges;
-  BOOL _scrollableBounded;
-  BOOL _isReportPending;
+  UIScrollViewContentInsetAdjustmentBehavior _originalInsetAdjustmentBehavior;
+  BOOL _appliedSafeAreaInsetAdjustment;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -52,37 +47,60 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 
 - (void)dealloc {
   [self stopObservingTextChanges];
-  [self unobserveScrollViewContentSize];
 }
 
 - (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState {
   _state = std::static_pointer_cast<TrueSheetContentViewShadowNode::ConcreteState const>(state);
+
+  CGFloat naturalHeight = _state->getData().naturalHeight;
+  if (naturalHeight != _lastReportedNaturalHeight) {
+    _lastReportedNaturalHeight = naturalHeight;
+    [self.delegate contentViewDidChangeSize:CGSizeMake(self.frame.size.width, naturalHeight)];
+  }
 }
 
-// Tells the shadow node to fill the container (flexGrow/flexShrink) so the
-// pinned ScrollView's viewport is bounded to the visible space. Only applied
-// for auto detents — otherwise content lays out naturally like a regular view.
-- (void)setScrollableBounded:(BOOL)bounded {
-  if (_scrollableBounded == bounded) {
+- (void)setScrollableHandle:(NSInteger)scrollableHandle {
+  if (_scrollableHandle == scrollableHandle) {
     return;
   }
-  _scrollableBounded = bounded;
+  _scrollableHandle = scrollableHandle;
 
-  if (_state) {
-    TrueSheetContentViewState newState;
-    newState.scrollableBounded = bounded;
-    _state->updateState(std::move(newState));
+  // Release the previously resolved ScrollView — setupScrollable re-resolves
+  [self clearScrollable];
+}
+
+- (void)setSafeAreaInsetAdjustment:(BOOL)safeAreaInsetAdjustment {
+  if (_safeAreaInsetAdjustment == safeAreaInsetAdjustment) {
+    return;
+  }
+  _safeAreaInsetAdjustment = safeAreaInsetAdjustment;
+  [self applySafeAreaInsetAdjustment];
+  [self updateBottomInset];
+}
+
+- (void)setFooterInsetAdjustment:(BOOL)footerInsetAdjustment {
+  if (_footerInsetAdjustment == footerInsetAdjustment) {
+    return;
   }
+  _footerInsetAdjustment = footerInsetAdjustment;
+  [self updateBottomInset];
 }
 
-- (void)setHasAutoDetent:(BOOL)hasAutoDetent {
-  if (_hasAutoDetent == hasAutoDetent) {
+// Hands the bottom safe-area inset to UIKit — `automatic` only insets while
+// the content can scroll, which the Android counterpart mirrors manually.
+- (void)applySafeAreaInsetAdjustment {
+  if (!_detectedScrollView) {
     return;
   }
-  _hasAutoDetent = hasAutoDetent;
 
-  if (_pinnedScrollView) {
-    [self setScrollableBounded:hasAutoDetent];
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  if (_safeAreaInsetAdjustment && !_appliedSafeAreaInsetAdjustment) {
+    _originalInsetAdjustmentBehavior = scrollView.contentInsetAdjustmentBehavior;
+    scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAutomatic;
+    _appliedSafeAreaInsetAdjustment = YES;
+  } else if (!_safeAreaInsetAdjustment && _appliedSafeAreaInsetAdjustment) {
+    scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedSafeAreaInsetAdjustment = NO;
   }
 }
 
@@ -111,58 +129,25 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 #pragma mark - Layout
 
 - (CGFloat)naturalHeight {
-  CGFloat height = self.frame.size.height;
-  if (_pinnedScrollView) {
-    height += _pinnedScrollView.scrollView.contentSize.height - _pinnedScrollView.frame.size.height;
-  }
-  return MAX(0, height);
-}
-
-- (void)reportSizeIfChanged {
-  // A deep ScrollView unmount doesn't pass through this view's mount hooks —
-  // detect the stale pin here so it (and its contentSize observation) is
-  // released instead of lingering until the next explicit setup or recycle.
-  if (_pinnedScrollView && ![_pinnedScrollView isDescendantOfView:self]) {
-    [self.delegate contentViewScrollViewDidChange];
-  }
-
-  // naturalHeight mixes frames from different views; mid-transaction they're
-  // momentarily inconsistent (parent updates before the ScrollView), which
-  // feeds back into the auto detent and oscillates. Coalesce to the next
-  // main-queue tick so frames are settled before measuring.
-  if (_pinnedScrollView) {
-    if (_isReportPending) {
-      return;
+  if (_state) {
+    CGFloat height = _state->getData().naturalHeight;
+    if (height > 0) {
+      return height;
     }
-    _isReportPending = YES;
-
-    __weak __typeof(self) weakSelf = self;
-    dispatch_async(dispatch_get_main_queue(), ^{
-      __typeof(self) strongSelf = weakSelf;
-      if (!strongSelf) {
-        return;
-      }
-      strongSelf->_isReportPending = NO;
-      [strongSelf reportSizeNow];
-    });
-    return;
-  }
-
-  [self reportSizeNow];
-}
-
-- (void)reportSizeNow {
-  CGSize newSize = CGSizeMake(self.frame.size.width, self.naturalHeight);
-  if (!CGSizeEqualToSize(newSize, _lastSize)) {
-    _lastSize = newSize;
-    [self.delegate contentViewDidChangeSize:newSize];
   }
+  return self.frame.size.height;
 }
 
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
            oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
-  [self reportSizeIfChanged];
+
+  // A deep ScrollView unmount doesn't pass through this view's mount hooks —
+  // detect the stale reference here so it's released instead of lingering until the
+  // next explicit setup or recycle.
+  if (_detectedScrollView && ![_detectedScrollView isDescendantOfView:self]) {
+    [self.delegate contentViewScrollViewDidChange];
+  }
 }
 
 #pragma mark - Child Mounting
@@ -178,46 +163,105 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 }
 
 - (void)checkScrollViewChanged {
-  if (!_pinnedScrollView || ![_pinnedScrollView isDescendantOfView:self]) {
+  if (!_detectedScrollView || ![_detectedScrollView isDescendantOfView:self]) {
+    [self.delegate contentViewScrollViewDidChange];
+  }
+}
+
+// A handle that commits in the same transaction as the ScrollView's insertion
+// resolves to nothing — prop updates process before mount instructions, and a
+// deep insertion doesn't pass through this view's mount hooks. Retry once the
+// whole transaction has mounted.
+- (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
+               withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry {
+  if (_scrollableHandle > 0 && !_detectedScrollView) {
     [self.delegate contentViewScrollViewDidChange];
   }
+
+  // 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
 
-- (void)setScrollViewContentInset:(CGFloat)contentBottom indicatorInset:(CGFloat)indicatorBottom {
-  if (!_pinnedScrollView)
+// The scroll indicator follows automatically — UIKit derives its insets from
+// the content inset while `automaticallyAdjustsScrollIndicatorInsets` is set.
+- (void)setBottomInset:(CGFloat)inset {
+  if (!_detectedScrollView)
     return;
 
-  UIEdgeInsets contentInset = _pinnedScrollView.scrollView.contentInset;
-  contentInset.bottom = contentBottom;
-  _pinnedScrollView.scrollView.contentInset = contentInset;
+  UIEdgeInsets contentInset = _detectedScrollView.scrollView.contentInset;
+  if (fabs(contentInset.bottom - inset) < 0.001) {
+    return;
+  }
 
-  UIEdgeInsets indicatorInsets = _pinnedScrollView.scrollView.verticalScrollIndicatorInsets;
-  indicatorInsets.bottom = indicatorBottom;
-  _pinnedScrollView.scrollView.verticalScrollIndicatorInsets = indicatorInsets;
+  contentInset.bottom = inset;
+  _detectedScrollView.scrollView.contentInset = contentInset;
+}
+
+// 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;
+  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 {
-  if (_pinnedScrollView) {
-    [self setScrollViewContentInset:0 indicatorInset:_originalIndicatorBottomInset];
+  [self setBottomInset:0];
+  _appliedKeyboardOffset = 0;
+  if (_appliedSafeAreaInsetAdjustment) {
+    _detectedScrollView.scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedSafeAreaInsetAdjustment = NO;
   }
-  [self unobserveScrollViewContentSize];
-  [self setScrollableBounded:NO];
-  _pinnedScrollView = nil;
-  _bottomInset = 0;
-  _originalIndicatorBottomInset = 0;
-  [self reportSizeIfChanged];
+  _detectedScrollView = nil;
 }
 
-- (void)setupScrollableWithBottomInset:(CGFloat)bottomInset {
-  // Check if pinned scroll view is still valid (still in view hierarchy)
-  if (_pinnedScrollView && ![_pinnedScrollView isDescendantOfView:self]) {
+- (void)setupScrollable {
+  // Check if the detected scroll view is still valid (still in view hierarchy)
+  if (_detectedScrollView && ![_detectedScrollView isDescendantOfView:self]) {
     [self clearScrollable];
   }
 
-  // Already set up with same inset and valid scroll view
-  if (_pinnedScrollView && _bottomInset == bottomInset) {
+  if (_detectedScrollView) {
     return;
   }
 
@@ -226,104 +270,76 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
     return;
   }
 
-  // Only capture originals on first pin
-  if (!_pinnedScrollView) {
-    _originalIndicatorBottomInset = scrollView.scrollView.verticalScrollIndicatorInsets.bottom;
-    _pinnedScrollView = scrollView;
-
-    [self observeScrollViewContentSize];
-    [self setScrollableBounded:_hasAutoDetent];
-    [self reportSizeIfChanged];
-  }
-
-  _bottomInset = bottomInset;
+  _detectedScrollView = scrollView;
 
-  [self setScrollViewContentInset:_bottomInset indicatorInset:_originalIndicatorBottomInset];
+  [self applySafeAreaInsetAdjustment];
 
-  // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
-  CGFloat keyboardHeight = _keyboardObserver ? _keyboardObserver.currentHeight : 0;
-  if (keyboardHeight > 0) {
-    CGFloat inset = [self keyboardInsetWithHeight:keyboardHeight];
-    [self setScrollViewContentInset:inset indicatorInset:_originalIndicatorBottomInset + inset];
-  }
+  // Apply the footer inset, and the keyboard inset if it's currently showing
+  [self updateBottomInset];
 }
 
-// An absolute footer rises above the keyboard and covers the content's bottom
-// edge — include it so the caret clears the footer, not just the keyboard.
-// A relative footer stays behind the keyboard below the content, so its
-// height shields that much of the keyboard's overlap.
+// Short or nested scroll views can end above the sheet's bottom edge.
+// Their frame also accounts for space occupied by a relative footer.
 - (CGFloat)keyboardInsetWithHeight:(CGFloat)height {
-  if (!self.footerView) {
-    return height;
-  }
-  if (_keyboardObserver.viewController.absoluteFooter) {
-    return height + [self.footerView keyboardOcclusionHeight];
-  }
-  return MAX(0, height - self.footerView.frame.size.height);
-}
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  UIWindow *window = scrollView.window;
+  CGRect scrollFrame = [scrollView convertRect:scrollView.bounds toView:window];
+  CGFloat keyboardTop = CGRectGetMaxY(window.bounds) - height;
+  CGFloat inset = MAX(0, CGRectGetMaxY(scrollFrame) - keyboardTop);
 
-// Content growth is invisible to layout once the viewport is bounded, so track
-// the scroll content size directly to keep the auto detent height in sync.
-- (void)observeScrollViewContentSize {
-  UIScrollView *scrollView = _pinnedScrollView.scrollView;
-  if (_observedScrollView == scrollView) {
-    return;
+  // 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 (_appliedSafeAreaInsetAdjustment) {
+    inset = MAX(0, inset - scrollView.safeAreaInsets.bottom);
   }
-  [self unobserveScrollViewContentSize];
-  _observedScrollView = scrollView;
-  [scrollView addObserver:self
-               forKeyPath:@"contentSize"
-                  options:NSKeyValueObservingOptionNew
-                  context:TrueSheetContentSizeContext];
-}
 
-- (void)unobserveScrollViewContentSize {
-  if (_observedScrollView) {
-    [_observedScrollView removeObserver:self forKeyPath:@"contentSize" context:TrueSheetContentSizeContext];
-    _observedScrollView = nil;
+  // 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 + [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;
   }
+
+  return adjustedInset;
 }
 
-- (void)observeValueForKeyPath:(NSString *)keyPath
-                      ofObject:(id)object
-                        change:(NSDictionary *)change
-                       context:(void *)context {
-  if (context == TrueSheetContentSizeContext) {
-    [self reportSizeIfChanged];
-    return;
+// An absolute footer floats over the viewport's bottom edge — extend the
+// 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 {
+  TrueSheetViewController *controller = _keyboardObserver.viewController;
+  if (self.footerView && controller.absoluteFooter && controller.footerAvoidsKeyboard &&
+      [self footerInsetAbove:0] <= 0) {
+    return [self.footerView keyboardOcclusionHeight];
   }
-  [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
+  return 0;
 }
 
+// Resolves the user-provided `scrollableHandle` within the content subtree —
+// Fabric component views carry their React tag as `UIView.tag`.
 - (RCTScrollViewComponentView *)findScrollView {
-  if (_pinnedScrollView) {
-    return _pinnedScrollView;
+  if (_detectedScrollView) {
+    return _detectedScrollView;
   }
 
-  if (self.subviews.count == 0) {
+  if (_scrollableHandle <= 0) {
     return nil;
   }
 
-  RCTScrollViewComponentView *scrollView = [self findScrollViewInSubviews:self.subviews];
-
-  if (!scrollView) {
-    for (UIView *subview in self.subviews) {
-      scrollView = [self findScrollViewInSubviews:subview.subviews];
-      if (scrollView) {
-        break;
-      }
-    }
+  UIView *view = [self viewWithTag:_scrollableHandle];
+  if ([view isKindOfClass:RCTScrollViewComponentView.class]) {
+    return (RCTScrollViewComponentView *)view;
   }
 
-  return scrollView;
-}
-
-- (RCTScrollViewComponentView *)findScrollViewInSubviews:(NSArray<UIView *> *)subviews {
-  for (UIView *subview in subviews) {
-    if ([subview isKindOfClass:RCTScrollViewComponentView.class] && ![subview isKindOfClass:TrueSheetView.class]) {
-      return (RCTScrollViewComponentView *)subview;
-    }
-  }
   return nil;
 }
 
@@ -331,11 +347,11 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 
 - (void)applyScrollEdgeEffects:(nullable ScrollableOptions *)options {
 #if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_0)
-  if (!_pinnedScrollView)
+  if (!_detectedScrollView)
     return;
 
   if (@available(iOS 26.0, *)) {
-    UIScrollView *scrollView = _pinnedScrollView.scrollView;
+    UIScrollView *scrollView = _detectedScrollView.scrollView;
     auto topEffect = options ? options.topScrollEdgeEffect : TrueSheetViewTopScrollEdgeEffect::Hidden;
     auto bottomEffect = options ? options.bottomScrollEdgeEffect : TrueSheetViewBottomScrollEdgeEffect::Hidden;
 
@@ -371,7 +387,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
 - (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!_pinnedScrollView) {
+  if (!_detectedScrollView) {
     return;
   }
 
@@ -380,14 +396,17 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   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 setScrollViewContentInset:inset indicatorInset:self->_originalIndicatorBottomInset + inset];
-                   }
-                   completion:nil];
+    delay:0
+    options:curve | UIViewAnimationOptionBeginFromCurrentState
+    animations:^{
+      [self setBottomInset:inset];
+    }
+    completion:^(BOOL finished) {
+      [self updateBottomInset];
+    }];
 
   // Defer scroll until the next run loop so content insets are applied first
   if (firstResponder) {
@@ -398,7 +417,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 }
 
 - (void)focusedInputTextDidChange:(NSNotification *)notification {
-  if (!_pinnedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
+  if (!_detectedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
     return;
   }
 
@@ -409,12 +428,15 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   }
 
   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 updateBottomInset];
     [self scrollToFocusedCaretAnimated:YES];
   });
 }
 
 - (void)scrollToFocusedCaretAnimated:(BOOL)animated {
-  if (!_pinnedScrollView) {
+  if (!_detectedScrollView) {
     return;
   }
 
@@ -424,7 +446,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
     return;
   }
 
-  UIScrollView *scrollView = _pinnedScrollView.scrollView;
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
   CGRect targetRect = [firstResponder convertRect:firstResponder.bounds toView:scrollView];
 
   if ([firstResponder conformsToProtocol:@protocol(UITextInput)]) {
@@ -442,14 +464,14 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
     }
   }
 
-  targetRect.size.height += self.keyboardScrollOffset;
+  targetRect.size.height += self.keyboardScrollOffset + [self footerOcclusion] - _appliedKeyboardOffset;
   [scrollView scrollRectToVisible:targetRect animated:animated];
 }
 
 - (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
   [self stopObservingTextChanges];
 
-  if (!_pinnedScrollView) {
+  if (!_detectedScrollView) {
     return;
   }
 
@@ -457,8 +479,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setScrollViewContentInset:self->_bottomInset
-                                      indicatorInset:self->_originalIndicatorBottomInset];
+                     [self setBottomInset:[self footerInsetAbove:0]];
                    }
                    completion:nil];
 }
@@ -470,9 +491,10 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   [self stopObservingTextChanges];
   [self clearScrollable];
   _state.reset();
-  _scrollableBounded = NO;
-  _hasAutoDetent = NO;
-  _lastSize = CGSizeZero;
+  _scrollableHandle = 0;
+  _safeAreaInsetAdjustment = NO;
+  _footerInsetAdjustment = NO;
+  _lastReportedNaturalHeight = 0;
 }
 
 @end

package/ios/TrueSheetFooterView.h

@@ -27,6 +27,12 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak, nullable) TrueSheetKeyboardObserver *keyboardObserver;
 @property (nonatomic, weak, nullable) id<TrueSheetFooterViewDelegate> delegate;
 
+/**
+ * Bottom inset currently baked into the footer's layout height — pairs with
+ * the measured frame so detent math can subtract exactly what's baked in.
+ */
+@property (nonatomic, readonly) CGFloat appliedBottomInset;
+
 /**
  * Re-applies the footer's keyboard slide using the current keyboard height.
  * No-op when the keyboard is hidden. Used to reflect live `keyboardOffset` changes.