@lodev09/react-native-true-sheet 4.0.0-beta.24 → 4.0.0-beta.26

package/ios/TrueSheetViewController.mm

@@ -11,10 +11,12 @@
 #import "TrueSheetContentView.h"
 #import "core/TrueSheetBlurView.h"
 #import "core/TrueSheetDetentCalculator.h"
+#import "core/TrueSheetDimView.h"
 #import "core/TrueSheetGrabberView.h"
 #import "utils/BlurUtil.h"
 #import "utils/GestureUtil.h"
 #import "utils/PlatformUtil.h"
+#import "utils/UIView+FirstResponder.h"
 #import "utils/WindowUtil.h"
 
 #import <React/RCTLog.h>
@@ -47,6 +49,10 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (void)setAccessibilityContentElement:(UIView *)contentView;
 - (NSArray *)accessibilityGrabberElements;
 - (void)endInteractiveDismissState;
+- (void)updateHingeState;
+- (void)correctHingeOffsetForIndex:(NSInteger)index;
+- (CGFloat)tabletopHingeEdge;
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height;
 - (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
                                       duration:(NSTimeInterval)duration
                           allowUserInteraction:(BOOL)allowUserInteraction
@@ -76,11 +82,14 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   NSInteger _pendingDetentIndex;
   NSInteger _displayedBackgroundIndex;
   BOOL _usesBackgroundEffects;
+  BOOL _refusedPanDismiss;
 
   // Present/dismiss tracking: a display link scoped to the transition
   // coordinator — started alongside the transition, stopped in its completion.
   CADisplayLink *_transitionLink;
   BOOL _isTransitioning;
+  // Where the sheet rests during the transition: the target on present, the start on dismiss
+  CGFloat _transitionRestPosition;
 
   BOOL _pendingContentSizeChange;
   BOOL _pendingDetentsChange;
@@ -91,6 +100,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   // for the next present (beats the float-threshold guess for re-presents).
   BOOL _hasObservedBottomInset;
   CGFloat _observedBottomInset;
+  BOOL _isRefreshingSafeArea;
 
   BOOL _isInteractiveDismiss;
   CGFloat _interactiveStartPosition;
@@ -99,14 +109,28 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   CADisplayLink *_interactivePositionLink;
 
   __weak TrueSheetViewController *_parentSheetController;
+  __weak UIView *_presenterFirstResponder;
 
   UIView *_anchorView;
 
   __weak UIWindow *_accessibilityWindow;
+  BOOL _appliedAccessibilityFooterElements;
 
   TrueSheetBlurView *_blurView;
   TrueSheetGrabberView *_grabberView;
   TrueSheetDetentCalculator *_detentCalculator;
+  TrueSheetDimView *_dimView;
+
+  // Foldable hinge (iOS 27.1+). Tabletop resolves on demand from the window's
+  // division region; these track the last applied posture to detect changes.
+  BOOL _hingeStateKnown;
+  CGFloat _hingeEdge;
+  NSInteger _hingeRestoreIndex;
+  NSInteger _hingeCorrections;
+  // Offset learned at the hinge, shared by every hinge-placed detent
+  CGFloat _hingeOffset;
+  // Offset each hinge-placed detent last resolved with, checked on settle
+  NSMutableDictionary<NSNumber *, NSNumber *> *_hingeOffsets;
 }
 
 #pragma mark - Initialization
@@ -126,6 +150,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _footerAvoidsKeyboard = YES;
     _dismissible = YES;
     _dimmed = YES;
+    _dimColor = nil;
+    _dimOpacity = nil;
     _dimmedDetentIndex = @(0);
     _presentation = facebook::react::TrueSheetViewPresentation::Page;
     _lastEmittedPositionState = (TrueSheetPositionState){0, 0, 0};
@@ -139,6 +165,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _pendingDetentIndex = -1;
 
     _insetAdjustment = TrueSheetViewInsetAdjustment::Automatic;
+    _hingeRestoreIndex = -1;
+    _hingeOffsets = [NSMutableDictionary dictionary];
     _detentCalculator = [[TrueSheetDetentCalculator alloc] init];
     _detentCalculator.delegate = self;
   }
@@ -225,14 +253,22 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   return self.currentPosition + (presentationY - modelY) + containerTy;
 }
 
