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

package/ios/TrueSheetContentView.mm

@@ -10,18 +10,32 @@
 
 #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/LayoutUtil.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;
+  BOOL _observingTextChanges;
+  BOOL _scrollableBounded;
+  BOOL _isReportPending;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -32,83 +46,439 @@ using namespace facebook::react;
   if (self = [super initWithFrame:frame]) {
     static const auto defaultProps = std::make_shared<const TrueSheetContentViewProps>();
     _props = defaultProps;
-
-    _pinnedScrollView = nil;
-    _lastSize = CGSizeZero;
   }
   return self;
 }
 
+- (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
+
+// The notification is app-wide (object:nil), so only observe while the keyboard is up
+- (void)startObservingTextChanges {
+  if (_observingTextChanges) {
+    return;
+  }
+  _observingTextChanges = YES;
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(focusedInputTextDidChange:)
+                                               name:UITextViewTextDidChangeNotification
+                                             object:nil];
+}
+
+- (void)stopObservingTextChanges {
+  if (!_observingTextChanges) {
+    return;
+  }
+  _observingTextChanges = NO;
+  [[NSNotificationCenter defaultCenter] removeObserver:self name:UITextViewTextDidChangeNotification object:nil];
+}
+
+#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;
+    }
+    _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];
+  }
+}
+
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
            oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [self reportSizeIfChanged];
+}
 
-  // Notify delegate when content size changes for sheet height updates
-  CGSize newSize = CGSizeMake(layoutMetrics.frame.size.width, layoutMetrics.frame.size.height);
-  if (!CGSizeEqualToSize(newSize, _lastSize)) {
-    _lastSize = newSize;
-    if ([self.delegate respondsToSelector:@selector(contentViewDidChangeSize:)]) {
-      [self.delegate contentViewDidChangeSize:newSize];
-    }
+#pragma mark - Child Mounting
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [super mountChildComponentView:childComponentView index:index];
+  [self checkScrollViewChanged];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [super unmountChildComponentView:childComponentView index:index];
+  [self checkScrollViewChanged];
+}
+
+- (void)checkScrollViewChanged {
+  if (!_pinnedScrollView || ![_pinnedScrollView isDescendantOfView:self]) {
+    [self.delegate contentViewScrollViewDidChange];
   }
 }
 
