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

package/ios/TrueSheetContentView.mm

@@ -17,25 +17,21 @@
 #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 _appliedContentInsetAdjustment;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -52,15 +48,20 @@ 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
+// detected 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) {
@@ -69,19 +70,55 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   _scrollableBounded = bounded;
 
   if (_state) {
-    TrueSheetContentViewState newState;
+    auto newState = _state->getData();
     newState.scrollableBounded = bounded;
     _state->updateState(std::move(newState));
   }
 }
 
+- (void)setScrollableHandle:(NSInteger)scrollableHandle {
+  if (_scrollableHandle == scrollableHandle) {
+    return;
+  }
+  _scrollableHandle = scrollableHandle;
+
+  // Release the previously resolved ScrollView — setupScrollable re-resolves
+  [self clearScrollable];
+}
+
+- (void)setContentInsetAdjustment:(BOOL)contentInsetAdjustment {
+  if (_contentInsetAdjustment == contentInsetAdjustment) {
+    return;
+  }
+  _contentInsetAdjustment = contentInsetAdjustment;
+  [self applyContentInsetAdjustment];
+}
+
+// Hands the bottom safe-area inset to UIKit — `automatic` only insets while
+// the content can scroll, which the Android counterpart mirrors manually.
+- (void)applyContentInsetAdjustment {
+  if (!_detectedScrollView) {
+    return;
+  }
+
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  if (_contentInsetAdjustment && !_appliedContentInsetAdjustment) {
+    _originalInsetAdjustmentBehavior = scrollView.contentInsetAdjustmentBehavior;
+    scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAutomatic;
+    _appliedContentInsetAdjustment = YES;
+  } else if (!_contentInsetAdjustment && _appliedContentInsetAdjustment) {
+    scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedContentInsetAdjustment = NO;
+  }
+}
+
 - (void)setHasAutoDetent:(BOOL)hasAutoDetent {
   if (_hasAutoDetent == hasAutoDetent) {
     return;
   }
   _hasAutoDetent = hasAutoDetent;
 
-  if (_pinnedScrollView) {
+  if (_detectedScrollView) {
     [self setScrollableBounded:hasAutoDetent];
   }
 }
@@ -111,58 +148,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 +182,42 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 }
 
 - (void)checkScrollViewChanged {
-  if (!_pinnedScrollView || ![_pinnedScrollView isDescendantOfView:self]) {
+  if (!_detectedScrollView || ![_detectedScrollView isDescendantOfView:self]) {
     [self.delegate contentViewScrollViewDidChange];
   }
 }
 
 #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)setKeyboardInset:(CGFloat)inset {
+  if (!_detectedScrollView)
     return;
 
-  UIEdgeInsets contentInset = _pinnedScrollView.scrollView.contentInset;
-  contentInset.bottom = contentBottom;
-  _pinnedScrollView.scrollView.contentInset = contentInset;
-
-  UIEdgeInsets indicatorInsets = _pinnedScrollView.scrollView.verticalScrollIndicatorInsets;
-  indicatorInsets.bottom = indicatorBottom;
-  _pinnedScrollView.scrollView.verticalScrollIndicatorInsets = indicatorInsets;
+  UIEdgeInsets contentInset = _detectedScrollView.scrollView.contentInset;
+  contentInset.bottom = inset;
+  _detectedScrollView.scrollView.contentInset = contentInset;
 }
 
 - (void)clearScrollable {
-  if (_pinnedScrollView) {
-    [self setScrollViewContentInset:0 indicatorInset:_originalIndicatorBottomInset];
+  [self setKeyboardInset:0];
+  _appliedKeyboardOffset = 0;
+  if (_appliedContentInsetAdjustment) {
+    _detectedScrollView.scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedContentInsetAdjustment = 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 +226,75 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
     return;
   }
 
-  // Only capture originals on first pin
-  if (!_pinnedScrollView) {
-    _originalIndicatorBottomInset = scrollView.scrollView.verticalScrollIndicatorInsets.bottom;
-    _pinnedScrollView = scrollView;
+  _detectedScrollView = scrollView;
 
-    [self observeScrollViewContentSize];
-    [self setScrollableBounded:_hasAutoDetent];
-    [self reportSizeIfChanged];
-  }
-
-  _bottomInset = bottomInset;
-
-  [self setScrollViewContentInset:_bottomInset indicatorInset:_originalIndicatorBottomInset];
+  [self applyContentInsetAdjustment];
+  [self setScrollableBounded:_hasAutoDetent];
 
   // 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];
+    [self setKeyboardInset:[self keyboardInsetWithHeight:keyboardHeight]];
   }
 }
 