+// Some callers run before this controller's view is attached (e.g. mid-presentation
+// detent resolution), so fall back to the presenter's window.
+- (UIWindow *)hostWindow {
+  return self.view.window ?: self.presentingViewController.view.window;
+}
+
 - (CGFloat)screenHeight {
   // 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;
+  // UIScreen.mainScreen, so prefer the window's height.
+  UIWindow *window = self.hostWindow;
   return window ? window.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
 }
 
+// Gap UIKit leaves between a floating sheet (iOS 26+) and the screen's bottom edge
+static const CGFloat TrueSheetFloatingSheetInset = 8;
+
 // 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) {
@@ -316,6 +352,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // wrong leaves the safe-area region unfilled (gap) or double-padded.
   UIView *view = self.viewIfLoaded;
   if (view.window) {
+    // Mid-present, hold the expected inset over a stale zero so the footer
+    // doesn't shrink and regrow — viewDidAppear forces the real value.
+    if (!_isPresented && [self hasStaleBottomSafeArea]) {
+      return [self bottomSafeAreaForHeight:view.bounds.size.height];
+    }
+
     _hasObservedBottomInset = YES;
     _observedBottomInset = view.safeAreaInsets.bottom;
     return _observedBottomInset;
@@ -428,6 +470,81 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   _grabberView = [[TrueSheetGrabberView alloc] init];
   _grabberView.hidden = YES;
   [_grabberView addToView:self.view];
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    __weak __typeof(self) weakSelf = self;
+    UIHingeInteraction *hingeInteraction =
+      [[UIHingeInteraction alloc] initWithUpdateHandler:^(UIHingeInteraction *_, UIHingeInteractionUpdate *__) {
+        // Next run loop, so the division region reflects the new posture
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf updateHingeState];
+        });
+      }];
+    [self.view addInteraction:hingeInteraction];
+  }
+#endif
+}
+
+#pragma mark - Custom Dimming
+
+// UISheetPresentationController has no API for the dim's color or opacity, so a custom
+// color/opacity turns the native dim off and fades in our own view behind the sheet.
+- (BOOL)useCustomDimming {
+  return self.dimmed && (self.dimColor != nil || self.dimOpacity != nil);
+}
+
+- (BOOL)isDimmedAtEveryDetent {
+  return self.dimmed && [self.dimmedDetentIndex integerValue] == 0;
+}
+
+// Like the system dim, fades in between the detent below `dimmedDetentIndex` and the dimmed detent.
+- (CGFloat)dimAlphaForIndex:(CGFloat)index {
+  if (![self useCustomDimming]) {
+    return 0;
+  }
+
+  CGFloat progress = index - [self.dimmedDetentIndex integerValue] + 1;
+  return fmax(0, fmin(1, progress));
+}
+
+// Present and dismiss fade the dim over the whole travel below the resting position.
+- (CGFloat)dimAlphaForPosition:(CGFloat)position index:(CGFloat)index {
+  if (!_isTransitioning || position <= _transitionRestPosition) {
+    return [self dimAlphaForIndex:index];
+  }
+
+  CGFloat travel = self.screenHeight - _transitionRestPosition;
+  CGFloat progress = travel > 0 ? fmax(0, (self.screenHeight - position) / travel) : 0;
+  return [self dimAlphaForIndex:[self interpolatedIndexForPosition:_transitionRestPosition]] * progress;
+}
+
+- (void)setupDimView {
+  UIView *container = self.presentationController.containerView;
+  if (!container || (!_dimView && ![self useCustomDimming])) {
+    return;
+  }
+
+  if (!_dimView) {
+    _dimView = [[TrueSheetDimView alloc] init];
+
+    __weak __typeof(self) weakSelf = self;
+    _dimView.onTap = ^{
+      [weakSelf handleDimViewTap];
+    };
+  }
+
+  // Keep opacity in the color so a transparent dim still receives touches.
+  UIColor *color = self.dimColor ?: [UIColor blackColor];
+  CGFloat opacity = self.dimOpacity ? [self.dimOpacity doubleValue] : 0.5;
+  _dimView.backgroundColor = [color colorWithAlphaComponent:CGColorGetAlpha(color.CGColor) * opacity];
+  [_dimView addToView:container];
+}
+
+- (void)handleDimViewTap {
+  if (self.dismissible) {
+    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  }
 }
 
 - (void)viewWillAppear:(BOOL)animated {
@@ -443,6 +560,22 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       [_parentSheetController setAccessibilityContentElement:self.accessibilityContentView ?: self.view];
     }
 
