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

package/ios/TrueSheetView.mm

@@ -13,6 +13,7 @@
 #import "TrueSheetContentView.h"
 #import "TrueSheetFooterView.h"
 #import "TrueSheetModule.h"
+#import "TrueSheetOverlayView.h"
 #import "TrueSheetViewController.h"
 #import "core/RNScreensEventObserver.h"
 #import "events/TrueSheetDragEvents.h"
@@ -53,7 +54,7 @@ using namespace facebook::react;
   NSInteger _initialDetentIndex;
   TrueSheetViewInsetAdjustment _insetAdjustment;
   ScrollableOptions *_scrollableOptions;
-  BOOL _hasAutoDetent;
+  NSInteger _scrollableHandle;
   BOOL _initialDetentAnimated;
   BOOL _isSheetUpdatePending;
   BOOL _pendingLayoutUpdate;
@@ -63,6 +64,9 @@ using namespace facebook::react;
   BOOL _pendingMountEvent;
   BOOL _pendingSizeChange;
   BOOL _pendingPropsUpdate;
+  BOOL _isPresentPending;
+  NSUInteger _pendingPresentGeneration;
+  TrueSheetCompletionBlock _pendingPresentCompletion;
   NSArray *_pendingDetents;
   RNScreensEventObserver *_screensEventObserver;
 }
@@ -124,13 +128,38 @@ using namespace facebook::react;
 
   UIViewController *vc = [self findPresentingViewController];
 
-  // Only present if the view controller is in the same window and not being dismissed
-  if (!vc || vc.view.window != self.window || _controller.isBeingDismissed) {
+  // Only present if the view controller is in the same window
+  if (!vc || vc.view.window != self.window) {
     // Animate next time when sheet finally moves to the correct window
     _initialDetentAnimated = YES;
     return;
   }
 
+  // A sheet still animating out of the presenter (e.g. our own controller,
+  // recycled mid-dismissal) blocks presentation — retry once its transition ends.
+  UIViewController *dismissing = vc.presentedViewController;
+  if (dismissing && dismissing.isBeingDismissed) {
+    _initialDetentAnimated = YES;
+
+    __weak __typeof(self) weakSelf = self;
+    void (^retry)(void) = ^{
+      dispatch_async(dispatch_get_main_queue(), ^{
+        [weakSelf presentInitialIfNeeded];
+      });
+    };
+
+    id<UIViewControllerTransitionCoordinator> coordinator = dismissing.transitionCoordinator;
+    if (coordinator) {
+      [coordinator animateAlongsideTransition:nil
+                                   completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                     retry();
+                                   }];
+    } else {
+      retry();
+    }
+    return;
+  }
+
   _didInitiallyPresent = YES;
 
   // Deferred a runloop turn so sibling mounts from the current transaction
@@ -157,6 +186,8 @@ using namespace facebook::react;
   [_screensEventObserver stopObserving];
   _screensEventObserver = nil;
 
+  [self cancelPendingPresent];
+
   if (_controller && _controller.presentingViewController) {
     // Find the root presenting controller to dismiss the entire stack
     UIViewController *root = _controller.presentingViewController;
@@ -175,8 +206,6 @@ using namespace facebook::react;
 
   [_snapshotView removeFromSuperview];
   _snapshotView = nil;
-
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
 }
 
 #pragma mark - RCTComponentViewProtocol