-// 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.
+// height shields that much of the keyboard's overlap. An absolute footer
+// floats within the viewport — its clearance is the content padding's job
+// (the caret reveal accounts for it, see footerOcclusion).
 - (CGFloat)keyboardInsetWithHeight:(CGFloat)height {
-  if (!self.footerView) {
-    return height;
-  }
-  if (_keyboardObserver.viewController.absoluteFooter) {
-    return height + [self.footerView keyboardOcclusionHeight];
+  CGFloat inset = height;
+  if (self.footerView && !_keyboardObserver.viewController.absoluteFooter) {
+    inset = MAX(0, height - self.footerView.frame.size.height);
   }
-  return MAX(0, height - self.footerView.frame.size.height);
-}
 
-// 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 (_appliedContentInsetAdjustment) {
+    inset = MAX(0, inset - _detectedScrollView.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 - 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).
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  if (scrollView.contentSize.height <= 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.
+- (CGFloat)footerOcclusion {
+  if (self.footerView && _keyboardObserver.viewController.absoluteFooter) {
+    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 +302,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 +342,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
 - (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!_pinnedScrollView) {
+  if (!_detectedScrollView) {
     return;
   }
 
@@ -385,7 +356,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setScrollViewContentInset:inset indicatorInset:self->_originalIndicatorBottomInset + inset];
+                     [self setKeyboardInset:inset];
                    }
                    completion:nil];
 
@@ -398,7 +369,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 }
 
 - (void)focusedInputTextDidChange:(NSNotification *)notification {
-  if (!_pinnedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
+  if (!_detectedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
     return;
   }
 
@@ -409,12 +380,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 setKeyboardInset:[self keyboardInsetWithHeight:self->_keyboardObserver.currentHeight]];
     [self scrollToFocusedCaretAnimated:YES];
   });
 }
 
 - (void)scrollToFocusedCaretAnimated:(BOOL)animated {
-  if (!_pinnedScrollView) {
+  if (!_detectedScrollView) {
     return;
   }
 
@@ -424,7 +398,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 +416,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 +431,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setScrollViewContentInset:self->_bottomInset
-                                      indicatorInset:self->_originalIndicatorBottomInset];
+                     [self setKeyboardInset:0];
                    }
                    completion:nil];
 }
@@ -471,8 +444,10 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   [self clearScrollable];
   _state.reset();
   _scrollableBounded = NO;
+  _scrollableHandle = 0;
+  _contentInsetAdjustment = NO;
   _hasAutoDetent = NO;
-  _lastSize = CGSizeZero;
+  _lastReportedNaturalHeight = 0;
 }
 
 @end

package/ios/TrueSheetFooterView.mm

@@ -196,6 +196,7 @@ using namespace facebook::react;
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
                      self.transform = CGAffineTransformMakeTranslation(0, -slide);
+                     [self syncEdgeEffect];
                    }
                    completion:nil];
 }
@@ -209,10 +210,26 @@ using namespace facebook::react;
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
                      self.transform = CGAffineTransformIdentity;
+                     [self syncEdgeEffect];
                    }
                    completion:nil];
 }
 
