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

package/ios/TrueSheetContentView.mm

@@ -10,11 +10,13 @@
 
 #import "TrueSheetContentView.h"
 #import <React/RCTScrollViewComponentView.h>
-#import <react/renderer/components/TrueSheetSpec/ComponentDescriptors.h>
 #import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
 #import <react/renderer/components/TrueSheetSpec/Props.h>
 #import <react/renderer/components/TrueSheetSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.h>
 #import "TrueSheetContainerView.h"
+#import "TrueSheetFooterView.h"
 #import "TrueSheetView.h"
 #import "TrueSheetViewController.h"
 #import "utils/PlatformUtil.h"
@@ -22,13 +24,18 @@
 
 using namespace facebook::react;
 
+static void *TrueSheetContentSizeContext = &TrueSheetContentSizeContext;
+
 @implementation TrueSheetContentView {
+  TrueSheetContentViewShadowNode::ConcreteState::Shared _state;
   RCTScrollViewComponentView *_pinnedScrollView;
+  UIScrollView *_observedScrollView;
   CGSize _lastSize;
   CGFloat _bottomInset;
-  CGFloat _originalScrollViewHeight;
   CGFloat _originalIndicatorBottomInset;
   BOOL _observingTextChanges;
+  BOOL _scrollableBounded;
+  BOOL _isReportPending;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -45,6 +52,38 @@ using namespace facebook::react;
 
 - (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);
+}
+
+// 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) {
+    return;
+  }
+  _scrollableBounded = bounded;
+
+  if (_state) {
+    TrueSheetContentViewState newState;
+    newState.scrollableBounded = bounded;
+    _state->updateState(std::move(newState));
+  }
+}
+
+- (void)setHasAutoDetent:(BOOL)hasAutoDetent {
+  if (_hasAutoDetent == hasAutoDetent) {
+    return;
+  }
+  _hasAutoDetent = hasAutoDetent;
+
+  if (_pinnedScrollView) {
+    [self setScrollableBounded:hasAutoDetent];
+  }
 }
 
 #pragma mark - Text Change Observing
@@ -71,17 +110,61 @@ using namespace facebook::react;
 
 #pragma mark - Layout
 
-- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
-           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
-  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+- (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;
+    }
+    _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];
+}
 
