@lodev09/react-native-true-sheet 4.0.0-beta.1 → 4.0.0-beta.10

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 _appliedContentInsetAdjustment;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -52,37 +47,51 @@ 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)setContentInsetAdjustment:(BOOL)contentInsetAdjustment {
+  if (_contentInsetAdjustment == contentInsetAdjustment) {
+    return;
   }
+  _contentInsetAdjustment = contentInsetAdjustment;
+  [self applyContentInsetAdjustment];
 }
 
-- (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)applyContentInsetAdjustment {
+  if (!_detectedScrollView) {
     return;
   }
-  _hasAutoDetent = hasAutoDetent;
 
-  if (_pinnedScrollView) {
-    [self setScrollableBounded:hasAutoDetent];
+  UIScrollView *scrollView = _detectedScrollView.scrollView;
+  if (_contentInsetAdjustment && !_appliedContentInsetAdjustment) {
+    _originalInsetAdjustmentBehavior = scrollView.contentInsetAdjustmentBehavior;
+    scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentAutomatic;
+    _appliedContentInsetAdjustment = YES;
+  } else if (!_contentInsetAdjustment && _appliedContentInsetAdjustment) {
+    scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedContentInsetAdjustment = NO;
   }
 }
 
@@ -111,58 +120,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 +154,52 @@ 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];
   }
 }
 
 #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 unobserveScrollViewContentSize];
-  [self setScrollableBounded:NO];
-  _pinnedScrollView = nil;
-  _bottomInset = 0;
-  _originalIndicatorBottomInset = 0;
-  [self reportSizeIfChanged];
+  [self setKeyboardInset:0];
+  _appliedKeyboardOffset = 0;
+  if (_appliedContentInsetAdjustment) {
+    _detectedScrollView.scrollView.contentInsetAdjustmentBehavior = _originalInsetAdjustmentBehavior;
+    _appliedContentInsetAdjustment = NO;
+  }
+  _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 +208,74 @@ 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 applyContentInsetAdjustment];
 
   // 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 +283,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 +323,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 +337,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 +350,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
 }
 
 - (void)focusedInputTextDidChange:(NSNotification *)notification {
-  if (!_pinnedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
+  if (!_detectedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
     return;
   }
 
@@ -409,12 +361,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 +379,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 +397,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 +412,7 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setScrollViewContentInset:self->_bottomInset
-                                      indicatorInset:self->_originalIndicatorBottomInset];
+                     [self setKeyboardInset:0];
                    }
                    completion:nil];
 }
@@ -470,9 +424,9 @@ static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
   [self stopObservingTextChanges];
   [self clearScrollable];
   _state.reset();
-  _scrollableBounded = NO;
-  _hasAutoDetent = NO;
-  _lastSize = CGSizeZero;
+  _scrollableHandle = 0;
+  _contentInsetAdjustment = 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.

package/ios/TrueSheetFooterView.mm

@@ -25,6 +25,8 @@ using namespace facebook::react;
   CGFloat _currentKeyboardOffset;
   CGFloat _bottomInset;
   BOOL _keyboardVisible;
+  BOOL _didPushBottomInset;
+  CGFloat _appliedBottomInset;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -43,6 +45,8 @@ using namespace facebook::react;
     _currentKeyboardOffset = 0;
     _bottomInset = 0;
     _keyboardVisible = NO;
+    _didPushBottomInset = NO;
+    _appliedBottomInset = 0;
   }
   return self;
 }
@@ -55,7 +59,11 @@ using namespace facebook::react;
 // bottom safe-area inset — the footer owns the sheet's bottom edge, so it
 // absorbs the inset and its background fills it.
 - (void)setBottomInset:(CGFloat)bottomInset {
-  if (_bottomInset == bottomInset) {
+  // The first push must go through even when the value matches the ivar
+  // default (0) — it marks the state initialized so the shadow node stops
+  // seeding from the app-wide precalculated inset, which may belong to
+  // another sheet (e.g. a floating sheet whose real inset is 0).
+  if (_didPushBottomInset && _bottomInset == bottomInset) {
     return;
   }
   _bottomInset = bottomInset;
@@ -85,6 +93,14 @@ using namespace facebook::react;
   // them an inset stale (same reason Android bridges through
   // TrueSheetStateUpdater).
   _state->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+  _didPushBottomInset = YES;
+}
+
+// The inset baked into the current layout by the shadow node (pushed or
+// seeded — see TrueSheetFooterViewShadowNode). Refreshed in
+// updateLayoutMetrics so it always pairs with the measured height.
+- (CGFloat)appliedBottomInset {
+  return _appliedBottomInset;
 }
 
 // Height the footer occupies above the keyboard — its layout height minus the
@@ -123,8 +139,19 @@ using namespace facebook::react;
            oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
 
+  // State lands before layout metrics within the same mount transaction, so
+  // this reflects the inset the shadow node baked into this frame — seeded
+  // values are recorded back into the state at layout time (see
+  // TrueSheetFooterViewShadowNode).
+  CGFloat previousAppliedBottomInset = _appliedBottomInset;
+  if (_state) {
+    _appliedBottomInset = _state->getData().bottomInset;
+  }
+
   CGFloat height = layoutMetrics.frame.size.height;
-  if (height != _lastHeight) {
+  // An inset change alone (fixed-height footer: padding moves, frame doesn't)
+  // still changes what's baked in — report so the controller re-pairs.
+  if (height != _lastHeight || _appliedBottomInset != previousAppliedBottomInset) {
     _lastHeight = height;
     [self.delegate footerViewDidChangeSize:CGSizeMake(layoutMetrics.frame.size.width, height)];
   }
@@ -143,6 +170,8 @@ using namespace facebook::react;
   _currentKeyboardOffset = 0;
   _bottomInset = 0;
   _keyboardVisible = NO;
+  _didPushBottomInset = NO;
+  _appliedBottomInset = 0;
 }
 
 #pragma mark - TrueSheetKeyboardObserverDelegate
@@ -167,6 +196,7 @@ using namespace facebook::react;
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
                      self.transform = CGAffineTransformMakeTranslation(0, -slide);
+                     [self syncEdgeEffect];
                    }
                    completion:nil];
 }
@@ -180,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/TrueSheetModule.h

@@ -27,16 +27,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 /**
  * Register a sheet component view with its React tag
- * Called automatically by TrueSheetView during initialization
+ * Called automatically by TrueSheetView when it attaches to a window.
+ * The registry holds views weakly, so no unregistration is needed.
  */
 + (void)registerView:(TrueSheetView *)view withTag:(NSNumber *)tag;
 
-/**
- * Unregister a sheet component view
- * Called automatically by TrueSheetView during dealloc
- */
-+ (void)unregisterViewWithTag:(NSNumber *)tag;
-
 @end
 
 NS_ASSUME_NONNULL_END