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

package/ios/core/RNScreensEventObserver.mm

@@ -22,8 +22,7 @@ using namespace facebook::react;
   NSInteger _presenterScreenTag;
   NSMutableSet<NSNumber *> *_screenTags;
   __weak UIViewController *_presenterScreenController;
-  __weak UIViewController *_parentScreenController;
-  __weak UIWindow *_window;
+  NSHashTable<UIViewController *> *_parentScreenControllers;
   BOOL _dismissedByNavigation;
   BOOL _pendingInteractiveDismiss;
   BOOL _pendingInteractiveAppear;
@@ -39,8 +38,7 @@ using namespace facebook::react;
     _presenterScreenTag = 0;
     _screenTags = [NSMutableSet new];
     _presenterScreenController = nil;
-    _parentScreenController = nil;
-    _window = nil;
+    _parentScreenControllers = [NSHashTable weakObjectsHashTable];
   }
   return self;
 }
@@ -143,8 +141,7 @@ using namespace facebook::react;
   _presenterScreenTag = 0;
   [_screenTags removeAllObjects];
   _presenterScreenController = nil;
-  _parentScreenController = nil;
-  _window = view.window;
+  [_parentScreenControllers removeAllObjects];
 
   Class screenViewClass = NSClassFromString(@"RNSScreenView");
   if (!screenViewClass)
@@ -165,8 +162,8 @@ using namespace facebook::react;
       if (!_presenterScreenController) {
         _presenterScreenTag = current.tag;
         _presenterScreenController = screenVC;
-      } else if (!_parentScreenController && screenVC) {
-        _parentScreenController = screenVC;
+      } else if (screenVC) {
+        [_parentScreenControllers addObject:screenVC];
       }
     }
   }
@@ -239,27 +236,16 @@ using namespace facebook::react;
 }
 
 - (BOOL)shouldDismissForScreenTag:(NSInteger)screenTag {
-  // For parent screens (not immediate presenter), check if the presenter screen is being removed
-  // This handles nested stack removal case
+  // For parent screens, dismiss if one was popped or covered in its own stack. The presenter
+  // may already be detached (e.g. its nested stack unmounting), so it can't be checked here.
+  // Skip if all are still top (e.g. modal dismiss - sheet dismisses naturally)
   if (screenTag != _presenterScreenTag) {
-    UINavigationController *parentNav = _parentScreenController.navigationController;
-
-    // Modal case: parent's nav is presented -> let sheet dismiss naturally
-    // Nested stack case: parent's nav is not presented (embedded) -> need to dismiss
-    if (parentNav.presentingViewController != nil) {
-      return NO;
-    }
-
-    if (!_parentScreenController) {
-      return NO;
-    }
-
-    // If presenter view is no longer in window, the nested stack is being removed
-    UIView *presenterView = [_window viewWithTag:_presenterScreenTag];
-    if (presenterView == nil || presenterView.window == nil) {
-      return YES;
+    for (UIViewController *screen in _parentScreenControllers) {
+      UINavigationController *nav = screen.navigationController;
+      if (nav && nav.topViewController != screen) {
+        return YES;
+      }
     }
-
     return NO;
   }
 
@@ -272,7 +258,24 @@ using namespace facebook::react;
 
   // Dismiss if presenter is no longer top of nav stack (pushed/popped)
   // Skip if still top (e.g. modal dismiss - sheet dismisses naturally)
-  return navController.topViewController != _presenterScreenController;
+  if (navController.topViewController != _presenterScreenController) {
+    return YES;
+  }
+
+  // A presenter inside a screen container (e.g. a bottom tab) stays the top of
+  // that container while an enclosing stack pushes a screen over it.
+  for (UINavigationController *outerNav = navController.navigationController; outerNav;
+    outerNav = outerNav.navigationController) {
+    UIViewController *ancestor = _presenterScreenController;
+    while (ancestor && ancestor != outerNav.topViewController) {
+      ancestor = ancestor.parentViewController;
+    }
+    if (!ancestor) {
+      return YES;
+    }
+  }
+
+  return NO;
 }
 
 @end

package/ios/core/TrueSheetBlurView.h

@@ -14,8 +14,6 @@ NS_ASSUME_NONNULL_BEGIN
 @interface TrueSheetBlurView : UIVisualEffectView
 
 @property (nonatomic, assign) facebook::react::TrueSheetViewBackgroundBlur backgroundBlur;
-@property (nonatomic, strong, nullable) NSNumber *blurIntensity;
-@property (nonatomic, assign) BOOL blurInteraction;
 
 /// Adds the blur view to a parent view with proper constraints
 - (void)addToView:(UIView *)parentView;

package/ios/core/TrueSheetBlurView.mm

@@ -13,15 +13,13 @@
 
 using namespace facebook::react;
 
-@implementation TrueSheetBlurView {
-  UIViewPropertyAnimator *_blurAnimator;
-}
+@implementation TrueSheetBlurView
 
 #pragma mark - Initialization
 
 - (instancetype)init {
   if (self = [super init]) {
-    _blurInteraction = YES;
+    self.userInteractionEnabled = NO;
   }
   return self;
 }
@@ -38,45 +36,14 @@ using namespace facebook::react;
   [parentView insertSubview:self atIndex:0];
 }
 
