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

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;
 }
@@ -110,24 +114,80 @@ using namespace facebook::react;
     return;
   }
 
-  if (_initialDetentIndex >= 0 && !_didInitiallyPresent) {
-    UIViewController *vc = [self findPresentingViewController];
+  [self presentInitialIfNeeded];
+}
+
+// JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+// navigation footer set via setOptions) commits together with it — by the time
+// the prop lands the tree is final and the sheet presents at its final height.
+// Called from didMoveToWindow (re-attach) and finalizeUpdates (the prop
+// arriving after attach, which didMoveToWindow won't re-fire for).
+- (void)presentInitialIfNeeded {
+  if (_initialDetentIndex < 0 || _didInitiallyPresent)
+    return;
 
-    // Only present if the view controller is in the same window and not being dismissed
-    if (vc && vc.view.window == self.window && !_controller.isBeingDismissed) {
-      _didInitiallyPresent = YES;
-      [self presentAtIndex:_initialDetentIndex animated:_initialDetentAnimated completion:nil];
+  UIViewController *vc = [self findPresentingViewController];
+
+  // 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 {
-      // Animate next time when sheet finally moves to the correct window
-      _initialDetentAnimated = YES;
+      retry();
     }
+    return;
   }
+
+  _didInitiallyPresent = YES;
+
+  // Deferred a runloop turn so sibling mounts from the current transaction
+  // (e.g. a footer committed alongside the prop) land before measuring.
+  __weak __typeof(self) weakSelf = self;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    __typeof(self) strongSelf = weakSelf;
+    if (!strongSelf || strongSelf->_controller.isPresented || strongSelf->_controller.isBeingPresented)
+      return;
+
+    [strongSelf presentAtIndex:strongSelf->_initialDetentIndex
+                      animated:strongSelf->_initialDetentAnimated
+                    completion:^(BOOL success, NSError *_Nullable error) {
+                      // Present can fail if the view detached during this turn —
+                      // reset so the next attach/prop update retries.
+                      if (!success) {
+                        strongSelf->_didInitiallyPresent = NO;
+                      }
+                    }];
+  });
 }
 
 - (void)dealloc {
   [_screensEventObserver stopObserving];
   _screensEventObserver = nil;
 
+  [self cancelPendingPresent];
+
   if (_controller && _controller.presentingViewController) {
     // Find the root presenting controller to dismiss the entire stack
     UIViewController *root = _controller.presentingViewController;
@@ -146,8 +206,6 @@ using namespace facebook::react;
 
   [_snapshotView removeFromSuperview];
   _snapshotView = nil;
-
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
 }
 
 #pragma mark - RCTComponentViewProtocol
@@ -163,12 +221,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) {
@@ -187,14 +241,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);
 
@@ -204,8 +273,7 @@ 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.grabber = newProps.grabber;
 
@@ -248,33 +316,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];
   }
 
@@ -342,13 +415,49 @@ using namespace facebook::react;
     _pendingPropsUpdate = YES;
   } else if (_initialDetentIndex >= 0) {
     _pendingLayoutUpdate = NO;
+    if (self.window) {
+      [self presentInitialIfNeeded];
+    }
   }
 }
 
 - (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;
@@ -389,7 +498,6 @@ using namespace facebook::react;
   [_touchHandler attachToView:_containerView];
   [_controller.view addSubview:_containerView];
   [_controller.view bringSubviewToFront:_containerView];
-  _containerView.accessibilityViewIsModal = YES;
   _controller.accessibilityContentView = _containerView;
   [_controller setupAccessibilityContainer];
 
@@ -403,9 +511,8 @@ using namespace facebook::react;
     _controller.headerHeight = @(headerHeight);
   }
 
-  CGFloat footerHeight = [_containerView footerHeight];
-  if (footerHeight > 0) {
-    _controller.footerHeight = @(footerHeight);
+  if ([_containerView footerHeight] > 0) {
+    [self syncFooterMetrics];
   }
 
   CGFloat peekContentHeight = [_containerView peekContentHeight];
@@ -445,7 +552,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);
@@ -467,11 +574,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 —
@@ -480,24 +617,41 @@ using namespace facebook::react;
   if (_containerView) {
     _controller.contentHeight = @([_containerView contentHeight]);
     _controller.headerHeight = @([_containerView headerHeight]);
-    _controller.footerHeight = @([_containerView footerHeight]);
+    [self syncFooterMetrics];
     _controller.peekContentHeight = @([_containerView peekContentHeight]);
   }
   _pendingSizeChange = NO;
 
+  [self refreshFooterBottomInset];
   [_controller setupSheetDetents];
   [_controller setupActiveDetentWithIndex:index];
 
   [_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 {
@@ -530,7 +684,32 @@ 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;
+  }
+
   if (_controller.isBeingDismissed || !_controller.isPresented) {
     RCTLogWarn(@"TrueSheet: sheet is already dismissed. No need to dismiss it again.");
 
@@ -583,6 +762,10 @@ using namespace facebook::react;
  * Debounced sheet update to handle rapid content/header size changes.
  */
 - (void)setupSheetDetentsForSizeChange {
+  // Keep the footer's absorbed inset in sync with the latest measured heights
+  // even before presenting, so the sheet presents at its final size.
+  [self refreshFooterBottomInset];
+
   // Retargeting the in-flight presentation makes UIKit snap the whole stack
   // (including the sheet behind) instead of animating. Defer to didPresent —
   // presentAtIndex measured synchronously, so this is usually a no-op.
@@ -610,6 +793,7 @@ using namespace facebook::react;
     // 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];
     [self->_controller setupSheetDetentsForSizeChange];
   });
 }
