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

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;
@@ -110,18 +111,47 @@ using namespace facebook::react;
     return;
   }
 
-  if (_initialDetentIndex >= 0 && !_didInitiallyPresent) {
-    UIViewController *vc = [self findPresentingViewController];
+  [self presentInitialIfNeeded];
+}
 
-    // Only present if the view controller is in the same window and not being dismissed
-    if (vc && vc.view.window == self.window && !_controller.isBeingDismissed) {
-      _didInitiallyPresent = YES;
-      [self presentAtIndex:_initialDetentIndex animated:_initialDetentAnimated completion:nil];
-    } else {
-      // Animate next time when sheet finally moves to the correct window
-      _initialDetentAnimated = YES;
-    }
+// JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+// navigation footer set via setOptions) commits together with it — by the time
+// the prop lands the tree is final and the sheet presents at its final height.
+// Called from didMoveToWindow (re-attach) and finalizeUpdates (the prop
+// arriving after attach, which didMoveToWindow won't re-fire for).
+- (void)presentInitialIfNeeded {
+  if (_initialDetentIndex < 0 || _didInitiallyPresent)
+    return;
+
+  UIViewController *vc = [self findPresentingViewController];
+
+  // Only present if the view controller is in the same window and not being dismissed
+  if (!vc || vc.view.window != self.window || _controller.isBeingDismissed) {
+    // Animate next time when sheet finally moves to the correct window
+    _initialDetentAnimated = YES;
+    return;
   }
+
+  _didInitiallyPresent = YES;
+
+  // Deferred a runloop turn so sibling mounts from the current transaction
+  // (e.g. a footer committed alongside the prop) land before measuring.
+  __weak __typeof(self) weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf || strongSelf->_controller.isPresented || strongSelf->_controller.isBeingPresented)
+      return;
+
+    [strongSelf presentAtIndex:strongSelf->_initialDetentIndex
+                      animated:strongSelf->_initialDetentAnimated
+                    completion:^(BOOL success, NSError *_Nullable error) {
+                      // Present can fail if the view detached during this turn —
+                      // reset so the next attach/prop update retries.
+                      if (!success) {
+                        strongSelf->_didInitiallyPresent = NO;
+                      }
+                    }];
+  });
 }
 
 - (void)dealloc {
@@ -248,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;
@@ -342,6 +378,9 @@ using namespace facebook::react;
     _pendingPropsUpdate = YES;
   } else if (_initialDetentIndex >= 0) {
     _pendingLayoutUpdate = NO;
+    if (self.window) {
+      [self presentInitialIfNeeded];
+    }
   }
 }
 
@@ -403,9 +442,8 @@ using namespace facebook::react;
     _controller.headerHeight = @(headerHeight);
   }
 
-  CGFloat footerHeight = [_containerView footerHeight];
-  if (footerHeight > 0) {
-    _controller.footerHeight = @(footerHeight);
+  if ([_containerView footerHeight] > 0) {
+    [self syncFooterMetrics];
   }
 
   CGFloat peekContentHeight = [_containerView peekContentHeight];
@@ -471,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 —
@@ -480,11 +518,12 @@ using namespace facebook::react;
   if (_containerView) {
     _controller.contentHeight = @([_containerView contentHeight]);
     _controller.headerHeight = @([_containerView headerHeight]);
-    _controller.footerHeight = @([_containerView footerHeight]);
+    [self syncFooterMetrics];
     _controller.peekContentHeight = @([_containerView peekContentHeight]);
   }
   _pendingSizeChange = NO;
 
+  [self refreshFooterBottomInset];
   [_controller setupSheetDetents];
   [_controller setupActiveDetentWithIndex:index];
 
@@ -583,6 +622,10 @@ using namespace facebook::react;
  * Debounced sheet update to handle rapid content/header size changes.
  */
 - (void)setupSheetDetentsForSizeChange {
+  // Keep the footer's absorbed inset in sync with the latest measured heights
+  // even before presenting, so the sheet presents at its final size.
+  [self refreshFooterBottomInset];
+
   // Retargeting the in-flight presentation makes UIKit snap the whole stack
   // (including the sheet behind) instead of animating. Defer to didPresent —
   // presentAtIndex measured synchronously, so this is usually a no-op.
@@ -610,6 +653,7 @@ using namespace facebook::react;
     // Refresh here (not just on peek size events) since the peek's offset
     // within the content can change without its own size changing.
     self->_controller.peekContentHeight = @([self->_containerView peekContentHeight]);
+    [self refreshFooterBottomInset];
     [self->_controller setupSheetDetentsForSizeChange];
   });
 }