-- (void)clearAnimator {
-  if (_blurAnimator) {
-    [_blurAnimator stopAnimation:YES];
-    _blurAnimator = nil;
-  }
-}
-
 - (void)applyBlurEffect {
-  self.userInteractionEnabled = self.blurInteraction;
-
   if (self.backgroundBlur == TrueSheetViewBackgroundBlur::None) {
-    [self clearAnimator];
     self.effect = nil;
     return;
   }
 
   UIBlurEffectStyle style = [BlurUtil blurEffectStyleFromEnum:self.backgroundBlur];
-  UIBlurEffect *blurEffect = [UIBlurEffect effectWithStyle:style];
-
-  CGFloat intensity =
-    (self.blurIntensity && [self.blurIntensity floatValue] >= 0) ? [self.blurIntensity floatValue] / 100.0 : 1.0;
-
-  if (intensity >= 1.0) {
-    [self clearAnimator];
-    self.effect = blurEffect;
-    return;
-  }
-
-  if (!_blurAnimator) {
-    __weak __typeof(self) weakSelf = self;
-    _blurAnimator = [[UIViewPropertyAnimator alloc] initWithDuration:1.0
-                                                               curve:UIViewAnimationCurveLinear
-                                                          animations:^{
-                                                            weakSelf.effect = blurEffect;
-                                                          }];
-  }
-
-  _blurAnimator.pausesOnCompletion = YES;
-  _blurAnimator.fractionComplete = intensity;
+  self.effect = [UIBlurEffect effectWithStyle:style];
 }
 
 @end

package/ios/core/TrueSheetDetentCalculator.h

@@ -24,6 +24,9 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, readonly) BOOL absoluteHeader;
 @property (nonatomic, strong, readonly, nullable) NSNumber *footerHeight;
 @property (nonatomic, readonly) BOOL absoluteFooter;
+@property (nonatomic, readonly) BOOL footerInsetAdjustment;
+@property (nonatomic, readonly) BOOL footerAvoidsKeyboard;
+@property (nonatomic, readonly) CGFloat appliedFooterBottomInset;
 @property (nonatomic, strong, readonly, nullable) NSNumber *peekContentHeight;
 
 @end
@@ -43,12 +46,15 @@ NS_ASSUME_NONNULL_BEGIN
  For peek (-2) detents, calculates based on header + footer height.
  */
 - (CGFloat)detentValueForIndex:(NSInteger)index;
+- (NSInteger)backgroundIndexForPosition:(CGFloat)position displayedIndex:(NSInteger)displayedIndex;
 
 /**
  Returns the height for auto (-1) detents: content + header + footer height.
  An absolute (floating) header or footer contributes no height.
+ A pinned footer contributes only its overlap above the keyboard. UIKit adds
+ the keyboard expansion separately. Pass 0 for the keyboard-free height.
  */