@@ -625,7 +809,7 @@ using namespace facebook::react;
 }
 
 - (void)containerViewFooterDidChangeSize:(CGSize)newSize {
-  _controller.footerHeight = @(newSize.height);
+  [self syncFooterMetrics];
   [self setupSheetDetentsForSizeChange];
   [_controller setupAccessibilityContainer];
 }
@@ -634,7 +818,7 @@ using namespace facebook::react;
   [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];
 }
@@ -687,6 +871,10 @@ using namespace facebook::react;
   }
 }
 
+- (void)viewControllerDidAttemptDismiss {
+  [TrueSheetLifecycleEvents emitDismissAttempt:_eventEmitter];
+}
+
 - (void)viewControllerDidDismiss {
   [_containerView cleanupKeyboardObserver];
   if (!_dismissedByNavigation) {
@@ -716,6 +904,11 @@ using namespace facebook::react;
   [self updateStateWithSize:size];
 }
 
+- (void)viewControllerSafeAreaInsetsDidChange {
+  [self refreshFooterBottomInset];
+  [_containerView updateFooterKeyboardOffset];
+}
+
 - (void)viewControllerWillFocus {
   [TrueSheetFocusEvents emitWillFocus:_eventEmitter];
 }
@@ -781,16 +974,41 @@ using namespace facebook::react;
   if (!_containerView)
     return;
 
-  _containerView.insetAdjustment = _insetAdjustment;
   _containerView.scrollableOptions = _scrollableOptions;
-  _containerView.hasAutoDetent = _hasAutoDetent;
-  _containerView.footerBottomInset = _controller.footerBottomInset;
+  _containerView.scrollableHandle = _scrollableHandle;
+  _containerView.safeAreaInsetAdjustment = (_scrollableOptions ? _scrollableOptions.safeAreaInsetAdjustment : YES) &&
+                                           _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  _containerView.footerInsetAdjustment = _controller.footerInsetAdjustment;
+  [self refreshFooterBottomInset];
   [_containerView setupScrollable];
+}
+
+// footerHeight and appliedFooterBottomInset must stay paired — detent math
+// subtracts exactly the inset baked into the measured footer height (see
+// autoDetentBottomInset/peekDetentBottomInset).
+- (void)syncFooterMetrics {
+  _controller.footerHeight = @([_containerView footerHeight]);
+  _controller.appliedFooterBottomInset = [_containerView footerAppliedBottomInset];
+}
+
+// Recomputes the inset the footer absorbs and pushes it down. The inset
+// depends on measured heights and detents (see maxNaturalDetentHeight), so
+// this runs on size and detent changes — not just prop updates.
+- (void)refreshFooterBottomInset {
+  if (!_containerView)
+    return;
+
+  // appliedFooterBottomInset is NOT set here — it tracks what's actually
+  // baked into the footer's measured height (reported with its layout), not
+  // what was just pushed. Setting it at push time desyncs the pair and lets
+  // a seeded inset read as natural content height (see maxNaturalDetentHeight).
+  CGFloat inset = _controller.footerBottomInset;
+  _containerView.footerBottomInset = inset;
 
   // Publish the inset so a footer set later (e.g. navigation setOptions) is
   // padded on its very first layout instead of resizing the sheet twice.
   if (_insetAdjustment == TrueSheetViewInsetAdjustment::Automatic) {
-    TrueSheetInsets::setBottomSafeArea(_controller.footerBottomInset);
+    TrueSheetInsets::setBottomSafeArea(inset);
   }
 }
 
@@ -801,6 +1019,7 @@ using namespace facebook::react;
   if (_pendingDetents) {
     _controller.detents = _pendingDetents;
     _pendingDetents = nil;
+    [self refreshFooterBottomInset];
   }
 
   UIView *presenterView = _controller.presentingViewController.view;

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
@@ -36,6 +37,7 @@ NS_ASSUME_NONNULL_BEGIN
                                  detent:(CGFloat)detent
                                realtime:(BOOL)realtime;
 - (void)viewControllerDidChangeSize:(CGSize)size;
+- (void)viewControllerSafeAreaInsetsDidChange;
 - (void)viewControllerWillFocus;
 - (void)viewControllerDidFocus;
 - (void)viewControllerWillBlur;
@@ -53,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;
@@ -60,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;
@@ -70,13 +80,17 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL dimmed;
 @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::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;
@@ -87,6 +101,12 @@ 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;
 @property (nonatomic, readonly) BOOL isTopmostPresentedController;
 @property (nonatomic, readonly) BOOL isStackedBehindChild;
 @property (nonatomic, weak, nullable) UIView *accessibilityContentView;
@@ -99,6 +119,14 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (nonatomic, readonly) CGFloat footerBottomInset;
 
+/**
+ * The inset currently baked into the footer's measured height, reported
+ * alongside its layout (see TrueSheetFooterView.appliedBottomInset). Detent
+ * resolution subtracts this exact value so the baked inset is never
+ * double-counted.
+ */
+@property (nonatomic, assign) CGFloat appliedFooterBottomInset;
+
 - (void)setupAccessibilityContainer;
 - (void)applyActiveDetent;
 - (void)setupActiveDetentWithIndex:(NSInteger)index;