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

package/ios/TrueSheetViewController.mm

@@ -45,6 +45,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (void)restoreWindowAccessibilityElements;
 - (void)setSheetAccessibilityElementsHidden:(BOOL)hidden;
 - (void)setAccessibilityContentElement:(UIView *)contentView;
+- (NSArray *)accessibilityGrabberElements;
 - (void)endInteractiveDismissState;
 - (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
                                       duration:(NSTimeInterval)duration
@@ -53,6 +54,20 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
 @end
 
+// VoiceOver delivers the two-finger Z (escape) gesture by walking up the view
+// hierarchy from the focused element, so the sheet's root view handles it.
+@interface TrueSheetControllerView : UIView
+@property (nonatomic, weak) TrueSheetViewController *controller;
+@end
+
+@implementation TrueSheetControllerView
+
+- (BOOL)accessibilityPerformEscape {
+  return [self.controller accessibilityPerformEscape];
+}
+
+@end
+
 @implementation TrueSheetViewController {
   TrueSheetPositionState _lastEmittedPositionState;
   CGSize _lastReportedSize;
@@ -70,6 +85,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;
@@ -202,10 +222,19 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (CGFloat)screenHeight {
-  UIWindow *window = self.view.window;
+  // In a windowed iPad app (Stage Manager, iPadOS 26 windowing) the window can be shorter than
+  // UIScreen.mainScreen, so prefer the window's height. Some callers run before this controller's
+  // view is attached (e.g. mid-presentation detent resolution), so fall back to the presenter's.
+  UIWindow *window = self.view.window ?: self.presentingViewController.view.window;
   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 +244,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (CGFloat)bottomSafeAreaForHeight:(CGFloat)height {
-  if (UIDevice.currentDevice.userInterfaceIdiom != UIUserInterfaceIdiomPhone) {
+  if (!TrueSheetIsPhoneIdiom()) {
     return 0;
   }
 
@@ -232,49 +261,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 {
@@ -314,6 +395,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
 #pragma mark - View Lifecycle
 
+- (void)loadView {
+  TrueSheetControllerView *view = [[TrueSheetControllerView alloc] init];
+  view.controller = self;
+  self.view = view;
+}
+
 - (void)viewDidLoad {
   [super viewDidLoad];
   self.view.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
@@ -421,6 +508,37 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 }
 
+- (NSArray *)accessibilityGrabberElements {
+  if (_grabberView && !_grabberView.hidden) {
+    return @[ _grabberView ];
+  }
+
+  // The system grabber is an accessibility element UIKit adds to the presented view
+  // (a sibling of our root view). Expose it so VoiceOver can resize or dismiss with it.
+  // UIKit also keeps a transparent bottom grabber there, so skip invisible views.
+  NSMutableArray *elements = [NSMutableArray array];
+  for (UIView *subview in self.presentationController.presentedView.subviews) {
+    if (subview != self.view && subview.isAccessibilityElement && !subview.hidden && subview.alpha > 0) {
+      [elements addObject:subview];
+    }
+  }
+  return elements;
+}
+
+- (BOOL)accessibilityPerformEscape {
+  if (!_isPresented) {
+    return NO;
+  }
+
+  if (!self.dismissible) {
+    [self.delegate viewControllerDidAttemptDismiss];
+    return NO;
+  }
+
+  [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  return YES;
+}
+
 - (void)setAccessibilityContentElement:(UIView *)contentView {
   BOOL hasAccessibilityFooterElements = [contentView isKindOfClass:[TrueSheetContainerView class]] &&
                                         [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements];
@@ -433,12 +551,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   // its accessibilityElements getter recomputes live, so a footer/content subtree
   // that remounts (e.g. swapping a footer button on a state change) stays
   // discoverable instead of leaving this snapshot pointing at destroyed views.
-  NSArray *accessibilityElements;
+  NSMutableArray *accessibilityElements = [[self accessibilityGrabberElements] mutableCopy];
   if (isAccessibilityModal) {
     NSArray *contentElements = contentView.accessibilityElements;
-    accessibilityElements = contentElements.count > 0 ? contentElements : @[ contentView ];
+    [accessibilityElements addObjectsFromArray:contentElements.count > 0 ? contentElements : @[ contentView ]];
   } else {
-    accessibilityElements = @[ contentView ];
+    [accessibilityElements addObject:contentView];
   }
 
   self.view.isAccessibilityElement = NO;
@@ -451,6 +569,15 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     presentedView.accessibilityViewIsModal = isAccessibilityModal;
     presentedView.accessibilityElements = accessibilityElements;
 
+    // The system grabber is a sibling of our root view, so an escape performed while it
+    // is focused walks presentedView → window and never reaches TrueSheetControllerView.
+    if (@available(iOS 17.0, *)) {
+      __weak __typeof(self) weakSelf = self;
+      presentedView.accessibilityPerformEscapeBlock = ^BOOL {
+        return [weakSelf accessibilityPerformEscape];
+      };
+    }
+
     UIWindow *window = self.view.window;
     UIViewController *presentingViewController = [self accessibilityPresentingViewController];
     if (window && presentingViewController.view) {
@@ -520,6 +647,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     [self restoreWindowAccessibilityElements];
     _isPresented = NO;
     _isWillDismissEmitted = NO;
+    _hasObservedBottomInset = NO;
 
     [_anchorView removeFromSuperview];
     _anchorView = nil;
@@ -575,24 +703,26 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     return;
   }
 
-  if (_pendingContentSizeChange || _pendingDetentsChange) {
+  // Mid-drag the frame tracks the finger — never settle or learn from it;
+  // pending changes keep their flags and settle on the first post-drag layout.
+  if ((_pendingContentSizeChange || _pendingDetentsChange) && !_isDragging) {
     _pendingContentSizeChange = NO;
     _pendingDetentsChange = NO;
     [self settleAtDetentIndex:self.currentDetentIndex debug:@"layout"];
-  } else if (!_isDragging) {
-    // Drags emit from the pan handler. A child on top moves this sheet two
-    // ways: an animated collapse/restore step (presenting/dismissing) — emit
-    // the target non-realtime so JS animates to it — or direct per-frame
-    // re-layouts while the child drags, which stay realtime.
+  } else {
+    // A child on top moves this sheet two ways: an animated collapse/restore
+    // step (presenting/dismissing) — emit the target non-realtime so JS
+    // animates to it — or direct per-frame re-layouts while the child drags,
+    // which stay realtime. Mid-drag no child is on top, so drags emit realtime.
     BOOL realtime = self.presentedViewController == nil || !self.isPresentedViewAnimating;
 
     // A layout pass at rest can nudge the frame by a sub-pixel amount
     // (pixel-grid snapping after present), leaving the interpolated index
     // slightly off the whole number. Re-learn when the frame is effectively
     // at the current detent so the drift is absorbed instead of emitted.
-    // The tight threshold keeps real movement (e.g. scroll-driven expansion)
-    // from being absorbed.
-    if (self.presentedViewController == nil && !self.isPresentedViewAnimating) {
+    // The tight threshold keeps real movement (e.g. scroll-driven expansion
+    // or a drag hovering near the detent) from being absorbed.
+    if (!_isDragging && self.presentedViewController == nil && !self.isPresentedViewAnimating) {
       NSInteger index = self.currentDetentIndex;
       CGFloat expectedHeight = [_detentCalculator resolvedHeightForIndex:index];
       CGFloat actualHeight = self.screenHeight - self.currentPosition;
@@ -605,9 +735,46 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 }
 
+// Rotation or an iPad window resize changes the height fractional detents
+// resolve against — re-resolve alongside the transition so the sheet lands on
+// the new height instead of waiting for a content-driven rebuild.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+  [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+
+  if (@available(iOS 16.0, *)) {
+    [coordinator
+      animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        [self.sheet invalidateDetents];
+      }
+                      completion:nil];
+  }
+}
+
+// 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.
@@ -695,7 +862,14 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
       _isDragging = YES;
       break;
     case UIGestureRecognizerStateChanged:
-      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES debug:@"drag change"];
+      // Layout owns the emit while the sheet resizes with the finger (a
+      // layout pass is already queued), and the transition tick owns it
+      // during an interactive dismiss. Translation-only movement (e.g.
+      // dragging down to the first detent) triggers neither — emit here as
+      // the backup.
+      if (!_isTransitioning && !self.presentedView.layer.needsLayout && !self.viewIfLoaded.layer.needsLayout) {
+        [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES debug:@"drag change"];
+      }
       break;
     case UIGestureRecognizerStateEnded:
     case UIGestureRecognizerStateCancelled: {
@@ -780,27 +954,26 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (void)handleTransitionTick {
-  // Interactive dismiss phase (finger down) — the pan handler emits.
-  if (!_isDragging) {
-    CGFloat position = self.livePosition;
-
-    if (self.isBeingDismissed) {
-      // Emit only once the dismiss is committed: on release UIKit moves the
-      // model frame off-screen, while a cancelled drag rewinds it back to the
-      // detent (isBeingDismissed stays YES during the rewind).
-      if (self.currentPosition >= self.screenHeight) {
-        [self emitWillDismissEvents];
-      }
+  // Also covers the interactive dismiss phase (finger down) — layout passes
+  // are skipped while transitioning, so the tick owns position there too.
+  CGFloat position = self.livePosition;
 
-      // Hide blur at the end of dismiss to prevent UIVisualEffectView
-      // from causing a flicker/flash at the bottom edge of the sheet.
-      if (self.screenHeight - position < 1) {
-        _blurView.alpha = 0;
-      }
+  if (self.isBeingDismissed) {
+    // Emit only once the dismiss is committed: on release UIKit moves the
+    // model frame off-screen, while a cancelled drag rewinds it back to the
+    // detent (isBeingDismissed stays YES during the rewind).
+    if (self.currentPosition >= self.screenHeight) {
+      [self emitWillDismissEvents];
     }
 
-    [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition"];
+    // Hide blur at the end of dismiss to prevent UIVisualEffectView
+    // from causing a flicker/flash at the bottom edge of the sheet.
+    if (self.screenHeight - position < 1) {
+      _blurView.alpha = 0;
+    }
   }
+
+  [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition"];
 }
 
 /**
@@ -1079,8 +1252,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 +1264,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];
@@ -1107,8 +1278,13 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
   if (@available(iOS 16.0, *)) {
     NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
-    CGFloat sheetHeight = value * self.screenHeight;
-    return [self customDetentWithIdentifier:detentId height:sheetHeight atIndex:index];
+    // Resolve lazily — detents are built before presentation (no window yet), and
+    // UIKit re-resolves on container size changes (rotation, windowed iPad resize).
+    return [self customDetentWithIdentifier:detentId
+                                    atIndex:index
+                                heightBlock:^CGFloat {
+                                  return value * self.screenHeight;
+                                }];
   } else if (value >= 0.5) {
     return [UISheetPresentationControllerDetent largeDetent];
   } else {
@@ -1116,16 +1292,6 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 }
 
-- (UISheetPresentationControllerDetent *)customDetentWithIdentifier:(NSString *)identifier
-                                                             height:(CGFloat)height
-                                                            atIndex:(NSInteger)index API_AVAILABLE(ios(16.0)) {
-  return [self customDetentWithIdentifier:identifier
-                                  atIndex:index
-                              heightBlock:^CGFloat {
-                                return height;
-                              }];
-}
-
 - (UISheetPresentationControllerDetent *)customDetentWithIdentifier:(NSString *)identifier
                                                             atIndex:(NSInteger)index
                                                         heightBlock:(CGFloat (^)(void))heightBlock
@@ -1246,14 +1412,11 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 #if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
   if (@available(iOS 26.1, *)) {
     if (!self.isDesignCompatibilityMode) {
-      if (self.backgroundColor) {
-        self.sheet.backgroundEffect = [UIColorEffect effectWithColor:self.backgroundColor];
-      } else if (hasBlur) {
+      if (self.backgroundColor || hasBlur) {
         self.sheet.backgroundEffect = [UIColorEffect effectWithColor:[UIColor clearColor]];
       } else {
         self.sheet.backgroundEffect = nil;
       }
-      return;
     }
   }
 #endif
@@ -1305,6 +1468,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
         }];
       } else if (strongSelf.dismissible) {
         [strongSelf.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+      } else {
+        [strongSelf.delegate viewControllerDidAttemptDismiss];
       }
     };
 
@@ -1316,6 +1481,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _grabberView.onIncrement = nil;
     _grabberView.onDecrement = nil;
   }
+
+  // Only the topmost sheet may refresh, or a parent's prop update would steal the
+  // window accessibility override from the child presented over it.
+  if (_isPresented && self.isTopmostPresentedController) {
+    [self setupAccessibilityContainer];
+  }
 }
 
 - (void)handleGrabberTap {
@@ -1328,8 +1499,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     return;
 
   NSInteger nextIndex = (currentIndex + 1) % detentCount;
-  if (nextIndex == 0 && detentCount == 1 && self.dismissible) {
-    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  if (nextIndex == 0 && detentCount == 1) {
+    if (self.dismissible) {
+      [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+    } else {
+      [self.delegate viewControllerDidAttemptDismiss];
+    }
   } else {
     [self.sheet animateChanges:^{
       [self resizeToDetentIndex:nextIndex];
@@ -1421,6 +1596,13 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   return self.dismissible;
 }
 
+// UIKit calls this after shouldDismiss returns NO — the sheet has already
+// bounced back, so JS can confirm and dismiss programmatically (Apple's
+// unsaved-changes pattern).
+- (void)presentationControllerDidAttemptToDismiss:(UIPresentationController *)presentationController {
+  [self.delegate viewControllerDidAttemptDismiss];
+}
+
 - (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier:
   (UISheetPresentationController *)sheetPresentationController {
   dispatch_async(dispatch_get_main_queue(), ^{

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/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

package/ios/events/TrueSheetLifecycleEvents.h

@@ -33,6 +33,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (void)emitDidDismiss:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter;
 
++ (void)emitDismissAttempt:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/events/TrueSheetLifecycleEvents.mm

@@ -66,6 +66,14 @@
   emitter->onDidDismiss({});
 }
 
++ (void)emitDismissAttempt:(std::shared_ptr<const facebook::react::EventEmitter>)eventEmitter {
+  if (!eventEmitter)
+    return;
+
+  auto emitter = std::static_pointer_cast<TrueSheetViewEventEmitter const>(eventEmitter);
+  emitter->onDismissAttempt({});
+}
+
 @end
 
 #endif  // RCT_NEW_ARCH_ENABLED