+    [self setupDimView];
+
+    // A new presentation records the posture it starts in
+    _hingeStateKnown = NO;
+    _hingeRestoreIndex = -1;
+    _hingeOffset = 0;
+
+    // UIKit hides the presenter's keyboard under a sheet dimmed at every detent and
+    // brings it back on dismiss, but custom dimming leaves the native sheet undimmed.
+    if ([self useCustomDimming] && [self isDimmedAtEveryDetent]) {
+      UIView *firstResponder = [presenter.view findFirstResponder];
+      if ([firstResponder resignFirstResponder]) {
+        _presenterFirstResponder = firstResponder;
+      }
+    }
+
     dispatch_async(dispatch_get_main_queue(), ^{
       NSInteger index = self.currentDetentIndex;
       CGFloat position = self.currentPosition;
@@ -471,15 +604,48 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
       [self->_grabberView updateAccessibilityValueWithIndex:index detentCount:self->_detents.count];
       [self settleAtDetentIndex:index debug:@"did present"];
+
+      // Apply a posture change that happened while presenting
+      [self updateHingeState];
     });
 
     [self setupGestureRecognizer];
     _isPresented = YES;
+    [self refreshStaleBottomSafeArea];
   }
 
   [self setupAccessibilityContainer];
 }
 
+/**
+ * A present that overlaps another transition (e.g. re-presenting while a
+ * native stack pops) can leave the root view's bottom safe area at zero, and
+ * UIKit doesn't recompute it until the sheet's frame next changes. Suspect a
+ * zero the presented height says shouldn't be there — a small floating sheet
+ * legitimately has none.
+ */
+- (BOOL)hasStaleBottomSafeArea {
+  UIView *view = self.viewIfLoaded;
+  return view.window && view.safeAreaInsets.bottom <= 0 && [self bottomSafeAreaForHeight:view.bounds.size.height] > 0;
+}
+
+// Toggling additionalSafeAreaInsets forces UIKit to recompute the safe area.
+// The toggle's intermediate value isn't reported, so the footer only sees the
+// settled one.
+- (void)refreshStaleBottomSafeArea {
+  if (![self hasStaleBottomSafeArea]) {
+    return;
+  }
+
+  _isRefreshingSafeArea = YES;
+  UIEdgeInsets insets = self.additionalSafeAreaInsets;
+  self.additionalSafeAreaInsets = UIEdgeInsetsMake(insets.top, insets.left, insets.bottom + 1, insets.right);
+  self.additionalSafeAreaInsets = insets;
+  _isRefreshingSafeArea = NO;
+
+  [self.delegate viewControllerSafeAreaInsetsDidChange];
+}
+
 - (void)setupAccessibilityContainer {
   UIView *contentView = self.accessibilityContentView;
   if (!contentView) {
@@ -489,6 +655,34 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self setAccessibilityContentElement:contentView];
 }
 
+// Only the topmost sheet may refresh, or it would steal the window
+// accessibility override from the child presented over it.
+- (BOOL)canRefreshAccessibilityContainer {
+  return _isPresented && !self.isBeingDismissed && self.isTopmostPresentedController;
+}
+
+- (void)refreshAccessibilityContainer {
+  if (self.canRefreshAccessibilityContainer) {
+    [self setupAccessibilityContainer];
+  }
+}
+
+- (void)refreshAccessibilityContainerIfFooterChanged {
+  // Only a dimmed sheet's boundary depends on the footer
+  if (!_dimmed || !self.canRefreshAccessibilityContainer) {
+    return;
+  }
+
+  UIView *contentView = self.accessibilityContentView;
+  if (![contentView isKindOfClass:[TrueSheetContainerView class]] ||
+      [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements] == _appliedAccessibilityFooterElements) {
+    return;
+  }
+
+  [self setAccessibilityContentElement:contentView];
+  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, nil);
+}
+
 - (UIViewController *)accessibilityPresentingViewController {
   UIViewController *presentingViewController = self.presentingViewController;
   while ([presentingViewController isKindOfClass:[TrueSheetViewController class]] &&
@@ -562,6 +756,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // Footer controls exposed as separate accessibility elements can be skipped
   // by XCTest when the presented sheet is a hard modal accessibility boundary.
   BOOL isAccessibilityModal = _dimmed && !hasAccessibilityFooterElements;
+  _appliedAccessibilityFooterElements = hasAccessibilityFooterElements;
 
   // At a hard modal boundary XCTest skips nested elements, so flatten the
   // container's children into the array. Otherwise expose the container itself:
@@ -656,6 +851,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     [self.delegate viewControllerWillBlur];
     [self.delegate viewControllerWillDismiss];
     [_parentSheetController.delegate viewControllerWillFocus];
+
+    // Restored once the dismiss commits, like UIKit's own keyboard preservation.
+    UIView *firstResponder = _presenterFirstResponder;
+    _presenterFirstResponder = nil;
+    if (!self.presentingViewController.isBeingDismissed) {
+      [firstResponder becomeFirstResponder];
+    }
   }
 }
 