-- (void)didMoveToSuperview {
-  [super didMoveToSuperview];
+#pragma mark - Scrollable
+
+- (void)setScrollViewContentInset:(CGFloat)contentBottom indicatorInset:(CGFloat)indicatorBottom {
+  if (!_pinnedScrollView)
+    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;
+}
 
-  // Setup scroll view pinning after Fabric mounts the view in container
-  // Ensures proper view hierarchy for scroll detection and pinning
-  if (self.superview) {
-    [self setupScrollViewPinning];
+- (void)clearScrollable {
+  if (_pinnedScrollView) {
+    [self setScrollViewContentInset:0 indicatorInset:_originalIndicatorBottomInset];
   }
+  [self unobserveScrollViewContentSize];
+  [self setScrollableBounded:NO];
+  _pinnedScrollView = nil;
+  _bottomInset = 0;
+  _originalIndicatorBottomInset = 0;
+  [self reportSizeIfChanged];
 }
 
-- (void)setupScrollViewPinning {
-  // Auto-detect and pin scroll views for proper sheet scrolling behavior
-  // Pinning ensures ScrollView fills the sheet area and scrolls correctly with the sheet
+- (void)setupScrollableWithBottomInset:(CGFloat)bottomInset {
+  // Check if pinned scroll view is still valid (still in view hierarchy)
+  if (_pinnedScrollView && ![_pinnedScrollView isDescendantOfView:self]) {
+    [self clearScrollable];
+  }
+
+  // Already set up with same inset and valid scroll view
+  if (_pinnedScrollView && _bottomInset == bottomInset) {
+    return;
+  }
+
   RCTScrollViewComponentView *scrollView = [self findScrollView];
+  if (!scrollView) {
+    return;
+  }
 
-  if (scrollView && scrollView != _pinnedScrollView) {
-    // Unpin previous scroll view if exists
-    if (_pinnedScrollView) {
-      [LayoutUtil unpinView:_pinnedScrollView];
-    }
+  // Only capture originals on first pin
+  if (!_pinnedScrollView) {
+    _originalIndicatorBottomInset = scrollView.scrollView.verticalScrollIndicatorInsets.bottom;
+    _pinnedScrollView = scrollView;
 
-    // Pin to container view to enable proper scrolling within the sheet
-    UIView *containerView = self.superview;
-    if (containerView) {
-      [LayoutUtil pinView:scrollView toParentView:containerView edges:UIRectEdgeAll];
-      _pinnedScrollView = scrollView;
-    }
+    [self observeScrollViewContentSize];
+    [self setScrollableBounded:_hasAutoDetent];
+    [self reportSizeIfChanged];
+  }
+
+  _bottomInset = bottomInset;
+
+  [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) {
+    CGFloat inset = [self keyboardInsetWithHeight:keyboardHeight];
+    [self setScrollViewContentInset:inset indicatorInset:_originalIndicatorBottomInset + inset];
   }
 }
 
+// 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);
+}
+
+// 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];
+}
+
+- (void)unobserveScrollViewContentSize {
+  if (_observedScrollView) {
+    [_observedScrollView removeObserver:self forKeyPath:@"contentSize" context:TrueSheetContentSizeContext];
+    _observedScrollView = nil;
+  }
+}
+
+- (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 {
-  // Get the React component's root view
+  if (_pinnedScrollView) {
+    return _pinnedScrollView;
+  }
+
   if (self.subviews.count == 0) {
     return nil;
   }
 
-  // Check first-level children for scroll views (ScrollView or FlatList)
-  for (UIView *subview in self.subviews) {
-    if ([subview isKindOfClass:RCTScrollViewComponentView.class]) {
-      return static_cast<RCTScrollViewComponentView *>(subview);
+  RCTScrollViewComponentView *scrollView = [self findScrollViewInSubviews:self.subviews];
+
+  if (!scrollView) {
+    for (UIView *subview in self.subviews) {
+      scrollView = [self findScrollViewInSubviews:subview.subviews];
+      if (scrollView) {
+        break;
+      }
     }
   }
 
+  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;
 }
 
-- (void)prepareForRecycle {
-  [super prepareForRecycle];
+#pragma mark - Scroll Edge Effects
 
-  // Remove scroll view constraints
-  if (_pinnedScrollView) {
-    [LayoutUtil unpinView:_pinnedScrollView];
-    _pinnedScrollView = nil;
+- (void)applyScrollEdgeEffects:(nullable ScrollableOptions *)options {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+  if (!_pinnedScrollView)
+    return;
+
+  if (@available(iOS 26.0, *)) {
+    UIScrollView *scrollView = _pinnedScrollView.scrollView;
+    auto topEffect = options ? options.topScrollEdgeEffect : TrueSheetViewTopScrollEdgeEffect::Hidden;
+    auto bottomEffect = options ? options.bottomScrollEdgeEffect : TrueSheetViewBottomScrollEdgeEffect::Hidden;
+
+    [self applyEdgeEffect:topEffect toEdge:scrollView.topEdgeEffect];
+    [self applyEdgeEffect:(TrueSheetViewTopScrollEdgeEffect)bottomEffect toEdge:scrollView.bottomEdgeEffect];
+  }
+#endif
+}
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_0)
+- (void)applyEdgeEffect:(TrueSheetViewTopScrollEdgeEffect)effect
+                 toEdge:(UIScrollEdgeEffect *)edgeEffect API_AVAILABLE(ios(26.0)) {
+  switch (effect) {
+    case TrueSheetViewTopScrollEdgeEffect::Automatic:
+      edgeEffect.hidden = NO;
+      edgeEffect.style = UIScrollEdgeEffectStyle.automaticStyle;
+      break;
+    case TrueSheetViewTopScrollEdgeEffect::Hard:
+      edgeEffect.hidden = NO;
+      edgeEffect.style = UIScrollEdgeEffectStyle.hardStyle;
+      break;
+    case TrueSheetViewTopScrollEdgeEffect::Soft:
+      edgeEffect.hidden = NO;
+      edgeEffect.style = UIScrollEdgeEffectStyle.softStyle;
+      break;
+    case TrueSheetViewTopScrollEdgeEffect::Hidden:
+      edgeEffect.hidden = YES;
+      break;
+  }
+}
+#endif
+
+#pragma mark - TrueSheetKeyboardObserverDelegate
+
+- (void)keyboardWillShow:(CGFloat)height duration:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
+  if (!_pinnedScrollView) {
+    return;
+  }
+
+  [self startObservingTextChanges];
+
+  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:inset indicatorInset:self->_originalIndicatorBottomInset + inset];
+                   }
+                   completion:nil];
+
+  // Defer scroll until the next run loop so content insets are applied first
+  if (firstResponder) {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self scrollToFocusedCaretAnimated:YES];
+    });
+  }
+}
+
+- (void)focusedInputTextDidChange:(NSNotification *)notification {
+  if (!_pinnedScrollView || !_keyboardObserver || _keyboardObserver.currentHeight <= 0) {
+    return;
+  }
+
+  TrueSheetViewController *sheetController = _keyboardObserver.viewController;
+  UIView *firstResponder = sheetController ? [sheetController.view findFirstResponder] : nil;
+  if (!firstResponder || notification.object != firstResponder) {
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self scrollToFocusedCaretAnimated:YES];
+  });
+}
+
+- (void)scrollToFocusedCaretAnimated:(BOOL)animated {
+  if (!_pinnedScrollView) {
+    return;
+  }
+
+  TrueSheetViewController *sheetController = _keyboardObserver.viewController;
+  UIView *firstResponder = sheetController ? [sheetController.view findFirstResponder] : nil;
+  if (!firstResponder) {
+    return;
   }
+
+  UIScrollView *scrollView = _pinnedScrollView.scrollView;
+  CGRect targetRect = [firstResponder convertRect:firstResponder.bounds toView:scrollView];
+
+  if ([firstResponder conformsToProtocol:@protocol(UITextInput)]) {
+    id<UITextInput> textInput = (id<UITextInput>)firstResponder;
+    UITextRange *selectedRange = textInput.selectedTextRange;
+    if (selectedRange) {
+      CGRect caretRect = [textInput caretRectForPosition:selectedRange.end];
+      // caretRectForPosition: can return non-finite coordinates during layout/selection transitions
+      BOOL caretRectValid = !CGRectIsNull(caretRect) && !CGRectIsInfinite(caretRect) && isfinite(caretRect.origin.x) &&
+                            isfinite(caretRect.origin.y) && isfinite(caretRect.size.width) &&
+                            isfinite(caretRect.size.height);
+      if (caretRectValid) {
+        targetRect = [firstResponder convertRect:caretRect toView:scrollView];
+      }
+    }
+  }
+
+  targetRect.size.height += self.keyboardScrollOffset;
+  [scrollView scrollRectToVisible:targetRect animated:animated];
+}
+
+- (void)keyboardWillHide:(NSTimeInterval)duration curve:(UIViewAnimationOptions)curve {
+  [self stopObservingTextChanges];
+
+  if (!_pinnedScrollView) {
+    return;
+  }
+
+  [UIView animateWithDuration:duration
+                        delay:0
+                      options:curve | UIViewAnimationOptionBeginFromCurrentState
+                   animations:^{
+                     [self setScrollViewContentInset:self->_bottomInset
+                                      indicatorInset:self->_originalIndicatorBottomInset];
+                   }
+                   completion:nil];
+}
+
+#pragma mark - Lifecycle
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self stopObservingTextChanges];
+  [self clearScrollable];
+  _state.reset();
+  _scrollableBounded = NO;
+  _hasAutoDetent = NO;
+  _lastSize = CGSizeZero;
 }
 
 @end
 
+Class<RCTComponentViewProtocol> TrueSheetContentViewCls(void) {
+  return TrueSheetContentView.class;
+}
+
 #endif

package/ios/TrueSheetFooterView.h

@@ -11,14 +11,39 @@
 #import <React/RCTSurfaceTouchHandler.h>
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIKit.h>
+#import "core/TrueSheetKeyboardObserver.h"
 
 @class TrueSheetViewController;
 
 NS_ASSUME_NONNULL_BEGIN
 
-@interface TrueSheetFooterView : RCTViewComponentView
+@protocol TrueSheetFooterViewDelegate <NSObject>
+@optional
+- (void)footerViewDidChangeSize:(CGSize)size;
+@end
+
+@interface TrueSheetFooterView : RCTViewComponentView <TrueSheetKeyboardObserverDelegate>
+
+@property (nonatomic, weak, nullable) TrueSheetKeyboardObserver *keyboardObserver;
+@property (nonatomic, weak, nullable) id<TrueSheetFooterViewDelegate> delegate;
+
+/**
+ * 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;
 
-- (void)setupConstraintsWithHeight:(CGFloat)height;
+/**
+ * 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