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

package/ios/TrueSheetModule.mm

@@ -18,8 +18,9 @@
 
 #import <TrueSheetSpec/TrueSheetSpec.h>
 
-// Static registry to store view references by tag
-static NSMutableDictionary<NSNumber *, TrueSheetView *> *viewRegistry;
+// Static registry of live hosts by tag — weak so an unmounted host deallocates
+// (RN zeroes the tag before teardown, so hosts can't unregister themselves)
+static NSMapTable<NSNumber *, TrueSheetView *> *viewRegistry;
 
 @interface TrueSheetModule () <NativeTrueSheetModuleSpec>
 @end
@@ -30,7 +31,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
 
 + (void)initialize {
   if (self == [TrueSheetModule class]) {
-    viewRegistry = [NSMutableDictionary new];
+    viewRegistry = [NSMapTable strongToWeakObjectsMapTable];
   }
 }
 
@@ -151,7 +152,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
       // Find the root presented sheet (one without a parent TrueSheet)
       TrueSheetView *rootSheet = nil;
 
-      for (TrueSheetView *view in viewRegistry.allValues) {
+      for (TrueSheetView *view in viewRegistry.objectEnumerator) {
         if (!view.viewController.isPresented) {
           continue;
         }
@@ -191,7 +192,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
   }
 
   @synchronized(viewRegistry) {
-    return viewRegistry[reactTag];
+    return [viewRegistry objectForKey:reactTag];
   }
 }
 
@@ -201,17 +202,7 @@ RCT_EXPORT_MODULE(TrueSheetModule)
   }
 
   @synchronized(viewRegistry) {
-    viewRegistry[tag] = view;
-  }
-}
-
-+ (void)unregisterViewWithTag:(NSNumber *)tag {
-  if (!tag) {
-    return;
-  }
-
-  @synchronized(viewRegistry) {
-    [viewRegistry removeObjectForKey:tag];
+    [viewRegistry setObject:view forKey:tag];
   }
 }
 

package/ios/TrueSheetOverlayView.h

@@ -0,0 +1,32 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Hidden host that renders its children in a container attached directly to
+ * the window, above every presented sheet.
+ */
+@interface TrueSheetOverlayView : RCTViewComponentView
+
+/**
+ * Re-stacks every overlay container above the window's other subviews.
+ * Called when a sheet presents, since presenting adds its transition view on top.
+ */
++ (void)bringOverlaysToFrontInWindow:(nullable UIWindow *)window;
+
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/TrueSheetOverlayView.mm

@@ -0,0 +1,161 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import "TrueSheetOverlayView.h"
+#import "core/TrueSheetOverlayContainerView.h"
+
+#import <react/renderer/components/TrueSheetSpec/EventEmitters.h>
+#import <react/renderer/components/TrueSheetSpec/Props.h>
+#import <react/renderer/components/TrueSheetSpec/RCTComponentViewHelpers.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewComponentDescriptor.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewShadowNode.h>
+
+#import <React/RCTSurfaceTouchHandler.h>
+
+using namespace facebook::react;
+
+static NSHashTable<TrueSheetOverlayView *> *gOverlayViews;
+
+@interface TrueSheetOverlayView () <TrueSheetOverlayContainerViewDelegate>
+@end
+
+@implementation TrueSheetOverlayView {
+  TrueSheetOverlayContainerView *_containerView;
+  // Owns `_containerView` so it has a view controller in its responder chain. The
+  // container is a sibling of `rootViewController.view`, and a window's responder chain
+  // skips its root view controller — without an owner, `-[UIView reactViewController]`
+  // finds nothing and content that installs a view controller cannot attach.
+  UIViewController *_containerController;
+  RCTSurfaceTouchHandler *_touchHandler;
+  TrueSheetOverlayViewShadowNode::ConcreteState::Shared _state;
+  CGSize _lastStateSize;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<TrueSheetOverlayViewComponentDescriptor>();
+}
+
++ (void)bringOverlaysToFrontInWindow:(nullable UIWindow *)window {
+  if (!window)
+    return;
+
+  for (TrueSheetOverlayView *overlay in gOverlayViews) {
+    if (overlay->_containerView.superview == window) {
+      [window bringSubviewToFront:overlay->_containerView];
+    }
+  }
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const TrueSheetOverlayViewProps>();
+    _props = defaultProps;
+
+    _containerView = [[TrueSheetOverlayContainerView alloc] initWithFrame:CGRectZero];
+    _containerView.delegate = self;
+
+    // Assigning the container as its view is what puts the controller in the responder
+    // chain; the containment below is for lifecycle only.
+    _containerController = [UIViewController new];
+    _containerController.view = _containerView;
+
+    _touchHandler = [[RCTSurfaceTouchHandler alloc] init];
+    [_touchHandler attachToView:_containerView];
+
+    _lastStateSize = CGSizeZero;
+
+    // The host stays in the React tree for layout only — children render in the container
+    self.hidden = YES;
+
+    if (!gOverlayViews) {
+      gOverlayViews = [NSHashTable weakObjectsHashTable];
+    }
+    [gOverlayViews addObject:self];
+  }
+  return self;
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+
+  UIWindow *window = self.window;
+  if (window) {
+    _containerView.frame = window.bounds;
+    [window addSubview:_containerView];
+
+    UIViewController *root = window.rootViewController;
+    if (root != nil && _containerController.parentViewController != root) {
+      [root addChildViewController:_containerController];
+      [_containerController didMoveToParentViewController:root];
+    }
+  } else {
+    [_containerController willMoveToParentViewController:nil];
+    [_containerView removeFromSuperview];
+    [_containerController removeFromParentViewController];
+  }
+}
+
+#pragma mark - State
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<TrueSheetOverlayViewShadowNode::ConcreteState const>(state);
+
+  if (self.window) {
+    [self updateStateWithSize:self.window.bounds.size];
+  }
+}
+
+- (void)overlayContainerViewDidLayout:(CGSize)size {
+  [self updateStateWithSize:size];
+}
+
+- (void)updateStateWithSize:(CGSize)size {
+  if (!_state)
+    return;
+
+  if (fabs(size.width - _lastStateSize.width) < 0.5 && fabs(size.height - _lastStateSize.height) < 0.5)
+    return;
+
+  _lastStateSize = size;
+
+  auto stateData = _state->getData();
+  stateData.containerWidth = static_cast<float>(size.width);
+  stateData.containerHeight = static_cast<float>(size.height);
+  _state->updateState(std::move(stateData), EventQueue::UpdateMode::unstable_Immediate);
+}
+
+#pragma mark - Child Component Mounting
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [_containerView insertSubview:childComponentView atIndex:index];
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  [childComponentView removeFromSuperview];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_containerController willMoveToParentViewController:nil];
+  [_containerView removeFromSuperview];
+  [_containerController removeFromParentViewController];
+  _lastStateSize = CGSizeZero;
+  _state.reset();
+  self.hidden = YES;
+}
+
+@end
+
+Class<RCTComponentViewProtocol> TrueSheetOverlayViewCls(void) {
+  return TrueSheetOverlayView.class;
+}
+
+#endif

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;
@@ -110,18 +111,72 @@ 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 {
@@ -146,8 +201,6 @@ using namespace facebook::react;
 
   [_snapshotView removeFromSuperview];
   _snapshotView = nil;
-
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
 }
 
 #pragma mark - RCTComponentViewProtocol