-- (CGFloat)autoHeight;
+- (CGFloat)autoHeightForKeyboardHeight:(CGFloat)keyboardHeight;
 
 /**
  Returns the height for peek (-2) detents: header + footer + peek content height.
@@ -70,6 +76,17 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (CGFloat)resolvedHeightForIndex:(NSInteger)index;
 
+/**
+ Returns the offset learned for this detent itself, or 0 when none is learned.
+ */
+- (CGFloat)learnedOffsetForIndex:(NSInteger)index;
+
+/**
+ Sets the offset this detent is expected to rest with, unless its learned
+ offset is already within a point of it.
+ */
+- (void)assumeOffset:(CGFloat)offset forIndex:(NSInteger)index;
+
 /**
  Finds the segment between detents for a given position.
  Returns YES if position is between two detents, NO if at edges.

package/ios/core/TrueSheetDetentCalculator.mm

@@ -19,7 +19,7 @@
   if (index >= 0 && index < (NSInteger)detents.count) {
     CGFloat value = [detents[index] doubleValue];
     if (value == -1) {
-      return [self autoHeight] / self.delegate.screenHeight;
+      return [self autoHeightForKeyboardHeight:0] / self.delegate.screenHeight;
     }
     if (value == -2) {
       return [self peekHeight] / self.delegate.screenHeight;
@@ -29,10 +29,15 @@
   return 0;
 }
 
-- (CGFloat)autoHeight {
-  // An absolute (floating) header or footer overlaps the content, so it contributes no height
+- (CGFloat)autoHeightForKeyboardHeight:(CGFloat)keyboardHeight {
+  // An absolute (floating) header or footer overlaps the content, so it contributes no height —
+  // unless the footer pads the scrollable, then the content ends above it like a relative footer
   CGFloat headerHeight = self.delegate.absoluteHeader ? 0 : [self.delegate.headerHeight floatValue];
-  CGFloat footerHeight = self.delegate.absoluteFooter ? 0 : [self.delegate.footerHeight floatValue];
+  BOOL floatingFooter = self.delegate.absoluteFooter && !self.delegate.footerInsetAdjustment;
+  CGFloat footerHeight = floatingFooter ? 0 : [self.delegate.footerHeight floatValue];
+  if (self.delegate.absoluteFooter && !floatingFooter && !self.delegate.footerAvoidsKeyboard) {
+    footerHeight -= MIN(keyboardHeight, MAX(0, footerHeight - self.delegate.appliedFooterBottomInset));
+  }
   return [self.delegate.contentHeight floatValue] + headerHeight + footerHeight;
 }
 
@@ -75,13 +80,25 @@
   return detentValue * self.delegate.screenHeight;
 }
 
-- (CGFloat)offsetForIndex:(NSInteger)index {
-  // Use this detent's own offset if available
+- (CGFloat)learnedOffsetForIndex:(NSInteger)index {
   if (index >= 0 && index < (NSInteger)_resolvedDetentOffsets.count) {
-    CGFloat offset = [_resolvedDetentOffsets[index] doubleValue];
-    if (offset != 0)
-      return offset;
+    return [_resolvedDetentOffsets[index] doubleValue];
   }
+  return 0;
+}
+
+- (void)assumeOffset:(CGFloat)offset forIndex:(NSInteger)index {
+  if (index >= 0 && index < (NSInteger)_resolvedDetentOffsets.count &&
+      fabs([_resolvedDetentOffsets[index] doubleValue] - offset) > 1) {
+    _resolvedDetentOffsets[index] = @(offset);
+  }
+}
+
+- (CGFloat)offsetForIndex:(NSInteger)index {
+  // Use this detent's own offset if available
+  CGFloat learnedOffset = [self learnedOffsetForIndex:index];
+  if (learnedOffset != 0)
+    return learnedOffset;
 
   // Fall back to any known offset
   for (NSInteger i = 0; i < (NSInteger)_resolvedDetentOffsets.count; i++) {
@@ -93,6 +110,24 @@
   return 0;
 }
 
+- (NSInteger)backgroundIndexForPosition:(CGFloat)position displayedIndex:(NSInteger)displayedIndex {
+  NSInteger count = self.delegate.detents.count;
+  if (count == 0)
+    return -1;
+
+  CGFloat height = self.delegate.screenHeight - position;
+  NSInteger nextIndex = MAX(0, MIN(displayedIndex, count - 1));
+  CGFloat distance = fabs(height - [self resolvedHeightForIndex:nextIndex]);
+  for (NSInteger index = 0; index < count; index++) {
+    CGFloat nextDistance = fabs(height - [self resolvedHeightForIndex:index]);
+    if (nextDistance < distance) {
+      nextIndex = index;
+      distance = nextDistance;
+    }
+  }
+  return nextIndex;
+}
+
 - (BOOL)findSegmentForPosition:(CGFloat)position outIndex:(NSInteger *)outIndex outProgress:(CGFloat *)outProgress {
   NSArray<NSNumber *> *detents = self.delegate.detents;
   NSInteger count = detents.count;

package/ios/core/TrueSheetDimView.h

@@ -0,0 +1,27 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Dim behind the sheet for a custom color or opacity, which
+ * UISheetPresentationController has no API for. Starts hidden.
+ */
+@interface TrueSheetDimView : UIView
+
+/// Called when the dim is tapped
+@property (nonatomic, copy, nullable) void (^onTap)(void);
+
+/// Adds the dim view behind everything in the presentation container
+- (void)addToView:(UIView *)parentView;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/TrueSheetDimView.mm