@@ -625,7 +669,7 @@ using namespace facebook::react;
 }
 
 - (void)containerViewFooterDidChangeSize:(CGSize)newSize {
-  _controller.footerHeight = @(newSize.height);
+  [self syncFooterMetrics];
   [self setupSheetDetentsForSizeChange];
   [_controller setupAccessibilityContainer];
 }
@@ -634,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];
 }
@@ -716,6 +760,10 @@ using namespace facebook::react;
   [self updateStateWithSize:size];
 }
 
+- (void)viewControllerSafeAreaInsetsDidChange {
+  [self refreshFooterBottomInset];
+}
+
 - (void)viewControllerWillFocus {
   [TrueSheetFocusEvents emitWillFocus:_eventEmitter];
 }
@@ -781,16 +829,41 @@ 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;
-  _containerView.footerBottomInset = _controller.footerBottomInset;
+  [self refreshFooterBottomInset];
   [_containerView setupScrollable];
+}
+
+// footerHeight and appliedFooterBottomInset must stay paired — detent math
+// subtracts exactly the inset baked into the measured footer height (see
+// autoDetentBottomInset/peekDetentBottomInset).
+- (void)syncFooterMetrics {
+  _controller.footerHeight = @([_containerView footerHeight]);
+  _controller.appliedFooterBottomInset = [_containerView footerAppliedBottomInset];
+}
+
+// Recomputes the inset the footer absorbs and pushes it down. The inset
+// depends on measured heights and detents (see maxNaturalDetentHeight), so
+// this runs on size and detent changes — not just prop updates.
+- (void)refreshFooterBottomInset {
+  if (!_containerView)
+    return;
+
+  // appliedFooterBottomInset is NOT set here — it tracks what's actually
+  // baked into the footer's measured height (reported with its layout), not
+  // what was just pushed. Setting it at push time desyncs the pair and lets
+  // a seeded inset read as natural content height (see maxNaturalDetentHeight).
+  CGFloat inset = _controller.footerBottomInset;
+  _containerView.footerBottomInset = inset;
 
   // Publish the inset so a footer set later (e.g. navigation setOptions) is
   // padded on its very first layout instead of resizing the sheet twice.
   if (_insetAdjustment == TrueSheetViewInsetAdjustment::Automatic) {
-    TrueSheetInsets::setBottomSafeArea(_controller.footerBottomInset);
+    TrueSheetInsets::setBottomSafeArea(inset);
   }
 }
 
@@ -801,6 +874,7 @@ using namespace facebook::react;
   if (_pendingDetents) {
     _controller.detents = _pendingDetents;
     _pendingDetents = nil;
+    [self refreshFooterBottomInset];
   }
 
   UIView *presenterView = _controller.presentingViewController.view;

package/ios/TrueSheetViewController.h

@@ -36,6 +36,7 @@ NS_ASSUME_NONNULL_BEGIN
                                  detent:(CGFloat)detent
                                realtime:(BOOL)realtime;
 - (void)viewControllerDidChangeSize:(CGSize)size;
+- (void)viewControllerSafeAreaInsetsDidChange;
 - (void)viewControllerWillFocus;
 - (void)viewControllerDidFocus;
 - (void)viewControllerWillBlur;
@@ -99,6 +100,14 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (nonatomic, readonly) CGFloat footerBottomInset;
 
+/**
+ * The inset currently baked into the footer's measured height, reported
+ * alongside its layout (see TrueSheetFooterView.appliedBottomInset). Detent
+ * resolution subtracts this exact value so the baked inset is never
+ * double-counted.
+ */
+@property (nonatomic, assign) CGFloat appliedFooterBottomInset;
+
 - (void)setupAccessibilityContainer;
 - (void)applyActiveDetent;
 - (void)setupActiveDetentWithIndex:(NSInteger)index;

package/ios/TrueSheetViewController.mm

@@ -70,6 +70,11 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   BOOL _isDragging;
   BOOL _isWillDismissEmitted;
 