@@ -163,12 +216,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) {
@@ -248,17 +297,23 @@ using namespace facebook::react;
   _initialDetentIndex = newProps.initialDetentIndex;
   _initialDetentAnimated = newProps.initialDetentAnimated;
 
+  _scrollableHandle = newProps.scrollableHandle;
+
   const auto &scrollableOpts = newProps.scrollableOptions;
   BOOL scrollingExpandsSheet = scrollableOpts.scrollingExpandsSheet;
+  BOOL contentInsetAdjustment = scrollableOpts.contentInsetAdjustmentBehavior;
   auto topEdgeEffect = scrollableOpts.topScrollEdgeEffect;
   auto bottomEdgeEffect = scrollableOpts.bottomScrollEdgeEffect;
-  BOOL hasScrollableOptions = scrollableOpts.keyboardScrollOffset > 0 || !scrollingExpandsSheet ||
+  BOOL hasScrollableOptions = scrollableOpts.keyboardScrollOffset > 0 || scrollableOpts.keyboardOffset != 0 ||
+                              !scrollingExpandsSheet || !contentInsetAdjustment ||
                               topEdgeEffect != TrueSheetViewTopScrollEdgeEffect::Hidden ||
                               bottomEdgeEffect != TrueSheetViewBottomScrollEdgeEffect::Hidden;
 
   if (hasScrollableOptions) {
     ScrollableOptions *options = [[ScrollableOptions alloc] init];
+    options.contentInsetAdjustment = contentInsetAdjustment;
     options.keyboardScrollOffset = scrollableOpts.keyboardScrollOffset;
+    options.keyboardOffset = scrollableOpts.keyboardOffset;
     options.scrollingExpandsSheet = scrollingExpandsSheet;
     options.topScrollEdgeEffect = topEdgeEffect;
     options.bottomScrollEdgeEffect = bottomEdgeEffect;
@@ -342,13 +397,47 @@ 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();
+    }
+  }
 
   _lastStateSize = CGSizeZero;
   _didInitiallyPresent = NO;
@@ -389,7 +478,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 +491,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];
@@ -471,7 +558,7 @@ using namespace facebook::react;
   [_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 +567,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 {
@@ -583,6 +687,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 +718,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 +734,7 @@ using namespace facebook::react;
 }
 
 - (void)containerViewFooterDidChangeSize:(CGSize)newSize {
-  _controller.footerHeight = @(newSize.height);
+  [self syncFooterMetrics];
   [self setupSheetDetentsForSizeChange];
   [_controller setupAccessibilityContainer];
 }
@@ -634,7 +743,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 +796,10 @@ using namespace facebook::react;
   }
 }
 
+- (void)viewControllerDidAttemptDismiss {
+  [TrueSheetLifecycleEvents emitDismissAttempt:_eventEmitter];
+}
+
 - (void)viewControllerDidDismiss {
   [_containerView cleanupKeyboardObserver];
   if (!_dismissedByNavigation) {
@@ -716,6 +829,10 @@ using namespace facebook::react;
   [self updateStateWithSize:size];
 }
 
+- (void)viewControllerSafeAreaInsetsDidChange {
+  [self refreshFooterBottomInset];
+}
+
 - (void)viewControllerWillFocus {
   [TrueSheetFocusEvents emitWillFocus:_eventEmitter];
 }
@@ -781,16 +898,40 @@ using namespace facebook::react;
   if (!_containerView)
     return;
 
-  _containerView.insetAdjustment = _insetAdjustment;
   _containerView.scrollableOptions = _scrollableOptions;
-  _containerView.hasAutoDetent = _hasAutoDetent;
-  _containerView.footerBottomInset = _controller.footerBottomInset;
+  _containerView.scrollableHandle = _scrollableHandle;
+  _containerView.contentInsetAdjustment = (_scrollableOptions ? _scrollableOptions.contentInsetAdjustment : YES) &&
+                                          _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  [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 +942,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;
@@ -99,6 +101,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;