@@ -0,0 +1,41 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#import "TrueSheetDimView.h"
+
+@implementation TrueSheetDimView
+
+#pragma mark - Initialization
+
+- (instancetype)init {
+  if (self = [super init]) {
+    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    self.alpha = 0;
+
+    UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(handleTap)];
+    [self addGestureRecognizer:tap];
+  }
+  return self;
+}
+
+#pragma mark - Public
+
+- (void)addToView:(UIView *)parentView {
+  self.frame = parentView.bounds;
+  [parentView insertSubview:self atIndex:0];
+}
+
+#pragma mark - Actions
+
+- (void)handleTap {
+  if (_onTap) {
+    _onTap();
+  }
+}
+
+@end

package/ios/core/TrueSheetGrabberView.mm

@@ -91,6 +91,13 @@ static const CGFloat kHitPaddingVertical = 10.0;
   }
 }
 
+// Pad the pill evenly like the system grabber. The view frame itself stays inside
+// the sheet, since the reveal check reads the frame rather than this rect.
+- (CGRect)accessibilityFrame {
+  CGRect rect = CGRectInset(_vibrancyView.frame, -kHitPaddingHorizontal, -kHitPaddingVertical);
+  return UIAccessibilityConvertFrameToScreenCoordinates(rect, self);
+}
+
 - (void)accessibilityIncrement {
   if (_onIncrement) {
     _onIncrement();
@@ -144,14 +151,17 @@ static const CGFloat kHitPaddingVertical = 10.0;
   CGFloat topMargin = [self effectiveTopMargin];
   CGFloat parentWidth = self.superview ? self.superview.bounds.size.width : UIScreen.mainScreen.bounds.size.width;
 
+  // Keep the frame inside the sheet. A frame above the top edge reads as a clipped element
+  // to VoiceOver, and the sheet reveals it on focus by moving to the next detent.
   CGFloat frameWidth = pillWidth + kHitPaddingHorizontal * 2;
-  CGFloat frameHeight = pillHeight + kHitPaddingVertical * 2;
-  CGFloat frameY = topMargin - kHitPaddingVertical;
+  CGFloat frameY = MAX(0, topMargin - kHitPaddingVertical);
+  CGFloat pillY = topMargin - frameY;
+  CGFloat frameHeight = pillY + pillHeight + kHitPaddingVertical;
 
   self.frame = CGRectMake((parentWidth - frameWidth) / 2.0, frameY, frameWidth, frameHeight);
   self.backgroundColor = UIColor.clearColor;
 
-  CGRect pillRect = CGRectMake(kHitPaddingHorizontal, kHitPaddingVertical, pillWidth, pillHeight);
+  CGRect pillRect = CGRectMake(kHitPaddingHorizontal, pillY, pillWidth, pillHeight);
   _vibrancyView.frame = pillRect;
   _vibrancyView.layer.cornerRadius = [self effectiveCornerRadius];
   _vibrancyView.clipsToBounds = YES;

package/ios/core/TrueSheetKeyboardObserver.h

@@ -26,6 +26,13 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak, nullable) TrueSheetViewController *viewController;
 @property (nonatomic, readonly) CGFloat currentHeight;
 
+/**
+ * What's left of the keyboard's last show/hide animation, so a change landing
+ * outside it (e.g. after a React commit) can finish on the same curve.
+ */
+@property (nonatomic, readonly) NSTimeInterval remainingAnimationDuration;
+@property (nonatomic, readonly) UIViewAnimationOptions animationCurve;
+
 - (void)addDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate;
 - (void)removeDelegate:(id<TrueSheetKeyboardObserverDelegate>)delegate;
 

package/ios/core/TrueSheetKeyboardObserver.mm

@@ -12,15 +12,27 @@
 #import "../TrueSheetViewController.h"
 #import "../utils/UIView+FirstResponder.h"
 
+// Between the minimized keyboard (up to ~180pt) and the shortest docked iPad
+// keyboard (~340pt)
+static const CGFloat kMinimizedKeyboardMaxHeight = 250.0;
+
+static const NSTimeInterval kUnanimatedKeyboardDuration = 0.25;
+
 @implementation TrueSheetKeyboardObserver {
   NSHashTable<id<TrueSheetKeyboardObserverDelegate>> *_delegates;
   CGFloat _currentHeight;
+  CGFloat _pendingMinimizedKeyboardOverlap;
+  CFTimeInterval _animationEndTime;
 }
 
 - (CGFloat)currentHeight {
   return _currentHeight;
 }
 
+- (NSTimeInterval)remainingAnimationDuration {
+  return MAX(0, _animationEndTime - CACurrentMediaTime());
+}
+
 - (instancetype)init {
   if (self = [super init]) {
     _delegates = [NSHashTable weakObjectsHashTable];
@@ -37,14 +49,20 @@
 }
 
 - (void)start {
-  [[NSNotificationCenter defaultCenter] addObserver:self
-                                           selector:@selector(keyboardWillChangeFrame:)
-                                               name:UIKeyboardWillChangeFrameNotification
-                                             object:nil];
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+  [center addObserver:self
+             selector:@selector(keyboardWillChangeFrame:)
+                 name:UIKeyboardWillChangeFrameNotification
+               object:nil];
+  [center addObserver:self selector:@selector(keyboardWillShow:) name:UIKeyboardWillShowNotification object:nil];
+  [center addObserver:self selector:@selector(keyboardWillHide:) name:UIKeyboardWillHideNotification object:nil];
 }
 
 - (void)stop {
-  [[NSNotificationCenter defaultCenter] removeObserver:self name:UIKeyboardWillChangeFrameNotification object:nil];
+  NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+  [center removeObserver:self name:UIKeyboardWillChangeFrameNotification object:nil];
+  [center removeObserver:self name:UIKeyboardWillShowNotification object:nil];
+  [center removeObserver:self name:UIKeyboardWillHideNotification object:nil];
 }
 
 - (void)dealloc {
@@ -59,15 +77,21 @@
   return firstResponder != nil;
 }
 
-- (void)keyboardWillChangeFrame:(NSNotification *)notification {
-  if (_viewController && !_viewController.isTopmostPresentedController) {
-    return;
-  }
-
-  if (![self isFirstResponderWithinSheet]) {
-    return;
+// iPadOS 26 reports its minimized keyboard (the pill left after hiding the
+// keyboard while the input keeps focus) as a short docked keyboard. An input
+// accessory view does stay docked across the bottom edge, so it still counts.
+- (BOOL)isMinimizedKeyboardFrame:(CGRect)frame {
+  if (@available(iOS 26.0, *)) {
+    if (UIDevice.currentDevice.userInterfaceIdiom != UIUserInterfaceIdiomPad) {
+      return NO;
+    }
+    UIView *firstResponder = [_viewController.view findFirstResponder];
+    return frame.size.height < kMinimizedKeyboardMaxHeight && !firstResponder.inputAccessoryView;
   }
+  return NO;
+}
 
+- (void)keyboardWillChangeFrame:(NSNotification *)notification {
   NSDictionary *userInfo = notification.userInfo;
   CGRect keyboardFrame = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
   NSTimeInterval duration = [userInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
@@ -79,13 +103,63 @@
   }
 
   CGRect keyboardFrameInWindow = [window convertRect:keyboardFrame fromWindow:nil];
-  CGFloat keyboardHeight = MAX(0, window.bounds.size.height - keyboardFrameInWindow.origin.y);
+  // A floating iPad keyboard is narrower than the window: it covers no edge and
+  // UIKit doesn't grow the sheet for it, so it counts as hidden. Width only — a
+  // windowed app gets docked frames offset by the window's inset.
+  BOOL floating = CGRectGetWidth(keyboardFrameInWindow) < CGRectGetWidth(window.bounds) - 1;
+  CGFloat keyboardHeight = floating ? 0 : MAX(0, window.bounds.size.height - keyboardFrameInWindow.origin.y);
+  CGFloat minimizedKeyboardOverlap = 0;
+
+  // Not gated on being topmost: UIKit restores (and an app may blur) a sheet's
+  // input while a stacked child is still dismissing over it. A hide reaches
+  // every sheet that rose, even one that no longer holds the first responder.
+  if (keyboardHeight > 0) {
+    if (![self isFirstResponderWithinSheet]) {
+      return;
+    }
+    // The minimized keyboard floats in a corner and covers nothing — treat it
+    // as hidden, and offset the growth UIKit still applies for it.
+    if ([self isMinimizedKeyboardFrame:keyboardFrameInWindow]) {
+      UIView *sheetView = _viewController.view;
+      CGFloat sheetBottom = CGRectGetMaxY([sheetView convertRect:sheetView.bounds toView:nil]);
+      minimizedKeyboardOverlap =
+        MAX(0, MIN(CGRectGetMaxY(keyboardFrameInWindow), sheetBottom) - CGRectGetMinY(keyboardFrameInWindow));
+      keyboardHeight = 0;
+    }
+  }
+
+  // Hiding a full keyboard ends either minimized or fully hidden, and UIKit
+  // only tells which (show or hide) after it has laid out the sheet for it.
+  _pendingMinimizedKeyboardOverlap = 0;
+  if (minimizedKeyboardOverlap > 0 && _currentHeight > 0) {
+    _pendingMinimizedKeyboardOverlap = minimizedKeyboardOverlap;
+    minimizedKeyboardOverlap = 0;
+  }
+
+  CGFloat previousOverlap = _viewController.minimizedKeyboardOverlap;
+  _viewController.minimizedKeyboardOverlap = minimizedKeyboardOverlap;
+
+  if (keyboardHeight == 0 && _currentHeight == 0 && minimizedKeyboardOverlap == previousOverlap) {
+    return;
+  }
+
+  // Docking or undocking the floating keyboard comes unanimated — animate the
+  // footer and scrollable insets ourselves instead of snapping them.
+  if (duration == 0 && (keyboardHeight > 0) != (_currentHeight > 0)) {
+    duration = kUnanimatedKeyboardDuration;
+  }
 
   _currentHeight = keyboardHeight;
+  _animationEndTime = CACurrentMediaTime() + duration;
+  _animationCurve = curve;
 
-  if (keyboardHeight > 0) {
+  // UIKit also moves the sheet as the minimized keyboard comes and goes, by
+  // whatever the detents couldn't absorb — settle again once it's done.
+  if (keyboardHeight > 0 || minimizedKeyboardOverlap != previousOverlap) {
     _viewController.keyboardSheetGrown = YES;
-  } else {
+  }
+
+  if (keyboardHeight == 0) {
     // The sheet stays grown until UIKit finishes the shrink-back animation —
     // clear after it completes, unless the keyboard came back in the meantime.
     __weak __typeof(self) weakSelf = self;
@@ -98,6 +172,8 @@
       });
   }
 
+  _viewController.keyboardHeight = keyboardHeight;
+
   for (id<TrueSheetKeyboardObserverDelegate> delegate in _delegates) {
     if (keyboardHeight > 0) {
       [delegate keyboardWillShow:keyboardHeight duration:duration curve:curve];
@@ -107,6 +183,22 @@
   }
 }
 
+// Shown minimized: UIKit has grown the sheet for it already, take it back.
+- (void)keyboardWillShow:(NSNotification *)notification {
+  if (_pendingMinimizedKeyboardOverlap == 0) {
+    return;
+  }
+
+  _viewController.minimizedKeyboardOverlap = _pendingMinimizedKeyboardOverlap;
+  _pendingMinimizedKeyboardOverlap = 0;
+  _viewController.keyboardSheetGrown = YES;
+  [_viewController invalidateDetents];
+}
+
+- (void)keyboardWillHide:(NSNotification *)notification {
+  _pendingMinimizedKeyboardOverlap = 0;
+}
+
 @end
 
 #endif

package/ios/core/TrueSheetOverlayContainerView.h

@@ -0,0 +1,31 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol TrueSheetOverlayContainerViewDelegate <NSObject>
+- (void)overlayContainerViewDidLayout:(CGSize)size;
+@end
+
+/**
+ * Window-level view hosting an overlay's children.
+ * Touches that miss every child fall through to the views beneath.
+ */
+@interface TrueSheetOverlayContainerView : UIView
+
+@property (nonatomic, weak, nullable) id<TrueSheetOverlayContainerViewDelegate> delegate;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/core/TrueSheetOverlayContainerView.mm

@@ -0,0 +1,35 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "TrueSheetOverlayContainerView.h"
+
+@implementation TrueSheetOverlayContainerView
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    self.backgroundColor = UIColor.clearColor;
+    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  }
+  return self;
+}
+
+- (nullable UIView *)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event {
+  UIView *hit = [super hitTest:point withEvent:event];
+  return hit == self ? nil : hit;
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  [self.delegate overlayContainerViewDidLayout:self.bounds.size];
+}
+
+@end
+
+#endif