+// UIKit derives the edge effect region from model geometry at commit time,
+// outside our animation context — the blur snaps to the footer's final
+// position while the footer is still animating. Re-evaluating the scroll
+// view's layout inside the animation block makes the region change inherit
+// the keyboard curve.
+- (void)syncEdgeEffect {
+  if (@available(iOS 26.0, *)) {
+    UIScrollView *scrollView = [self edgeInteractionScrollView];
+    if (scrollView) {
+      [scrollView setNeedsLayout];
+      [scrollView layoutIfNeeded];
+    }
+  }
+}
+
 - (void)applyKeyboardOffset {
   CGFloat height = self.keyboardObserver.currentHeight;
   if (height <= 0 || !self.keyboardObserver.viewController.absoluteFooter) {

package/ios/TrueSheetView.mm

@@ -53,6 +53,7 @@ using namespace facebook::react;
   NSInteger _initialDetentIndex;
   TrueSheetViewInsetAdjustment _insetAdjustment;
   ScrollableOptions *_scrollableOptions;
+  NSInteger _scrollableHandle;
   BOOL _hasAutoDetent;
   BOOL _initialDetentAnimated;
   BOOL _isSheetUpdatePending;
@@ -277,17 +278,23 @@ using namespace facebook::react;
   _initialDetentIndex = newProps.initialDetentIndex;
   _initialDetentAnimated = newProps.initialDetentAnimated;
 
+  _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 || !scrollingExpandsSheet ||
+  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;
@@ -502,7 +509,7 @@ using namespace facebook::react;
   [_controller setupSheetSizing];
   [_controller setupSheetProps];
 
-  // Pin before measuring so a first-time pin doesn't shift sizes mid-animation.
+  // Detect before measuring so a first-time detection doesn't shift sizes mid-animation.
   [self setupScrollable];
 
   // Measure synchronously so the presentation starts at the right height —
@@ -671,7 +678,7 @@ using namespace facebook::react;
   [self setupSheetDetentsForSizeChange];
 }
 
-// When the ScrollView changes (e.g. conditional remount), re-pin the new ScrollView.
+// When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView.
 - (void)containerViewScrollViewDidChange {
   [self setupScrollable];
 }
@@ -822,8 +829,10 @@ using namespace facebook::react;
   if (!_containerView)
     return;
 
-  _containerView.insetAdjustment = _insetAdjustment;
   _containerView.scrollableOptions = _scrollableOptions;
+  _containerView.scrollableHandle = _scrollableHandle;
+  _containerView.contentInsetAdjustment = (_scrollableOptions ? _scrollableOptions.contentInsetAdjustment : YES) &&
+                                          _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
   _containerView.hasAutoDetent = _hasAutoDetent;
   [self refreshFooterBottomInset];
   [_containerView setupScrollable];

package/ios/utils/UIView+ScrollEdgeInteraction.h

@@ -17,6 +17,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setupEdgeInteractionWithScrollView:(nullable UIScrollView *)scrollView
                                       edge:(UIRectEdge)edge API_AVAILABLE(ios(26.0));
 - (void)cleanupEdgeInteraction API_AVAILABLE(ios(26.0));
+- (nullable UIScrollView *)edgeInteractionScrollView API_AVAILABLE(ios(26.0));
 
 @end
 

package/ios/utils/UIView+ScrollEdgeInteraction.mm

@@ -31,15 +31,37 @@ static const void *kEdgeEffectHintKey = &kEdgeEffectHintKey;
   objc_setAssociatedObject(self, kEdgeEffectHintKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 }
 
+- (nullable UIScrollView *)edgeInteractionScrollView API_AVAILABLE(ios(26.0)) {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+  for (id<UIInteraction> interaction in self.interactions) {
+    if ([interaction isKindOfClass:[UIScrollEdgeElementContainerInteraction class]]) {
+      return ((UIScrollEdgeElementContainerInteraction *)interaction).scrollView;
+    }
+  }
+#endif
+  return nil;
+}
+
 - (void)setupEdgeInteractionWithScrollView:(nullable UIScrollView *)scrollView
                                       edge:(UIRectEdge)edge API_AVAILABLE(ios(26.0)) {
-  [self cleanupEdgeInteraction];
-
   if (!scrollView) {
+    [self cleanupEdgeInteraction];
     return;
   }
 
 #if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+  // Update in place — this re-runs on every footer/header size change, and
+  // tearing the interaction down mid keyboard animation flashes the edge
+  // effect at the footer's final position.
+  for (id<UIInteraction> interaction in self.interactions) {
+    if ([interaction isKindOfClass:[UIScrollEdgeElementContainerInteraction class]]) {
+      UIScrollEdgeElementContainerInteraction *existing = (UIScrollEdgeElementContainerInteraction *)interaction;
+      existing.scrollView = scrollView;
+      existing.edge = edge;
+      return;
+    }
+  }
+
   // UIScrollEdgeElementContainerInteraction requires standard UIKit element
   // descendants (UILabel, UIControl, etc.) to trigger the edge effect.
   // RCTViewComponentView subviews are not recognized, so we add a