-  CGSize newSize = CGSizeMake(layoutMetrics.frame.size.width, layoutMetrics.frame.size.height);
+- (void)reportSizeNow {
+  CGSize newSize = CGSizeMake(self.frame.size.width, self.naturalHeight);
   if (!CGSizeEqualToSize(newSize, _lastSize)) {
     _lastSize = newSize;
     [self.delegate contentViewDidChangeSize:newSize];
   }
 }
 
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [self reportSizeIfChanged];
+}
+
 #pragma mark - Child Mounting
 
 - (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
@@ -117,24 +200,17 @@ using namespace facebook::react;
 
 - (void)clearScrollable {
   if (_pinnedScrollView) {
-    CGRect frame = _pinnedScrollView.frame;
-    frame.size.height = _originalScrollViewHeight;
-    _pinnedScrollView.frame = frame;
-
     [self setScrollViewContentInset:0 indicatorInset:_originalIndicatorBottomInset];
   }
+  [self unobserveScrollViewContentSize];
+  [self setScrollableBounded:NO];
   _pinnedScrollView = nil;
   _bottomInset = 0;
-  _originalScrollViewHeight = 0;
   _originalIndicatorBottomInset = 0;
+  [self reportSizeIfChanged];
 }
 
-- (void)setupScrollable:(BOOL)enabled bottomInset:(CGFloat)bottomInset {
-  if (!enabled) {
-    [self clearScrollable];
-    return;
-  }
-
+- (void)setupScrollableWithBottomInset:(CGFloat)bottomInset {
   // Check if pinned scroll view is still valid (still in view hierarchy)
   if (_pinnedScrollView && ![_pinnedScrollView isDescendantOfView:self]) {
     [self clearScrollable];
@@ -152,49 +228,71 @@ using namespace facebook::react;
 
   // Only capture originals on first pin
   if (!_pinnedScrollView) {
-    _originalScrollViewHeight = scrollView.frame.size.height;
     _originalIndicatorBottomInset = scrollView.scrollView.verticalScrollIndicatorInsets.bottom;
     _pinnedScrollView = scrollView;
+
+    [self observeScrollViewContentSize];
+    [self setScrollableBounded:_hasAutoDetent];
+    [self reportSizeIfChanged];
   }
 
   _bottomInset = bottomInset;
 
-  [self updateScrollViewHeight];
-
   [self setScrollViewContentInset:_bottomInset indicatorInset:_originalIndicatorBottomInset];
 
   // If keyboard is currently showing, re-apply the keyboard inset to the new ScrollView
   CGFloat keyboardHeight = _keyboardObserver ? _keyboardObserver.currentHeight : 0;
   if (keyboardHeight > 0) {
-    [self setScrollViewContentInset:keyboardHeight indicatorInset:_originalIndicatorBottomInset + keyboardHeight];
+    CGFloat inset = [self keyboardInsetWithHeight:keyboardHeight];
+    [self setScrollViewContentInset:inset indicatorInset:_originalIndicatorBottomInset + inset];
   }
 }
 
-- (void)updateScrollViewHeight {
-  if (!_pinnedScrollView) {
-    return;
+// 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.
+- (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);
+}
 
-  UIView *containerView = self.superview;
-  if (!containerView) {
+// 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;
   }
+  [self unobserveScrollViewContentSize];
+  _observedScrollView = scrollView;
+  [scrollView addObserver:self
+               forKeyPath:@"contentSize"
+                  options:NSKeyValueObservingOptionNew
+                  context:TrueSheetContentSizeContext];
+}
 
-  CGRect scrollViewFrameInContainer = [_pinnedScrollView.superview convertRect:_pinnedScrollView.frame
-                                                                        toView:containerView];
-  CGFloat newHeight = containerView.bounds.size.height - scrollViewFrameInContainer.origin.y;
-
-  if (newHeight > 0) {
-    // Preserve contentOffset before changing frame to prevent scroll jump
-    CGPoint savedContentOffset = _pinnedScrollView.scrollView.contentOffset;
-
-    CGRect frame = _pinnedScrollView.frame;
-    frame.size.height = newHeight;
-    _pinnedScrollView.frame = frame;
+- (void)unobserveScrollViewContentSize {
+  if (_observedScrollView) {
+    [_observedScrollView removeObserver:self forKeyPath:@"contentSize" context:TrueSheetContentSizeContext];
+    _observedScrollView = nil;
+  }
+}
 
-    // Restore contentOffset after frame change
-    _pinnedScrollView.scrollView.contentOffset = savedContentOffset;
+- (void)observeValueForKeyPath:(NSString *)keyPath
+                      ofObject:(id)object
+                        change:(NSDictionary *)change
+                       context:(void *)context {
+  if (context == TrueSheetContentSizeContext) {
+    [self reportSizeIfChanged];
+    return;
   }
+  [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
 }
 
 - (RCTScrollViewComponentView *)findScrollView {
@@ -282,12 +380,12 @@ using namespace facebook::react;
   TrueSheetViewController *sheetController = _keyboardObserver.viewController;
   UIView *firstResponder = sheetController ? [sheetController.view findFirstResponder] : nil;
 
+  CGFloat inset = [self keyboardInsetWithHeight:height];
   [UIView animateWithDuration:duration
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     [self setScrollViewContentInset:height
-                                      indicatorInset:self->_originalIndicatorBottomInset + height];
+                     [self setScrollViewContentInset:inset indicatorInset:self->_originalIndicatorBottomInset + inset];
                    }
                    completion:nil];
 
@@ -371,6 +469,10 @@ using namespace facebook::react;
   [super prepareForRecycle];
   [self stopObservingTextChanges];
   [self clearScrollable];
+  _state.reset();
+  _scrollableBounded = NO;
+  _hasAutoDetent = NO;
+  _lastSize = CGSizeZero;
 }
 
 @end

package/ios/TrueSheetFooterView.h

@@ -27,14 +27,24 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak, nullable) TrueSheetKeyboardObserver *keyboardObserver;
 @property (nonatomic, weak, nullable) id<TrueSheetFooterViewDelegate> delegate;
 
-- (void)setupConstraintsWithHeight:(CGFloat)height;
-
 /**
  * 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.
  */
 - (void)applyKeyboardOffset;
 
+/**
+ * Bottom safe-area inset the footer absorbs as padding (via the shadow node)
+ * so its content clears the home indicator and the background fills the inset.
+ */
+- (void)setBottomInset:(CGFloat)bottomInset;
+
+/**
+ * Height the footer occupies above the keyboard — its layout height minus
+ * the safe-area inset it drops while the keyboard is open.
+ */
+- (CGFloat)keyboardOcclusionHeight;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/TrueSheetFooterView.mm

@@ -9,22 +9,22 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 
 #import "TrueSheetFooterView.h"
-#import <react/renderer/components/TrueSheetSpec/ComponentDescriptors.h>
 #import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
 #import <react/renderer/components/TrueSheetSpec/Props.h>
 #import <react/renderer/components/TrueSheetSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.h>
 #import "TrueSheetViewController.h"
-#import "utils/LayoutUtil.h"
 #import "utils/UIView+ScrollEdgeInteraction.h"
 
 using namespace facebook::react;
 
 @implementation TrueSheetFooterView {
+  TrueSheetFooterViewShadowNode::ConcreteState::Shared _state;
   CGFloat _lastHeight;
-  CGFloat _pendingHeight;
-  BOOL _didInitialLayout;
-  NSLayoutConstraint *_bottomConstraint;
   CGFloat _currentKeyboardOffset;
+  CGFloat _bottomInset;
+  BOOL _keyboardVisible;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -40,14 +40,59 @@ using namespace facebook::react;
     self.isAccessibilityElement = NO;
 
     _lastHeight = 0;
-    _pendingHeight = 0;
-    _didInitialLayout = NO;
-    _bottomConstraint = nil;
     _currentKeyboardOffset = 0;
+    _bottomInset = 0;
+    _keyboardVisible = NO;
   }
   return self;
 }
 
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<TrueSheetFooterViewShadowNode::ConcreteState const>(state);
+}
+
+// Tells the shadow node to pad the footer's bottom edge with the sheet's
+// 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) {
+    return;
+  }
+  _bottomInset = bottomInset;
+  [self pushBottomInsetState];
+}
+
+// Skipped while the keyboard is open — an absolute footer rises above the
+// keyboard, so the inset would leave a gap.
+- (void)setKeyboardVisible:(BOOL)keyboardVisible {
+  if (_keyboardVisible == keyboardVisible) {
+    return;
+  }
+  _keyboardVisible = keyboardVisible;
+  [self pushBottomInsetState];
+}
+
+- (void)pushBottomInsetState {
+  if (!_state) {
+    return;
+  }
+
+  TrueSheetFooterViewState newState;
+  newState.bottomInset = _keyboardVisible ? 0 : _bottomInset;
+  newState.initialized = true;
+  // Immediate so the inset lands before anything reads the footer's height —
+  // the async path races the keyboard caret scroll and detent setup, leaving
+  // them an inset stale (same reason Android bridges through
+  // TrueSheetStateUpdater).
+  _state->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+}
+
+// Height the footer occupies above the keyboard — its layout height minus the
+// safe-area inset it drops while the keyboard is open.
+- (CGFloat)keyboardOcclusionHeight {
+  return MAX(0, _lastHeight - (_keyboardVisible ? 0 : _bottomInset));
+}
+
 #pragma mark - Accessibility
 
 - (NSArray *)accessibilityElements {
@@ -74,57 +119,13 @@ using namespace facebook::react;
 
 #pragma mark - Layout
 
-- (void)setupConstraintsWithHeight:(CGFloat)height {
-  UIView *parentView = self.superview;
-  if (!parentView) {
-    // On recycled views, updateLayoutMetrics can fire before the view is
-    // reparented. Remember the desired height so didMoveToSuperview applies
-    // it instead of falling back to the stale self.frame from the previous
-    // present cycle.
-    _pendingHeight = height;
-    return;
-  }
-
-  [LayoutUtil unpinView:self fromParentView:parentView];
-  _bottomConstraint = nil;
-
-  self.translatesAutoresizingMaskIntoConstraints = NO;
-
-  [self.leadingAnchor constraintEqualToAnchor:parentView.leadingAnchor].active = YES;
-  [self.trailingAnchor constraintEqualToAnchor:parentView.trailingAnchor].active = YES;
-
-  _bottomConstraint = [self.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor
-                                                        constant:-_currentKeyboardOffset];
-  _bottomConstraint.active = YES;
-
-  if (height > 0) {
-    [self.heightAnchor constraintEqualToConstant:height].active = YES;
-  }
-
-  _lastHeight = height;
-  _pendingHeight = 0;
-}
-
-- (void)didMoveToSuperview {
-  [super didMoveToSuperview];
-
-  if (self.superview) {
-    CGFloat initialHeight = _pendingHeight > 0 ? _pendingHeight : self.frame.size.height;
-    [self setupConstraintsWithHeight:initialHeight];
-  }
-}
-
 - (void)updateLayoutMetrics:(const facebook::react::LayoutMetrics &)layoutMetrics
            oldLayoutMetrics:(const facebook::react::LayoutMetrics &)oldLayoutMetrics {
-  CGFloat height = layoutMetrics.frame.size.height;
-
-  if (!_didInitialLayout) {
-    [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
-    _didInitialLayout = YES;
-  }
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
 
+  CGFloat height = layoutMetrics.frame.size.height;
   if (height != _lastHeight) {
-    [self setupConstraintsWithHeight:height];
+    _lastHeight = height;
     [self.delegate footerViewDidChangeSize:CGSizeMake(layoutMetrics.frame.size.width, height)];
   }
 }
@@ -132,25 +133,31 @@ using namespace facebook::react;
 - (void)prepareForRecycle {
   [super prepareForRecycle];
 
-  [LayoutUtil unpinView:self fromParentView:self.superview];
   if (@available(iOS 26.0, *)) {
     [self cleanupEdgeInteraction];
   }
 
+  self.transform = CGAffineTransformIdentity;
+  _state = nullptr;
   _lastHeight = 0;
-  _pendingHeight = 0;
-  _didInitialLayout = NO;
-  _bottomConstraint = nil;
   _currentKeyboardOffset = 0;
+  _bottomInset = 0;
+  _keyboardVisible = NO;
 }
 
 #pragma mark - TrueSheetKeyboardObserverDelegate
 
+// 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.
 - (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!_bottomConstraint) {
+  if (!self.keyboardObserver.viewController.absoluteFooter) {
     return;
   }
 
+  [self setKeyboardVisible:YES];
+
   CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
   CGFloat slide = MAX(0, height + keyboardOffset);
   _currentKeyboardOffset = slide;
@@ -159,40 +166,36 @@ using namespace facebook::react;
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     self->_bottomConstraint.constant = -slide;
-                     [self.superview layoutIfNeeded];
+                     self.transform = CGAffineTransformMakeTranslation(0, -slide);
                    }
                    completion:nil];
 }
 
 - (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
-  if (!_bottomConstraint) {
-    return;
-  }
-
+  [self setKeyboardVisible:NO];
   _currentKeyboardOffset = 0;
 
   [UIView animateWithDuration:duration
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     self->_bottomConstraint.constant = 0;
-                     [self.superview layoutIfNeeded];
+                     self.transform = CGAffineTransformIdentity;
                    }
                    completion:nil];
 }
 
 - (void)applyKeyboardOffset {
   CGFloat height = self.keyboardObserver.currentHeight;
-  if (!_bottomConstraint || height <= 0) {
+  if (height <= 0 || !self.keyboardObserver.viewController.absoluteFooter) {
     return;
   }
 
+  [self setKeyboardVisible:YES];
+
   CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
   CGFloat slide = MAX(0, height + keyboardOffset);
   _currentKeyboardOffset = slide;
-  _bottomConstraint.constant = -slide;
-  [self.superview layoutIfNeeded];
+  self.transform = CGAffineTransformMakeTranslation(0, -slide);
 }
 
 @end

package/ios/TrueSheetHeaderView.mm

@@ -13,7 +13,6 @@
 #import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
 #import <react/renderer/components/TrueSheetSpec/Props.h>
 #import <react/renderer/components/TrueSheetSpec/RCTComponentViewHelpers.h>
-#import "utils/LayoutUtil.h"
 #import "utils/UIView+ScrollEdgeInteraction.h"
 
 using namespace facebook::react;