+  // Last bottom safe area observed while presented — reused as the estimate
+  // for the next present (beats the float-threshold guess for re-presents).
+  BOOL _hasObservedBottomInset;
+  CGFloat _observedBottomInset;
+
   BOOL _isInteractiveDismiss;
   CGFloat _interactiveStartPosition;
   UIView *_interactiveContainerView;
@@ -206,6 +211,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   return window ? window.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
 }
 
+// Only phone sheets absorb the bottom safe-area inset — non-phone idioms
+// (iPad form sheets) are inset from the screen edge by UIKit.
+static BOOL TrueSheetIsPhoneIdiom(void) {
+  return UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone;
+}
+
 - (CGFloat)detentBottomAdjustmentForHeight:(CGFloat)height {
   if (_insetAdjustment == TrueSheetViewInsetAdjustment::Automatic) {
     return 0;
@@ -215,7 +226,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (CGFloat)bottomSafeAreaForHeight:(CGFloat)height {
-  if (UIDevice.currentDevice.userInterfaceIdiom != UIUserInterfaceIdiomPhone) {
+  if (!TrueSheetIsPhoneIdiom()) {
     return 0;
   }
 
@@ -232,49 +243,101 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 /**
- * Bottom inset excluded from the auto detent. A relative footer owns the
- * sheet's bottom edge, so it absorbs the inset — UIKit lays custom detents out
- * above the safe area, which would otherwise gap the content from the footer.
+ * Largest height the sheet can reach across its configured detents, excluding
+ * the inset currently baked into the footer's height. Basis for the footer's
+ * inset absorption so it follows the same rule as bottomSafeAreaForHeight: —
+ * a sheet that only ever floats (small detents on iOS 26) keeps its footer
+ * unpadded.
  */
-- (CGFloat)autoDetentBottomInsetForHeight:(CGFloat)height {
-  if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
-    // 'none' already excludes the inset for every detent
-    return 0;
+- (CGFloat)maxNaturalDetentHeight {
+  CGFloat applied = [self.footerHeight floatValue] > 0 ? _appliedFooterBottomInset : 0;
+  CGFloat maxHeight = 0;
+
+  for (id detent in self.detents) {
+    if (![detent isKindOfClass:[NSNumber class]]) {
+      continue;
+    }
+
+    CGFloat value = [detent doubleValue];
+    CGFloat height = 0;
+    if (value == -1) {
+      // Auto counts a relative footer's (padded) height
+      height = [_detentCalculator autoHeight] - (_absoluteFooter ? 0 : applied);
+    } else if (value == -2) {
+      // Peek counts an absolute footer's (padded) height
+      height = [_detentCalculator peekHeight] - (_absoluteFooter ? applied : 0);
+    } else if (value > 0 && value <= 1) {
+      height = value * self.screenHeight;
+    }
+    maxHeight = fmax(maxHeight, height);
   }
 
-  if (_absoluteFooter || [self.footerHeight floatValue] <= 0) {
-    return 0;
+  if (self.maxContentHeight) {
+    maxHeight = fmin(maxHeight, [self.maxContentHeight floatValue]);
   }
 
-  return [self bottomSafeAreaForHeight:height];
+  return maxHeight > 0 ? maxHeight : self.screenHeight;
 }
 
-// The inset the footer absorbs as padding. Uses the auto detent height when
-// available so it matches the auto detent's inset exclusion above.
+// The inset the footer absorbs as padding.
 - (CGFloat)footerBottomInset {
   if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
     return 0;
   }
 
-  return [self bottomSafeAreaForHeight:_autoDetentHeight > 0 ? _autoDetentHeight : self.screenHeight];
+  // Early out so the maxNaturalDetentHeight fallback below doesn't run per
+  // layout pass on iPad only to be zeroed by bottomSafeAreaForHeight:.
+  if (!TrueSheetIsPhoneIdiom()) {
+    return 0;
+  }
+
+  // Once laid out, the sheet's own safe area is the authority — it reflects
+  // UIKit's actual float/anchored decision (a floating sheet gets 0), where
+  // bottomSafeAreaForHeight: can only guess the float threshold. Guessing
+  // wrong leaves the safe-area region unfilled (gap) or double-padded.
+  UIView *view = self.viewIfLoaded;
+  if (view.window) {
+    _hasObservedBottomInset = YES;
+    _observedBottomInset = view.safeAreaInsets.bottom;
+    return _observedBottomInset;
+  }
+
+  // Off-window while presented (e.g. hidden behind a native screen): the last
+  // observed value is this sheet's own truth — prefer it over the
+  // float-threshold guess. Cleared on dismiss so a re-present observes fresh
+  // geometry (rotation or detent changes while dismissed would stale it).
+  if (_hasObservedBottomInset) {
+    return _observedBottomInset;
+  }
+
+  return [self bottomSafeAreaForHeight:[self maxNaturalDetentHeight]];
 }
 
 /**
- * Bottom inset excluded from the peek detent. An absolute footer counts
- * toward the peek height and absorbs the inset as padding, but UIKit already
- * lays custom detents out above the safe area — subtract it so the inset
- * isn't doubled.
+ * Bottom inset excluded from the auto detent. A relative footer owns the
+ * sheet's bottom edge and carries the inset in its height (see
+ * footerBottomInset) — subtract exactly what was baked in so UIKit's own
+ * safe-area layout doesn't double it.
  */
-- (CGFloat)peekDetentBottomInsetForHeight:(CGFloat)height {
-  if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
+- (CGFloat)autoDetentBottomInset {
+  if (_absoluteFooter || [self.footerHeight floatValue] <= 0) {
     return 0;
   }
 
+  return _appliedFooterBottomInset;
+}
+
+/**
+ * Bottom inset excluded from the peek detent. An absolute footer counts
+ * toward the peek height and carries the inset in its height — subtract
+ * exactly what was baked in so it isn't doubled.
+ */
+- (CGFloat)peekDetentBottomInset {
   if (!_absoluteFooter || [self.footerHeight floatValue] <= 0) {
     return 0;
   }
 
-  return [self bottomSafeAreaForHeight:height];
+  return _appliedFooterBottomInset;
 }
 
 - (BOOL)isDesignCompatibilityMode {
@@ -520,6 +583,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     [self restoreWindowAccessibilityElements];
     _isPresented = NO;
     _isWillDismissEmitted = NO;
+    _hasObservedBottomInset = NO;
 
     [_anchorView removeFromSuperview];
     _anchorView = nil;
@@ -605,9 +669,30 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 }
 
+// Fires when UIKit resolves the sheet's float/anchored placement (present,
+// detent resize crossing the float threshold, rotation). The footer's
+// absorbed inset follows the observed safe area — repush it right away so
+// the footer pads/unpads in the same layout pass.
+- (void)viewSafeAreaInsetsDidChange {
+  [super viewSafeAreaInsetsDidChange];
+
+  // Mid-dismiss the frame moves off-screen and reports transient insets —
+  // don't let them pollute the observed value (matches viewDidLayoutSubviews).
+  if (!self.isBeingDismissed) {
+    [self.delegate viewControllerSafeAreaInsetsDidChange];
+  }
+}
+
 - (void)viewDidLayoutSubviews {
   [super viewDidLayoutSubviews];
 
+  // viewSafeAreaInsetsDidChange doesn't fire on re-present when the observed
+  // inset matches the previous presentation's — refresh every layout pass
+  // instead (deduped downstream, so unchanged values are free).
+  if (!self.isBeingDismissed) {
+    [self.delegate viewControllerSafeAreaInsetsDidChange];
+  }
+
   // Skip size reports while backgrounded behind a stacked child — the push-back
   // scaling changes the frame and would needlessly resize content.
   // _lastReportedSize stays stale so the restore pass re-reports any real change.
@@ -1079,8 +1164,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
       return [self customDetentWithIdentifier:@"custom-auto"
                                       atIndex:index
                                   heightBlock:^CGFloat {
-                                    CGFloat height = self->_autoDetentHeight;
-                                    return height - [self autoDetentBottomInsetForHeight:height];
+                                    return self->_autoDetentHeight - [self autoDetentBottomInset];
                                   }];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];
@@ -1092,8 +1176,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
       return [self customDetentWithIdentifier:@"custom-peek"
                                       atIndex:index
                                   heightBlock:^CGFloat {
-                                    CGFloat height = self->_peekDetentHeight;
-                                    return height - [self peekDetentBottomInsetForHeight:height];
+                                    return self->_peekDetentHeight - [self peekDetentBottomInset];
                                   }];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];

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