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

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,12 +54,28 @@ 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;
   CGFloat _autoDetentHeight;
   CGFloat _peekDetentHeight;
   NSInteger _pendingDetentIndex;
+  NSInteger _displayedBackgroundIndex;
+  BOOL _usesBackgroundEffects;
 
   // Present/dismiss tracking: a display link scoped to the transition
   // coordinator — started alongside the transition, stopped in its completion.
@@ -70,6 +87,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;
@@ -92,6 +114,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (instancetype)init {
   if (self = [super initWithNibName:nil bundle:nil]) {
     _detents = @[ @0.5, @1 ];
+    _detentBackgrounds = @[];
+    _displayedBackgroundIndex = 0;
     _contentHeight = @(0);
     _headerHeight = @(0);
     _footerHeight = @(0);
@@ -99,6 +123,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _grabber = YES;
     _draggable = YES;
     _scrollingExpandsSheet = YES;
+    _footerAvoidsKeyboard = YES;
     _dismissible = YES;
     _dimmed = YES;
     _dimmedDetentIndex = @(0);
@@ -113,7 +138,6 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _activeDetentIndex = -1;
     _pendingDetentIndex = -1;
 
-    _blurInteraction = YES;
     _insetAdjustment = TrueSheetViewInsetAdjustment::Automatic;
     _detentCalculator = [[TrueSheetDetentCalculator alloc] init];
     _detentCalculator.delegate = self;
@@ -202,10 +226,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 +248,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (CGFloat)bottomSafeAreaForHeight:(CGFloat)height {
-  if (UIDevice.currentDevice.userInterfaceIdiom != UIUserInterfaceIdiomPhone) {
+  if (!TrueSheetIsPhoneIdiom()) {
     return 0;
   }
 
@@ -232,52 +265,117 @@ 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 maxHeight = 0;
+
+  for (id detent in self.detents) {
+    if (![detent isKindOfClass:[NSNumber class]]) {
+      continue;
+    }
+
+    CGFloat value = [detent doubleValue];
+    CGFloat height = 0;
+    if (value == -1) {
+      height = [_detentCalculator autoHeightForKeyboardHeight:0] - [self autoDetentBottomInset];
+    } else if (value == -2) {
+      height = [_detentCalculator peekHeight] - [self peekDetentBottomInset];
+    } 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]];
+}
+
+// Re-resolve alongside the keyboard animation as its overlap with the pinned
+// footer changes, including keyboard height changes while already visible.
+- (void)setKeyboardHeight:(CGFloat)keyboardHeight {
+  if (_keyboardHeight == keyboardHeight) {
+    return;
+  }
+  _keyboardHeight = keyboardHeight;
+
+  if (_footerInsetAdjustment && !_footerAvoidsKeyboard && self.isPresented) {
+    [self setupSheetDetentsForSizeChange];
+  }
 }
 
 /**
- * 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 (or an
+ * absolute one padding the scrollable) 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.footerInsetAdjustment) || [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 {
+  if (@available(iOS 27.0, *)) {
+    return NO;
+  }
   if (@available(iOS 26.0, *)) {
     NSNumber *value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"];
     return value.boolValue;
@@ -314,6 +412,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 +525,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 +568,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 +586,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 +664,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     [self restoreWindowAccessibilityElements];
     _isPresented = NO;
     _isWillDismissEmitted = NO;
+    _hasObservedBottomInset = NO;
 
     [_anchorView removeFromSuperview];
     _anchorView = nil;
@@ -561,8 +706,10 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 
   // Dismissing with the keyboard up skips the hide notification — don't let
-  // the stale flag block learning on the next present.
+  // the stale flag block learning on the next present, or a stale height keep
+  // the footer out of the auto detent.
   _keyboardSheetGrown = NO;
+  _keyboardHeight = 0;
 
   [self emitDidDismissEvents];
 }
@@ -575,24 +722,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 +754,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 +881,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 +973,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"];
 }
 
 /**
@@ -933,6 +1125,20 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     }
   }
 
+  if (self.isPresented && !self.isBeingDismissed && !_isWillDismissEmitted && !_usesBackgroundEffects) {
+    NSInteger index = [_detentCalculator backgroundIndexForPosition:position displayedIndex:_displayedBackgroundIndex];
+    if (index != _displayedBackgroundIndex) {
+      _displayedBackgroundIndex = index;
+      [UIView animateWithDuration:0.2
+                            delay:0
+                          options:UIViewAnimationOptionBeginFromCurrentState | UIViewAnimationOptionAllowUserInteraction
+                       animations:^{
+                         [self setupBackground];
+                       }
+                       completion:nil];
+    }
+  }
+
   TrueSheetPositionState state = {
     .position = position,
     .detent = [self interpolatedDetentForPosition:position],
@@ -998,7 +1204,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
  */
 - (void)setupSheetDetentsForSizeChange {
   if (@available(iOS 16.0, *)) {
-    CGFloat autoHeight = [_detentCalculator autoHeight];
+    CGFloat autoHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight];
     CGFloat peekHeight = [_detentCalculator peekHeight];
 
     if (fabs(autoHeight - _autoDetentHeight) < 0.5 && fabs(peekHeight - _peekDetentHeight) < 0.5) {
@@ -1031,7 +1237,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
   [_detentCalculator clearResolvedHeights];
 
-  _autoDetentHeight = [_detentCalculator autoHeight];
+  _autoDetentHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight];
   _peekDetentHeight = [_detentCalculator peekHeight];
 
   for (NSInteger index = 0; index < self.detents.count; index++) {
@@ -1041,6 +1247,20 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   }
 
   [_detentCalculator setDetentCount:self.detents.count];
+  _usesBackgroundEffects = [self canUseBackgroundEffects:detents];
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+  if (@available(iOS 26.1, *)) {
+    if (_usesBackgroundEffects) {
+      for (NSInteger index = 0; index < detents.count; index++) {
+        NSDictionary *entry = [self backgroundForIndex:index];
+        auto blur = entry[@"blur"] ? static_cast<TrueSheetViewBackgroundBlur>([entry[@"blur"] intValue])
+                                   : TrueSheetViewBackgroundBlur::None;
+        detents[index].backgroundEffect = [self backgroundEffectForColor:entry[@"color"] blur:blur];
+      }
+    }
+  }
+#endif
+
   sheet.detents = detents;
 
   if (self.dimmed && [self.dimmedDetentIndex integerValue] == 0) {
@@ -1079,8 +1299,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 +1311,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 +1325,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 +1339,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
@@ -1215,6 +1428,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
 - (void)setupActiveDetentWithIndex:(NSInteger)index {
   _activeDetentIndex = index;
+  _displayedBackgroundIndex = index;
+  [self setupBackground];
   [self applyActiveDetent];
 }
 
@@ -1228,34 +1443,72 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   [self applyActiveDetent];
 }
 
-- (void)setupBackground {
-  auto effectiveBackgroundBlur = self.backgroundBlur;
-  if (@available(iOS 26.0, *)) {
-    // iOS 26+ has default liquid glass effect
-  } else if (effectiveBackgroundBlur == TrueSheetViewBackgroundBlur::None && !self.backgroundColor) {
-    effectiveBackgroundBlur = TrueSheetViewBackgroundBlur::SystemMaterial;
+- (BOOL)canUseBackgroundEffects:(NSArray<UISheetPresentationControllerDetent *> *)detents {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+  if (@available(iOS 26.1, *)) {
+    // Some 26.1 builds omit setters declared in the SDK.
+    if (self.isDesignCompatibilityMode || ![self.sheet respondsToSelector:@selector(setBackgroundEffect:)]) {
+      return NO;
+    }
+    for (UISheetPresentationControllerDetent *detent in detents) {
+      if (![detent respondsToSelector:@selector(setBackgroundEffect:)]) {
+        return NO;
+      }
+    }
+    return YES;
   }
+#endif
+  return NO;
+}
 
-  BOOL hasBlur = effectiveBackgroundBlur != TrueSheetViewBackgroundBlur::None;
+- (NSDictionary *)backgroundForIndex:(NSInteger)index {
+  return index >= 0 && index < self.detentBackgrounds.count ? self.detentBackgrounds[index] : nil;
+}
 
-  _blurView.backgroundBlur = hasBlur ? effectiveBackgroundBlur : TrueSheetViewBackgroundBlur::None;
-  _blurView.blurIntensity = self.blurIntensity;
-  _blurView.blurInteraction = self.blurInteraction;
-  [_blurView applyBlurEffect];
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+- (UIVisualEffect *)backgroundEffectForColor:(UIColor *)color
+                                        blur:(TrueSheetViewBackgroundBlur)blur API_AVAILABLE(ios(26.1)) {
+  if (blur != TrueSheetViewBackgroundBlur::None) {
+    return [UIBlurEffect effectWithStyle:[BlurUtil blurEffectStyleFromEnum:blur]];
+  }
+  return color ? [UIColorEffect effectWithColor:color] : nil;
+}
+#endif
 
+- (void)setupBackground {
 #if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
   if (@available(iOS 26.1, *)) {
-    if (!self.isDesignCompatibilityMode) {
-      if (self.backgroundColor || hasBlur) {
-        self.sheet.backgroundEffect = [UIColorEffect effectWithColor:[UIColor clearColor]];
-      } else {
-        self.sheet.backgroundEffect = nil;
-      }
+    if (_usesBackgroundEffects) {
+      self.sheet.backgroundEffect = [self backgroundEffectForColor:self.backgroundColor blur:self.backgroundBlur];
+      self.view.backgroundColor = nil;
+      _blurView.hidden = YES;
+      _blurView.backgroundBlur = TrueSheetViewBackgroundBlur::None;
+      [_blurView applyBlurEffect];
+      return;
     }
   }
 #endif
 
-  self.view.backgroundColor = self.backgroundColor;
+  NSDictionary *entry = [self backgroundForIndex:_displayedBackgroundIndex];
+  BOOL hasEntry = entry[@"color"] || entry[@"blur"];
+  UIColor *color = hasEntry ? entry[@"color"] : self.backgroundColor;
+  auto effectiveBackgroundBlur =
+    hasEntry ? (entry[@"blur"] ? static_cast<TrueSheetViewBackgroundBlur>([entry[@"blur"] intValue])
+                               : TrueSheetViewBackgroundBlur::None)
+             : self.backgroundBlur;
+  if (@available(iOS 26.0, *)) {
+    // iOS 26+ has default liquid glass effect
+  } else if (effectiveBackgroundBlur == TrueSheetViewBackgroundBlur::None && !color) {
+    effectiveBackgroundBlur = TrueSheetViewBackgroundBlur::SystemMaterial;
+  }
+
+  BOOL hasBlur = effectiveBackgroundBlur != TrueSheetViewBackgroundBlur::None;
+
+  _blurView.hidden = NO;
+  _blurView.backgroundBlur = effectiveBackgroundBlur;
+  [_blurView applyBlurEffect];
+
+  self.view.backgroundColor = hasBlur ? nil : color;
 }
 
 - (void)setupGrabber {
@@ -1302,6 +1555,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
         }];
       } else if (strongSelf.dismissible) {
         [strongSelf.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+      } else {
+        [strongSelf.delegate viewControllerDidAttemptDismiss];
       }
     };
 
@@ -1313,6 +1568,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 {
@@ -1325,8 +1586,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];
@@ -1335,8 +1600,23 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 }
 
 - (BOOL)isAnchored {
-  return self.anchor == TrueSheetViewAnchor::Left || self.anchor == TrueSheetViewAnchor::Right;
+  return self.placement == TrueSheetViewPlacement::Leading || self.placement == TrueSheetViewPlacement::Trailing;
+}
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+- (UISheetPresentationControllerPlacement)preferredPlacement API_AVAILABLE(ios(27.0)) {
+  switch (self.placement) {
+    case TrueSheetViewPlacement::Leading:
+      return UISheetPresentationControllerPlacementLeading;
+    case TrueSheetViewPlacement::Center:
+      return UISheetPresentationControllerPlacementCenter;
+    case TrueSheetViewPlacement::Trailing:
+      return UISheetPresentationControllerPlacementTrailing;
+    case TrueSheetViewPlacement::Automatic:
+      return UISheetPresentationControllerPlacementAutomatic;
+  }
 }
+#endif
 
 - (void)setupAnchorViewInView:(UIView *)parentView {
   if (!parentView)
@@ -1345,6 +1625,18 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   [_anchorView removeFromSuperview];
   _anchorView = nil;
 
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+  // iOS 27 exposes native placement. `sourceView` must stay nil since it overrides `preferredPlacement`.
+  if (@available(iOS 27.0, *)) {
+    if ([self.sheetPresentationController respondsToSelector:@selector(setPreferredPlacement:)]) {
+      self.sheetPresentationController.sourceView = nil;
+      self.sheetPresentationController.preferredPlacement = [self preferredPlacement];
+      return;
+    }
+  }
+#endif
+
+  // Pre-27 has no explicit center, so `center` falls back to the system default like `automatic`.
   if (!self.isAnchored) {
     self.sheetPresentationController.sourceView = nil;
     return;
@@ -1356,7 +1648,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   [parentView addSubview:_anchorView];
 
   NSLayoutAnchor *horizontalAnchor =
-    self.anchor == TrueSheetViewAnchor::Right ? parentView.trailingAnchor : parentView.leadingAnchor;
+    self.placement == TrueSheetViewPlacement::Trailing ? parentView.trailingAnchor : parentView.leadingAnchor;
 
   [NSLayoutConstraint activateConstraints:@[
     [_anchorView.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor],
@@ -1418,6 +1710,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(), ^{