@@ -666,6 +868,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _isWillDismissEmitted = NO;
     _hasObservedBottomInset = NO;
 
+    [_dimView removeFromSuperview];
+    _dimView = nil;
+
     [_anchorView removeFromSuperview];
     _anchorView = nil;
 
@@ -684,13 +889,29 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self restoreWindowAccessibilityElements];
   [self setSheetAccessibilityElementsHidden:YES];
 
-  // Dispatch to allow pan gesture to set _isDragging before checking;
-  // the transition tracker emits when the sheet is transitioning to dismiss
-  dispatch_async(dispatch_get_main_queue(), ^{
-    if (!self->_isDragging) {
-      [self emitWillDismissEvents];
-    }
-  });
+  // Dismissing with a child on top only animates the child out — this sheet
+  // doesn't move and isn't part of that transition, so fade its dim over it.
+  if (self.isBeingDismissed && self.presentedViewController) {
+    [UIView animateWithDuration:self.transitionCoordinator.transitionDuration
+                     animations:^{
+                       self->_dimView.alpha = 0;
+                     }];
+  }
+
+  // A swipe can still be cancelled, so emit once it commits on release. Any
+  // other dismiss (programmatic, outside tap, navigation) is already committed.
+  id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
+  if (coordinator.isInteractive) {
+    __weak __typeof(self) weakSelf = self;
+    [coordinator
+      notifyWhenInteractionChangesUsingBlock:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+        if (!context.isCancelled) {
+          [weakSelf emitWillDismissEvents];
+        }
+      }];
+  } else {
+    [self emitWillDismissEvents];
+  }
 
   [self setupTransitionTracker];
 }
@@ -710,6 +931,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // the footer out of the auto detent.
   _keyboardSheetGrown = NO;
   _keyboardHeight = 0;
+  _minimizedKeyboardOverlap = 0;
 
   [self emitDidDismissEvents];
 }
@@ -766,7 +988,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
         [self.sheet invalidateDetents];
       }
-                      completion:nil];
+      completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        // Rotating a half-open foldable swaps between book and tabletop
+        [self updateHingeState];
+      }];
   }
 }
 
@@ -779,7 +1004,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   // Mid-dismiss the frame moves off-screen and reports transient insets —
   // don't let them pollute the observed value (matches viewDidLayoutSubviews).
-  if (!self.isBeingDismissed) {
+  if (!self.isBeingDismissed && !_isRefreshingSafeArea) {
     [self.delegate viewControllerSafeAreaInsetsDidChange];
   }
 }
@@ -807,6 +1032,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     }
   }
 
+  // The hinge callback can run before the division region updates; the
+  // relayout UIKit does for the posture change always sees the new region.
+  [self updateHingeState];
+
   if (_pendingDetentIndex >= 0) {
     NSInteger pendingIndex = _pendingDetentIndex;
     _pendingDetentIndex = -1;
@@ -928,6 +1157,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 
   _isTransitioning = YES;
+  _transitionRestPosition = self.isBeingDismissed ? self.livePosition : self.currentPosition;
 
   // Learn the resolver-vs-actual offset before emitting transition positions so
   // the interpolated index lands exactly on the target detent. The presented
@@ -963,10 +1193,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       // Settle after a present, cancelled dismiss, or detent-snap transition.
       // Delayed because the presentedView frame isn't final until UIKit
       // completes its layout pass after the transition animation — learning
-      // here absorbs any sub-pixel drift since the earlier learns.
+      // here absorbs any sub-pixel drift since the earlier learns. A dismiss
+      // cancelled mid-drag leaves the finger down, so the drag end settles instead.
       if (strongSelf->_isPresented && !strongSelf.isBeingDismissed) {
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-          [strongSelf settleAtDetentIndex:strongSelf.currentDetentIndex debug:@"transition end"];
+          if (!strongSelf->_isDragging) {
+            [strongSelf settleAtDetentIndex:strongSelf.currentDetentIndex debug:@"transition end"];
+          }
         });
       }
     }];