@@ -185,6 +214,15 @@ using namespace facebook::react;
   return concreteComponentDescriptorProvider<TrueSheetViewComponentDescriptor>();
 }
 
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+
+  // RN 0.88+ resets layout metrics on recycle, so the next mount force-applies
+  // `hidden` from the display type and would reveal this host over the screen.
+  self.hidden = YES;
+}
+
 - (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
   [super updateProps:props oldProps:oldProps];
 
@@ -192,12 +230,8 @@ using namespace facebook::react;
 
   // Detents (-1 represents "auto")
   NSMutableArray *detents = [NSMutableArray new];
-  _hasAutoDetent = NO;
   for (const auto &detent : newProps.detents) {
     [detents addObject:@(detent)];
-    if (detent == -1) {
-      _hasAutoDetent = YES;
-    }
   }
 
   if (oldProps) {
@@ -216,14 +250,29 @@ using namespace facebook::react;
   // Background color
   _controller.backgroundColor = RCTUIColorFromSharedColor(newProps.backgroundColor);
 
+  NSMutableArray<NSDictionary *> *detentBackgrounds = [NSMutableArray new];
+  ContextContainer contextContainer;
+  PropsParserContext parserContext{-1, contextContainer};
+  for (const auto &entry : newProps.detentBackgrounds) {
+    NSMutableDictionary *background = [NSMutableDictionary new];
+    UIColor *color = RCTUIColorFromSharedColor(entry.color);
+    if (color) {
+      background[@"color"] = color;
+    }
+    if (!entry.blur.empty()) {
+      auto blur = TrueSheetViewBackgroundBlur::None;
+      fromRawValue(parserContext, RawValue(entry.blur), blur);
+      background[@"blur"] = @(static_cast<int>(blur));
+    }
+    [detentBackgrounds addObject:background];
+  }
+  if (![_controller.detentBackgrounds isEqualToArray:detentBackgrounds]) {
+    _controller.detentBackgrounds = detentBackgrounds;
+  }
+
   // Blur tint
   _controller.backgroundBlur = newProps.backgroundBlur;
 
-  // Blur options
-  const auto &blurOpts = newProps.blurOptions;
-  _controller.blurIntensity = blurOpts.intensity >= 0 ? @(blurOpts.intensity) : nil;
-  _controller.blurInteraction = blurOpts.interaction;
-
   // Corner radius
   _controller.cornerRadius = newProps.cornerRadius < 0 ? nil : @(newProps.cornerRadius);
 
@@ -233,8 +282,9 @@ using namespace facebook::react;
   // Content width
   _controller.maxContentWidth = newProps.maxContentWidth != 0.0 ? @(newProps.maxContentWidth) : nil;
 
-  // Anchor
-  _controller.anchor = newProps.anchor;
+  _controller.placement = newProps.placement;
+
+  _controller.foldOptions = newProps.foldOptions;
 
   _controller.grabber = newProps.grabber;
 
@@ -269,6 +319,8 @@ using namespace facebook::react;
   _controller.dismissible = newProps.dismissible;
   _controller.draggable = newProps.draggable;
   _controller.dimmed = newProps.dimmed;
+  _controller.dimOpacity = newProps.dimOpacity < 0 ? nil : @(newProps.dimOpacity);
+  _controller.dimColor = RCTUIColorFromSharedColor(newProps.dimColor);
 
   if (newProps.dimmedDetentIndex >= 0) {
     _controller.dimmedDetentIndex = @(newProps.dimmedDetentIndex);
@@ -277,33 +329,38 @@ using namespace facebook::react;
   _initialDetentIndex = newProps.initialDetentIndex;
   _initialDetentAnimated = newProps.initialDetentAnimated;
 
-  const auto &scrollableOpts = newProps.scrollableOptions;
-  BOOL scrollingExpandsSheet = scrollableOpts.scrollingExpandsSheet;
-  auto topEdgeEffect = scrollableOpts.topScrollEdgeEffect;
-  auto bottomEdgeEffect = scrollableOpts.bottomScrollEdgeEffect;
-  BOOL hasScrollableOptions = scrollableOpts.keyboardScrollOffset > 0 || !scrollingExpandsSheet ||
-                              topEdgeEffect != TrueSheetViewTopScrollEdgeEffect::Hidden ||
-                              bottomEdgeEffect != TrueSheetViewBottomScrollEdgeEffect::Hidden;
-
-  if (hasScrollableOptions) {
-    ScrollableOptions *options = [[ScrollableOptions alloc] init];
-    options.keyboardScrollOffset = scrollableOpts.keyboardScrollOffset;
-    options.scrollingExpandsSheet = scrollingExpandsSheet;
-    options.topScrollEdgeEffect = topEdgeEffect;
-    options.bottomScrollEdgeEffect = bottomEdgeEffect;
-    _scrollableOptions = options;
-  } else {
-    _scrollableOptions = nil;
-  }
+  _scrollableHandle = newProps.scrollableHandle;
 
-  _controller.scrollingExpandsSheet = scrollingExpandsSheet;
+  const auto &scrollableOpts = newProps.scrollableOptions;
+  ScrollableOptions *options = [[ScrollableOptions alloc] init];
+  options.contentInsetAdjustment = scrollableOpts.contentInsetAdjustment;
+  options.keyboardScrollOffset = scrollableOpts.keyboardScrollOffset;
+  options.keyboardOffset = scrollableOpts.keyboardOffset;
+  options.scrollingExpandsSheet = scrollableOpts.scrollingExpandsSheet;
+  options.topScrollEdgeEffect = scrollableOpts.topScrollEdgeEffect;
+  options.bottomScrollEdgeEffect = scrollableOpts.bottomScrollEdgeEffect;
+
+  // nil while every option is at its default
+  BOOL hasScrollableOptions = options.keyboardScrollOffset > 0 || options.keyboardOffset != 0 ||
+                              !options.scrollingExpandsSheet ||
+                              options.contentInsetAdjustment != TrueSheetViewContentInsetAdjustment::Automatic ||
+                              options.topScrollEdgeEffect != TrueSheetViewTopScrollEdgeEffect::Hidden ||
+                              options.bottomScrollEdgeEffect != TrueSheetViewBottomScrollEdgeEffect::Hidden;
+  _scrollableOptions = hasScrollableOptions ? options : nil;
+
+  _controller.scrollingExpandsSheet = options.scrollingExpandsSheet;
 
   _controller.absoluteHeader = newProps.headerOptions.position == TrueSheetViewPosition::Absolute;
   _controller.absoluteFooter = newProps.footerOptions.footerPosition == TrueSheetViewFooterPosition::Absolute;
+  _controller.footerInsetAdjustment =
+    options.footerInsetAdjustment && _controller.absoluteFooter && _scrollableHandle > 0;
 
   CGFloat footerKeyboardOffset = newProps.footerOptions.keyboardOffset;
-  if (_controller.footerKeyboardOffset != footerKeyboardOffset) {
+  BOOL footerAvoidsKeyboard = newProps.footerOptions.avoidKeyboard;
+  if (_controller.footerKeyboardOffset != footerKeyboardOffset ||
+      _controller.footerAvoidsKeyboard != footerAvoidsKeyboard) {
     _controller.footerKeyboardOffset = footerKeyboardOffset;
+    _controller.footerAvoidsKeyboard = footerAvoidsKeyboard;
     [_containerView updateFooterKeyboardOffset];
   }
 
@@ -366,7 +423,8 @@ using namespace facebook::react;
   [self setupScrollable];
 
   if (_controller.isPresented) {
-    [self applySheetPropsUpdate];
+    _pendingPropsUpdate = YES;
+    [self setupSheetDetentsForSizeChange];
   } else if (_controller.isBeingPresented) {
     _pendingPropsUpdate = YES;
   } else if (_initialDetentIndex >= 0) {
@@ -380,7 +438,40 @@ using namespace facebook::react;
 - (void)prepareForRecycle {
   [super prepareForRecycle];
 
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
+  // Pooled mid-dismissal: the next mount can reuse this host — and its
+  // controller — while the previous sheet is still animating out. Detach until
+  // that transition ends so its tail (didBlur, didDismiss, position) can't reach
+  // the new mount, then hand the controller back and let auto-present retry.
+  if (_controller.isBeingDismissed) {
+    _controller.delegate = nil;
+
+    __weak __typeof(self) weakSelf = self;
+    void (^reattach)(void) = ^{
+      dispatch_async(dispatch_get_main_queue(), ^{
+        __typeof(self) strongSelf = weakSelf;
+        if (!strongSelf)
+          return;
+
+        strongSelf->_controller.delegate = strongSelf;
+        strongSelf->_controller.activeDetentIndex = -1;
+        if (strongSelf.window) {
+          [strongSelf presentInitialIfNeeded];
+        }
+      });
+    };
+
+    id<UIViewControllerTransitionCoordinator> coordinator = _controller.transitionCoordinator;
+    if (coordinator) {
+      [coordinator animateAlongsideTransition:nil
+                                   completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                     reattach();
+                                   }];
+    } else {
+      reattach();
+    }
+  }
+
+  [self cancelPendingPresent];
 
   _lastStateSize = CGSizeZero;
   _didInitiallyPresent = NO;
@@ -421,7 +512,6 @@ using namespace facebook::react;
   [_touchHandler attachToView:_containerView];
   [_controller.view addSubview:_containerView];
   [_controller.view bringSubviewToFront:_containerView];
-  _containerView.accessibilityViewIsModal = YES;
   _controller.accessibilityContentView = _containerView;
   [_controller setupAccessibilityContainer];
 
@@ -476,7 +566,7 @@ using namespace facebook::react;
 - (void)presentAtIndex:(NSInteger)index
               animated:(BOOL)animated
             completion:(nullable TrueSheetCompletionBlock)completion {
-  if (_controller.isBeingPresented || _controller.isPresented) {
+  if (_controller.isBeingPresented || _controller.isPresented || _isPresentPending) {
     RCTLogWarn(@"TrueSheet: sheet is already presented. Use resize() to change detent.");
     if (completion) {
       completion(YES, nil);
@@ -498,11 +588,41 @@ using namespace facebook::react;
     return;
   }
 
+  // A controller still animating out of the presenter (e.g. a navigation modal
+  // closing) makes UIKit queue this presentation, so everything measured below
+  // goes stale before it starts. Present once that transition ends.
+  UIViewController *dismissing = presentingViewController.presentedViewController;
+  id<UIViewControllerTransitionCoordinator> dismissCoordinator =
+    dismissing.isBeingDismissed ? dismissing.transitionCoordinator : nil;
+  if (dismissCoordinator) {
+    _isPresentPending = YES;
+    _pendingPresentCompletion = completion;
+    NSUInteger generation = ++_pendingPresentGeneration;
+
+    __weak __typeof(self) weakSelf = self;
+    [dismissCoordinator
+      animateAlongsideTransition:nil
+                      completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                        dispatch_async(dispatch_get_main_queue(), ^{
+                          __typeof(self) strongSelf = weakSelf;
+                          if (!strongSelf || !strongSelf->_isPresentPending ||
+                              strongSelf->_pendingPresentGeneration != generation)
+                            return;
+
+                          TrueSheetCompletionBlock pendingCompletion = strongSelf->_pendingPresentCompletion;
+                          strongSelf->_isPresentPending = NO;
+                          strongSelf->_pendingPresentCompletion = nil;
+                          [strongSelf presentAtIndex:index animated:animated completion:pendingCompletion];
+                        });
+                      }];
+    return;
+  }
+
   [_controller setupAnchorViewInView:presentingViewController.view];
   [_controller setupSheetSizing];
   [_controller setupSheetProps];
 
-  // Pin before measuring so a first-time pin doesn't shift sizes mid-animation.
+  // Detect before measuring so a first-time detection doesn't shift sizes mid-animation.
   [self setupScrollable];
 
   // Measure synchronously so the presentation starts at the right height —
@@ -515,6 +635,8 @@ using namespace facebook::react;
     _controller.peekContentHeight = @([_containerView peekContentHeight]);
   }
   _pendingSizeChange = NO;
+  // Props queued while the previous presentation dismissed — applied above.
+  _pendingPropsUpdate = NO;
 
   [self refreshFooterBottomInset];
   [_controller setupSheetDetents];
@@ -523,13 +645,29 @@ using namespace facebook::react;
   [_screensEventObserver capturePresenterScreenFromView:self];
   [_screensEventObserver startObservingWithState:_state.get()->getData()];
 
+  UIWindow *window = presentingViewController.view.window;
   [presentingViewController presentViewController:_controller
                                          animated:animated
                                        completion:^{
+                                         [TrueSheetOverlayView bringOverlaysToFrontInWindow:window];
                                          if (completion) {
                                            completion(YES, nil);
                                          }
                                        }];
+
+  // Presenting adds the sheet's transition view on top of the window once the
+  // transition starts — re-front overlays alongside it so the first frame is
+  // already ordered (and again on completion in case the transition was queued)
+  id<UIViewControllerTransitionCoordinator> coordinator = _controller.transitionCoordinator;
+  if (coordinator) {
+    [coordinator
+      animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        [TrueSheetOverlayView bringOverlaysToFrontInWindow:window];
+      }
+                      completion:nil];
+  } else {
+    [TrueSheetOverlayView bringOverlaysToFrontInWindow:window];
+  }
 }
 
 - (void)resizeToIndex:(NSInteger)index completion:(nullable TrueSheetCompletionBlock)completion {
@@ -562,7 +700,46 @@ using namespace facebook::react;
                                   realtime:NO];
 }
 
+/**
+ * Drops a deferred present and resolves its caller. Returns whether one was pending.
+ */
+- (BOOL)cancelPendingPresent {
+  if (!_isPresentPending) {
+    return NO;
+  }
+
+  TrueSheetCompletionBlock pendingCompletion = _pendingPresentCompletion;
+  _isPresentPending = NO;
+  _pendingPresentCompletion = nil;
+  if (pendingCompletion) {
+    pendingCompletion(YES, nil);
+  }
+  return YES;
+}
+
 - (void)dismissAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion {
+  // Dismissing before a deferred present starts cancels it — nothing was presented.
+  if ([self cancelPendingPresent]) {
+    if (completion) {
+      completion(YES, nil);
+    }
+    return;
+  }
+
+  // Still animating in (isPresented flips at viewDidAppear): dismiss once the presentation lands
+  id<UIViewControllerTransitionCoordinator> presentCoordinator =
+    _controller.isBeingPresented ? _controller.transitionCoordinator : nil;
+  if (presentCoordinator) {
+    __weak __typeof(self) weakSelf = self;
+    [presentCoordinator animateAlongsideTransition:nil
+                                        completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                          dispatch_async(dispatch_get_main_queue(), ^{
+                                            [weakSelf dismissAnimated:animated completion:completion];
+                                          });
+                                        }];
+    return;
+  }
+
   if (_controller.isBeingDismissed || !_controller.isPresented) {
     RCTLogWarn(@"TrueSheet: sheet is already dismissed. No need to dismiss it again.");
 
@@ -612,7 +789,8 @@ using namespace facebook::react;
 #pragma mark - TrueSheetContainerViewDelegate
 
 /**
- * Debounced sheet update to handle rapid content/header size changes.
+ * Coalesces prop and size changes outside Fabric's mount transaction so
+ * the footer's layout can mount inside UIKit's resize animation.
  */
 - (void)setupSheetDetentsForSizeChange {
   // Keep the footer's absorbed inset in sync with the latest measured heights
@@ -628,26 +806,52 @@ using namespace facebook::react;
   }
 
   // Not presented: presentAtIndex measures at present time.
-  // Dismissing: the sheet is going away — touching detents perturbs the
-  // presentation stack, visibly glitching the sheet behind.
-  if (!_controller.isPresented || _controller.isBeingDismissed)
+  if (!_controller.isPresented || _isSheetUpdatePending)
     return;
 
-  if (_isSheetUpdatePending)
+  // Dismissing: the sheet is going away — touching detents perturbs the
+  // presentation stack, visibly glitching the sheet behind. An interactive
+  // dismiss can still cancel, so retry once the transition resolves.
+  if (_controller.isBeingDismissed) {
+    id<UIViewControllerTransitionCoordinator> coordinator = _controller.transitionCoordinator;
+    if (coordinator) {
+      _isSheetUpdatePending = YES;
+
+      __weak __typeof(self) weakSelf = self;
+      [coordinator animateAlongsideTransition:nil
+                                   completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                     dispatch_async(dispatch_get_main_queue(), ^{
+                                       __typeof(self) strongSelf = weakSelf;
+                                       if (!strongSelf)
+                                         return;
+
+                                       strongSelf->_isSheetUpdatePending = NO;
+                                       [strongSelf setupSheetDetentsForSizeChange];
+                                     });
+                                   }];
+    }
     return;
+  }
 
   _isSheetUpdatePending = YES;
 
   dispatch_async(dispatch_get_main_queue(), ^{
     self->_isSheetUpdatePending = NO;
-    if (!self->_containerView || self->_controller.isBeingDismissed)
+    if (!self->_containerView || !self->_controller.isPresented || self->_controller.isBeingDismissed)
       return;
 
     // Refresh here (not just on peek size events) since the peek's offset
     // within the content can change without its own size changing.
     self->_controller.peekContentHeight = @([self->_containerView peekContentHeight]);
     [self refreshFooterBottomInset];
+
+    // Size first: the props rebuild refreshes the heights itself, hiding the
+    // change from the controller and skipping its post-resize settle.
     [self->_controller setupSheetDetentsForSizeChange];
+    if (self->_pendingPropsUpdate) {
+      self->_pendingPropsUpdate = NO;
+      [self applySheetPropsUpdate];
+    }
   });
 }
 
@@ -664,14 +868,18 @@ using namespace facebook::react;
 - (void)containerViewFooterDidChangeSize:(CGSize)newSize {
   [self syncFooterMetrics];
   [self setupSheetDetentsForSizeChange];
-  [_controller setupAccessibilityContainer];
+  [_controller refreshAccessibilityContainer];
+}
+
+- (void)containerViewDidMountTransaction {
+  [_controller refreshAccessibilityContainerIfFooterChanged];
 }
 
 - (void)containerViewPeekDidChangeSize:(CGSize)newSize {
   [self setupSheetDetentsForSizeChange];
 }
 
-// When the ScrollView changes (e.g. conditional remount), re-pin the new ScrollView.
+// When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView.
 - (void)containerViewScrollViewDidChange {
   [self setupScrollable];
 }
@@ -680,11 +888,12 @@ using namespace facebook::react;
 
 - (void)viewControllerWillPresentAtIndex:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent {
   _controller.activeDetentIndex = index;
+  // Before emitting, so an input focused in onWillPresent raises a tracked keyboard
+  [_containerView setupKeyboardObserverWithViewController:_controller];
   [TrueSheetLifecycleEvents emitWillPresent:_eventEmitter index:index position:position detent:detent];
 }
 
 - (void)viewControllerDidPresentAtIndex:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent {
-  [_containerView setupKeyboardObserverWithViewController:_controller];
   [TrueSheetLifecycleEvents emitDidPresent:_eventEmitter index:index position:position detent:detent];
 
   if (_pendingPropsUpdate) {
@@ -724,6 +933,10 @@ using namespace facebook::react;
   }
 }
 
+- (void)viewControllerDidAttemptDismiss {
+  [TrueSheetLifecycleEvents emitDismissAttempt:_eventEmitter];
+}
+
 - (void)viewControllerDidDismiss {
   [_containerView cleanupKeyboardObserver];
   if (!_dismissedByNavigation) {
@@ -755,6 +968,7 @@ using namespace facebook::react;
 
 - (void)viewControllerSafeAreaInsetsDidChange {
   [self refreshFooterBottomInset];
+  [_containerView updateFooterKeyboardOffset];
 }
 
 - (void)viewControllerWillFocus {
@@ -822,9 +1036,11 @@ using namespace facebook::react;
   if (!_containerView)
     return;
 
-  _containerView.insetAdjustment = _insetAdjustment;
   _containerView.scrollableOptions = _scrollableOptions;
-  _containerView.hasAutoDetent = _hasAutoDetent;
+  _containerView.scrollableHandle = _scrollableHandle;
+  _containerView.safeAreaInsetAdjustment = (_scrollableOptions ? _scrollableOptions.safeAreaInsetAdjustment : YES) &&
+                                           _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  _containerView.footerInsetAdjustment = _controller.footerInsetAdjustment;
   [self refreshFooterBottomInset];
   [_containerView setupScrollable];
 }

package/ios/TrueSheetViewController.h

@@ -26,6 +26,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)viewControllerDidPresentAtIndex:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent;
 - (void)viewControllerWillDismiss;
 - (void)viewControllerDidDismiss;
+- (void)viewControllerDidAttemptDismiss;
 - (void)viewControllerDidChangeDetent:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent;
 - (void)viewControllerDidDrag:(UIGestureRecognizerState)state
                         index:(NSInteger)index
@@ -54,6 +55,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 @property (nonatomic, weak, nullable) id<TrueSheetViewControllerDelegate> delegate;
 @property (nonatomic, strong) NSArray<NSNumber *> *detents;
+@property (nonatomic, copy) NSArray<NSDictionary *> *detentBackgrounds;
 @property (nonatomic, strong, nullable) NSNumber *maxContentHeight;
 @property (nonatomic, strong, nullable) NSNumber *maxContentWidth;
 @property (nonatomic, strong, nullable) NSNumber *contentHeight;
@@ -61,6 +63,13 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL absoluteHeader;
 @property (nonatomic, strong, nullable) NSNumber *footerHeight;
 @property (nonatomic, assign) BOOL absoluteFooter;
+
+/**
+ * YES while the plugged scrollable is padded by the absolute footer's height
+ * (see ScrollableOptions.contentInsetAdjustment) — the footer then counts
+ * toward the auto detent like a relative one, so the content ends above it.
+ */
+@property (nonatomic, assign) BOOL footerInsetAdjustment;
 @property (nonatomic, strong, nullable) NSNumber *peekContentHeight;
 @property (nonatomic, strong, nullable) UIColor *backgroundColor;
 @property (nonatomic, strong, nullable) NSNumber *cornerRadius;
@@ -69,15 +78,22 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) facebook::react::TrueSheetViewAccessibilityOptionsStruct accessibilityOptions;
 @property (nonatomic, assign) BOOL draggable;
 @property (nonatomic, assign) BOOL dimmed;
+@property (nonatomic, strong, nullable) UIColor *dimColor;
+@property (nonatomic, strong, nullable) NSNumber *dimOpacity;
 @property (nonatomic, strong, nullable) NSNumber *dimmedDetentIndex;
 @property (nonatomic, assign) facebook::react::TrueSheetViewBackgroundBlur backgroundBlur;
-@property (nonatomic, strong, nullable) NSNumber *blurIntensity;
-@property (nonatomic, assign) BOOL blurInteraction;
 @property (nonatomic, assign) facebook::react::TrueSheetViewPresentation presentation;
-@property (nonatomic, assign) facebook::react::TrueSheetViewAnchor anchor;
+@property (nonatomic, assign) facebook::react::TrueSheetViewPlacement placement;
+@property (nonatomic, assign) facebook::react::TrueSheetViewFoldOptionsStruct foldOptions;
 @property (nonatomic, assign) facebook::react::TrueSheetViewInsetAdjustment insetAdjustment;
 @property (nonatomic, assign) BOOL scrollingExpandsSheet;
 @property (nonatomic, assign) CGFloat footerKeyboardOffset;
+
+/**
+ * NO keeps an absolute footer pinned to the sheet's bottom edge behind the
+ * keyboard instead of rising above it.
+ */
+@property (nonatomic, assign) BOOL footerAvoidsKeyboard;
 @property (nonatomic, assign) BOOL dismissible;
 @property (nonatomic, assign) BOOL isPresented;
 @property (nonatomic, assign) NSInteger activeDetentIndex;
@@ -88,6 +104,19 @@ NS_ASSUME_NONNULL_BEGIN
  * ~keyboardHeight into the learned offset.
  */
 @property (nonatomic, assign) BOOL keyboardSheetGrown;
+
+/**
+ * Target keyboard height, set as soon as the keyboard frame change is
+ * announced — ahead of the grow/shrink animation, unlike keyboardSheetGrown.
+ */
+@property (nonatomic, assign) CGFloat keyboardHeight;
+
+/**
+ * How far UIKit grows the sheet for the iPadOS minimized keyboard, which it
+ * treats as docked. Taken off every detent so the sheet stays put.
+ */
+@property (nonatomic, assign) CGFloat minimizedKeyboardOverlap;
+
 @property (nonatomic, readonly) BOOL isTopmostPresentedController;
 @property (nonatomic, readonly) BOOL isStackedBehindChild;
 @property (nonatomic, weak, nullable) UIView *accessibilityContentView;
@@ -109,6 +138,9 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) CGFloat appliedFooterBottomInset;
 
 - (void)setupAccessibilityContainer;
+- (void)refreshAccessibilityContainer;
+- (void)refreshAccessibilityContainerIfFooterChanged;
+
 - (void)applyActiveDetent;
 - (void)setupActiveDetentWithIndex:(NSInteger)index;
 - (void)resizeToDetentIndex:(NSInteger)index;
@@ -117,6 +149,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setupSheetDetents;
 - (void)setupSheetDetentsForSizeChange;
 - (void)setupSheetDetentsForDetentsChange;
+- (void)invalidateDetents;
 - (void)setupDraggable;
 - (void)setupAnchorViewInView:(UIView *)parentView;