@@ -978,13 +1211,6 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   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];
-    }
-
     // 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) {
@@ -1005,6 +1231,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // measured frame; the next unobstructed settle learns.
   if (self.presentedViewController == nil) {
     [self learnOffsetForDetentIndex:index];
+    [self correctHingeOffsetForIndex:index];
   }
 
   [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:debug];
@@ -1145,6 +1372,11 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     .index = [self interpolatedIndexForPosition:position],
   };
 
+  // A child on top only pushes this sheet back, its detent stays.
+  if (!presented) {
+    _dimView.alpha = [self dimAlphaForPosition:position index:state.index];
+  }
+
   // Settle (non-realtime) emits are authoritative and bypass the dedupe — a
   // learn right before them can correct the interpolated index by less than
   // the tolerance, and the corrected value must still reach JS.
@@ -1159,7 +1391,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 }
 
 - (void)learnOffsetForDetentIndex:(NSInteger)index {
-  if (_keyboardSheetGrown) {
+  if (_keyboardSheetGrown || _minimizedKeyboardOverlap > 0) {
     return;
   }
   [_detentCalculator learnOffsetForDetentIndex:index];
@@ -1193,6 +1425,146 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   return [_detentCalculator detentValueForIndex:index];
 }
 
+#pragma mark - Hinge
+
+/**
+ * Bottom edge (window coordinates) of an active horizontal fold, or 0 when the
+ * device isn't in tabletop. The division region is only active while the hinge
+ * is partially open, so this also excludes flat and closed postures.
+ */
+- (CGFloat)tabletopHingeEdge {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    UIWindow *window = self.hostWindow;
+    for (UIViewReservedRegion *region in [window reservedRegionsOfKind:[UIViewReservedRegionKind divisionRegionKind]]) {
+      CGRect frame = region.frame;
+      if (region.isActive && frame.size.width > frame.size.height) {
+        return CGRectGetMaxY(frame);
+      }
+    }
+  }
+#endif
+  return 0;
+}
+
+/**
+ * Gap between a hinge-placed detent's resolved height and the sheet's actual top
+ * edge: UIKit adds the bottom safe area, plus the floating sheet's inset. Every
+ * hinge-placed detent rests at the same height, so they share one offset — the
+ * first settle at the hinge learns it.
+ */
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height {
+  if (_hingeOffset > 0) {
+    return _hingeOffset;
+  }
+
+  return [self bottomSafeAreaForHeight:height] + TrueSheetFloatingSheetInset;
+}
+
+// A hinge-placed detent resolved with an off estimate lands a few points off
+// the hinge — re-resolve once the settle has learned the real offset.
+- (void)correctHingeOffsetForIndex:(NSInteger)index {
+  NSNumber *usedOffset = _hingeOffsets[@(index)];
+  if (!usedOffset || _hingeCorrections >= 2) {
+    return;
+  }
+
+  CGFloat learnedOffset = [_detentCalculator learnedOffsetForIndex:index];
+  if (learnedOffset == 0 || fabs(learnedOffset - usedOffset.doubleValue) <= 1) {
+    return;
+  }
+
+  _hingeOffset = learnedOffset;
+  _hingeCorrections++;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self invalidateDetentsAnimated];
+  });
+}
+
+- (void)invalidateDetentsAnimated {
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      self->_pendingContentSizeChange = YES;
+      [self.sheet invalidateDetents];
+    }];
+  }
+}
+
+/**
+ * Re-resolves hinge-placed detents when the posture changes, and runs 'snap':
+ * entering tabletop moves the sheet to the hinge detent, leaving it restores the
+ * previous detent if the sheet is still on the hinge. The posture a presentation
+ * starts in only records state, so presenting while already in tabletop doesn't
+ * jump the sheet. A change while presenting, dismissing, or dragging stays
+ * pending until the sheet is at rest again.
+ */
+- (void)updateHingeState {
+  NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+  if (hingeIndex < 0 && self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::None) {
+    return;
+  }
+
+  // Covered by a full-screen presentation, the sheet has no window to read the posture from
+  if (!self.viewIfLoaded.window) {
+    return;
+  }
+
+  CGFloat edge = [self tabletopHingeEdge];
+  if (!_hingeStateKnown) {
+    _hingeStateKnown = YES;
+    _hingeEdge = edge;
+    return;
+  }
+
+  if (!self.isPresented || self.isBeingDismissed || _isDragging || fabs(edge - _hingeEdge) < 0.5) {
+    return;
+  }
+
+  BOOL entered = edge > 0 && _hingeEdge == 0;
+  BOOL left = edge == 0 && _hingeEdge > 0;
+  _hingeEdge = edge;
+  _hingeOffset = 0;
+  _hingeCorrections = 0;
+
+  NSInteger targetIndex = -1;
+  NSInteger detentCount = (NSInteger)self.detents.count;
+  BOOL snaps =
+    self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::Snap && hingeIndex >= 0 && hingeIndex < detentCount;
+  if (entered && snaps) {
+    _hingeRestoreIndex = self.currentDetentIndex;
+    targetIndex = hingeIndex;
+  } else if (left && _hingeRestoreIndex >= 0) {
+    // Keep a detent the user picked while folded
+    if (snaps && self.currentDetentIndex == hingeIndex) {
+      targetIndex = MIN(_hingeRestoreIndex, detentCount - 1);
+    }
+    _hingeRestoreIndex = -1;
+  }
+
+  // A resize settles through the pending detent change
+  BOOL resizes = targetIndex >= 0 && targetIndex != self.activeDetentIndex;
+
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      [self.sheet invalidateDetents];
+      if (resizes) {
+        [self resizeToDetentIndex:targetIndex];
+      }
+    }];
+  }
+
+  // UIKit often re-resolves detents for the posture change on its own before
+  // this runs, so the invalidation above triggers no layout pass to settle in.
+  // Settle once the frame is final, same as a pending detent change.
+  if (!resizes) {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+      if (self.isPresented && !self.isBeingDismissed && !self->_isDragging && !self->_isTransitioning) {
+        [self settleAtDetentIndex:self.currentDetentIndex debug:@"hinge"];
+      }
+    });
+  }
+}
+
 #pragma mark - Sheet Configuration
 
 /**
@@ -1214,12 +1586,19 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _autoDetentHeight = autoHeight;
     _peekDetentHeight = peekHeight;
 
+    [self invalidateDetentsAnimated];
+  }
+  // iOS 15: detents are fixed medium/large — size changes can't affect them.
+}
+
+// Re-resolves the detents in place, e.g. when an input to the resolver
+// changes after UIKit has already laid out the sheet.
+- (void)invalidateDetents {
+  if (@available(iOS 16.0, *)) {
     [self.sheet animateChanges:^{
-      self->_pendingContentSizeChange = YES;
       [self.sheet invalidateDetents];
     }];
   }
-  // iOS 15: detents are fixed medium/large — size changes can't affect them.
 }
 
 - (void)setupSheetDetentsForDetentsChange {
@@ -1236,6 +1615,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
   [_detentCalculator clearResolvedHeights];
+  _hingeCorrections = 0;
 
   _autoDetentHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight];
   _peekDetentHeight = [_detentCalculator peekHeight];
@@ -1263,7 +1643,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   sheet.detents = detents;
 
-  if (self.dimmed && [self.dimmedDetentIndex integerValue] == 0) {
+  if ([self useCustomDimming]) {
+    sheet.largestUndimmedDetentIdentifier = sheet.detents.lastObject.identifier;
+  } else if ([self isDimmedAtEveryDetent]) {
     sheet.largestUndimmedDetentIdentifier = nil;
   } else {
     sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
@@ -1356,24 +1738,66 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
                                              : maxDetentValue;
 
                         CGFloat adjustedHeight = height - bottomAdjustment;
+                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
+
+                        // Tabletop: the hinge detent rests on the hinge, and 'avoid'/'snap'
+                        // cap every detent there.
+                        BOOL avoidsHinge = self.foldOptions.hingeBehavior != TrueSheetViewHingeBehavior::None;
+                        NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+                        BOOL hasHingeDetent = hingeIndex >= 0 && hingeIndex <= lastIndex;
+                        CGFloat hingeEdge = (hasHingeDetent || avoidsHinge) ? [self tabletopHingeEdge] : 0;
+                        CGFloat hingeOffset = 0;
+                        CGFloat hingeHeight = 0;
+                        if (hingeEdge > 0) {
+                          CGFloat panelHeight = self.screenHeight - hingeEdge;
+                          hingeOffset = [self hingeOffsetForHeight:panelHeight];
+                          hingeHeight = panelHeight - hingeOffset;
+                          if (hasHingeDetent) {
+                            // Lower detents stay below the hinge detent and higher ones above
+                            // it, so the detents keep their order
+                            CGFloat hingeDetentHeight =
+                              avoidsHinge ? hingeHeight - (lastIndex - hingeIndex) : hingeHeight;
+                            if (index == hingeIndex) {
+                              adjustedHeight = hingeHeight;
+                            } else if (index < hingeIndex) {
+                              adjustedHeight = fmin(adjustedHeight, hingeDetentHeight - (hingeIndex - index));
+                            } else {
+                              adjustedHeight = fmax(adjustedHeight, hingeDetentHeight + (index - hingeIndex));
+                            }
+                          }
+                          if (avoidsHinge) {
+                            maxValue = fmin(maxValue, hingeHeight);
+                          }
+                        }
 
                         // Only the last detent may occupy the full maximum. Two detents
                         // resolving to the same height (e.g. a capped auto and 1) make
                         // UIKit skip the stack's deck animation when presenting a child
                         // sheet and snap the sheet behind into place instead.
-                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
                         if (adjustedHeight >= maxValue && index < lastIndex) {
                           maxValue -= lastIndex - index;
                         }
 
                         CGFloat resolved = fmin(adjustedHeight, maxValue);
 
+                        // Detents within the collapse spacing of the hinge are hinge-placed.
+                        // They rest with the hinge offset, so position events map them right
+                        // before the first settle there.
+                        if (hingeHeight > 0 && fabs(resolved - hingeHeight) <= lastIndex + 0.5) {
+                          self->_hingeOffsets[@(index)] = @(hingeOffset);
+                          [self->_detentCalculator assumeOffset:hingeOffset forIndex:index];
+                        } else {
+                          [self->_hingeOffsets removeObjectForKey:@(index)];
+                        }
+
                         NSMutableArray *heights = self->_detentCalculator.resolvedDetentHeights;
                         if (heights && index >= 0 && index < (NSInteger)heights.count) {
                           heights[index] = @(resolved);
                         }
 
-                        return resolved;
+                        // Recorded uncompensated above: UIKit adds the overlap back on
+                        // top. A sheet shorter than the overlap still grows by the rest.
+                        return fmax(resolved - self.minimizedKeyboardOverlap, 0);
                       }];
 }
 
@@ -1569,11 +1993,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _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];
-  }
+  [self refreshAccessibilityContainer];
 }
 
 - (void)handleGrabberTap {
@@ -1702,18 +2122,55 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   [self setupBackground];
   [self setupGrabber];
+
+  // Dim props changed while presented. A hidden custom dim stays until dismiss;
+  // at alpha 0 it no longer takes touches.
+  if (_isPresented) {
+    [self setupDimView];
+    _dimView.alpha = [self dimAlphaForIndex:self.currentDetentIndex];
+  }
 }
 
 #pragma mark - UISheetPresentationControllerDelegate
 
 - (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController {
-  return self.dismissible;
+  // A sheet that can't be dragged can't be swiped away either, including by
+  // pulling down its scroll view: refuse a dismissal while any pan is under
+  // way, and keep the one from a tap outside the sheet. Reset on every call:
+  // UIKit skips didAttemptToDismiss for a short pull.
+  _refusedPanDismiss =
+    self.dismissible && !self.draggable && [self hasActivePanInView:presentationController.containerView];
+  return self.dismissible && !_refusedPanDismiss;
+}
+
+- (BOOL)hasActivePanInView:(UIView *)view {
+  if (!view) {
+    return NO;
+  }
+  for (UIGestureRecognizer *recognizer in view.gestureRecognizers ?: @[]) {
+    if ([recognizer isKindOfClass:[UIPanGestureRecognizer class]] &&
+        (recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateChanged)) {
+      return YES;
+    }
+  }
+  for (UIView *subview in view.subviews) {
+    if ([self hasActivePanInView:subview]) {
+      return YES;
+    }
+  }
+  return NO;
 }
 
 // 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 {
+  // A swipe refused only because the sheet can't be dragged isn't an attempt
+  // to dismiss a non-dismissible sheet.
+  if (_refusedPanDismiss) {
+    _refusedPanDismiss = NO;
+    return;
+  }
   [self.delegate viewControllerDidAttemptDismiss];
 }