@lodev09/react-native-true-sheet 4.0.0-beta.0 → 4.0.0-beta.10

package/ios/TrueSheetView.mm

@@ -13,60 +13,84 @@
 #import "TrueSheetContentView.h"
 #import "TrueSheetFooterView.h"
 #import "TrueSheetModule.h"
+#import "TrueSheetOverlayView.h"
 #import "TrueSheetViewController.h"
-#import "events/OnDetentChangeEvent.h"
-#import "events/OnDidDismissEvent.h"
-#import "events/OnDidPresentEvent.h"
-#import "events/OnDragBeginEvent.h"
-#import "events/OnDragChangeEvent.h"
-#import "events/OnDragEndEvent.h"
-#import "events/OnMountEvent.h"
-#import "events/OnPositionChangeEvent.h"
-#import "events/OnSizeChangeEvent.h"
-#import "events/OnWillDismissEvent.h"
-#import "events/OnWillPresentEvent.h"
-#import "utils/LayoutUtil.h"
+#import "core/RNScreensEventObserver.h"
+#import "events/TrueSheetDragEvents.h"
+#import "events/TrueSheetFocusEvents.h"
+#import "events/TrueSheetLifecycleEvents.h"
+#import "events/TrueSheetStateEvents.h"
 #import "utils/WindowUtil.h"
 
-#import <react/renderer/components/TrueSheetSpec/ComponentDescriptors.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/TrueSheetInsets.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetViewComponentDescriptor.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetViewShadowNode.h>
+#import <react/renderer/components/TrueSheetSpec/TrueSheetViewState.h>
 
 #import <React/RCTConversions.h>
 #import <React/RCTFabricComponentsPlugins.h>
+#import <React/RCTLog.h>
 #import <React/RCTSurfaceTouchHandler.h>
 #import <React/RCTUtils.h>
+#import <react/renderer/core/State.h>
 
 using namespace facebook::react;
 
-@interface TrueSheetView () <TrueSheetViewControllerDelegate, TrueSheetContainerViewDelegate>
+@interface TrueSheetView () <TrueSheetViewControllerDelegate,
+  TrueSheetContainerViewDelegate,
+  RNScreensEventObserverDelegate>
 @end
 
 @implementation TrueSheetView {
   TrueSheetContainerView *_containerView;
   TrueSheetViewController *_controller;
   RCTSurfaceTouchHandler *_touchHandler;
+  TrueSheetViewShadowNode::ConcreteState::Shared _state;
+  UIView *_snapshotView;
+  CGSize _lastStateSize;
   NSInteger _initialDetentIndex;
+  TrueSheetViewInsetAdjustment _insetAdjustment;
+  ScrollableOptions *_scrollableOptions;
+  NSInteger _scrollableHandle;
   BOOL _initialDetentAnimated;
+  BOOL _isSheetUpdatePending;
+  BOOL _pendingLayoutUpdate;
+  BOOL _didInitiallyPresent;
+  BOOL _dismissedByNavigation;
+  BOOL _pendingNavigationRepresent;
+  BOOL _pendingMountEvent;
+  BOOL _pendingSizeChange;
+  BOOL _pendingPropsUpdate;
+  NSArray *_pendingDetents;
+  RNScreensEventObserver *_screensEventObserver;
 }
 
+#pragma mark - Initialization
+
 - (instancetype)initWithFrame:(CGRect)frame {
   if (self = [super initWithFrame:frame]) {
     static const auto defaultProps = std::make_shared<const TrueSheetViewProps>();
     _props = defaultProps;
 
-    // Initialize controller - persists across container lifecycle
+    self.hidden = YES;
+    self.userInteractionEnabled = NO;
+
     _controller = [[TrueSheetViewController alloc] init];
     _controller.delegate = self;
 
-    // Initialize touch handler - will be attached to container when mounted
     _touchHandler = [[RCTSurfaceTouchHandler alloc] init];
-
     _containerView = nil;
-
+    _snapshotView = nil;
+    _lastStateSize = CGSizeZero;
     _initialDetentIndex = -1;
     _initialDetentAnimated = YES;
+    _isSheetUpdatePending = NO;
+
+    _screensEventObserver = [[RNScreensEventObserver alloc] init];
+    _screensEventObserver.delegate = self;
   }
   return self;
 }
@@ -74,29 +98,109 @@ using namespace facebook::react;
 - (void)didMoveToWindow {
   [super didMoveToWindow];
 
-  if (!self.window) {
+  if (!self.window)
     return;
-  }
 
-  // Register this view with the TurboModule when added to window
-  // This ensures the tag is properly set by the framework
   if (self.tag > 0) {
     [TrueSheetModule registerView:self withTag:@(self.tag)];
   }
+
+  if (_pendingNavigationRepresent && !_controller.isPresented) {
+    _pendingNavigationRepresent = NO;
+    [self presentAtIndex:_controller.activeDetentIndex animated:YES completion:nil];
+    return;
+  }
+
+  [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;
+
+  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 {
+      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 {
-  // Dismiss controller if presented
+  [_screensEventObserver stopObserving];
+  _screensEventObserver = nil;
+
   if (_controller && _controller.presentingViewController) {
-    [_controller dismissViewControllerAnimated:NO completion:nil];
+    // Find the root presenting controller to dismiss the entire stack
+    UIViewController *root = _controller.presentingViewController;
+    while (root.presentingViewController != nil) {
+      root = root.presentingViewController;
+    }
+    [root dismissViewControllerAnimated:YES completion:nil];
   }
 
-  // Clean up controller
+  _didInitiallyPresent = NO;
+  _dismissedByNavigation = NO;
+  _pendingNavigationRepresent = NO;
+
   _controller.delegate = nil;
   _controller = nil;
 
-  // Unregister this view from the TurboModule
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
+  [_snapshotView removeFromSuperview];
+  _snapshotView = nil;
 }
 
 #pragma mark - RCTComponentViewProtocol
@@ -105,319 +209,775 @@ using namespace facebook::react;
   return concreteComponentDescriptorProvider<TrueSheetViewComponentDescriptor>();
 }
 
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+
+  const auto &newProps = *std::static_pointer_cast<TrueSheetViewProps const>(props);
+
+  // Detents (-1 represents "auto")
+  NSMutableArray *detents = [NSMutableArray new];
+  for (const auto &detent : newProps.detents) {
+    [detents addObject:@(detent)];
+  }
+
+  if (oldProps) {
+    const auto &prevProps = *std::static_pointer_cast<TrueSheetViewProps const>(oldProps);
+    if (newProps.detents != prevProps.detents || newProps.insetAdjustment != prevProps.insetAdjustment) {
+      _pendingLayoutUpdate = YES;
+    }
+  }
+
+  if (_controller.isBeingPresented) {
+    _pendingDetents = detents;
+  } else {
+    _controller.detents = detents;
+  }
+
+  // Background color
+  _controller.backgroundColor = RCTUIColorFromSharedColor(newProps.backgroundColor);
+
+  // 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);
+
+  // Content height
+  _controller.maxContentHeight = newProps.maxContentHeight != 0.0 ? @(newProps.maxContentHeight) : nil;
+
+  // Content width
+  _controller.maxContentWidth = newProps.maxContentWidth != 0.0 ? @(newProps.maxContentWidth) : nil;
+
+  // Anchor
+  _controller.anchor = newProps.anchor;
+
+  _controller.grabber = newProps.grabber;
+
+  // Grabber options - check if any non-default values are set
+  const auto &grabberOpts = newProps.grabberOptions;
+  UIColor *grabberColor = RCTUIColorFromSharedColor(grabberOpts.color);
+  BOOL hasGrabberOptions = grabberOpts.width > 0 || grabberOpts.height > 0 || grabberOpts.topMargin > 0 ||
+                           grabberOpts.cornerRadius >= 0 || grabberColor != nil || !grabberOpts.adaptive;
+
+  if (hasGrabberOptions) {
+    GrabberOptions *options = [[GrabberOptions alloc] init];
+    if (grabberOpts.width > 0)
+      options.width = @(grabberOpts.width);
+    if (grabberOpts.height > 0)
+      options.height = @(grabberOpts.height);
+    if (grabberOpts.topMargin > 0)
+      options.topMargin = @(grabberOpts.topMargin);
+    if (grabberOpts.cornerRadius >= 0)
+      options.cornerRadius = @(grabberOpts.cornerRadius);
+    if (grabberColor)
+      options.color = grabberColor;
+    options.adaptive = grabberOpts.adaptive;
+    _controller.grabberOptions = options;
+  } else {
+    _controller.grabberOptions = nil;
+  }
+
+  // Accessibility options - applied to the custom grabber
+  _controller.accessibilityOptions = newProps.accessibilityOptions;
+
+  _controller.presentation = newProps.presentation;
+  _controller.dismissible = newProps.dismissible;
+  _controller.draggable = newProps.draggable;
+  _controller.dimmed = newProps.dimmed;
+
+  if (newProps.dimmedDetentIndex >= 0) {
+    _controller.dimmedDetentIndex = @(newProps.dimmedDetentIndex);
+  }
+
+  _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 || 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;
+    _scrollableOptions = options;
+  } else {
+    _scrollableOptions = nil;
+  }
+
+  _controller.scrollingExpandsSheet = scrollingExpandsSheet;
+
+  _controller.absoluteHeader = newProps.headerOptions.position == TrueSheetViewPosition::Absolute;
+  _controller.absoluteFooter = newProps.footerOptions.footerPosition == TrueSheetViewFooterPosition::Absolute;
+
+  CGFloat footerKeyboardOffset = newProps.footerOptions.keyboardOffset;
+  if (_controller.footerKeyboardOffset != footerKeyboardOffset) {
+    _controller.footerKeyboardOffset = footerKeyboardOffset;
+    [_containerView updateFooterKeyboardOffset];
+  }
+
+  _insetAdjustment = newProps.insetAdjustment;
+  _controller.insetAdjustment = _insetAdjustment;
+
+  [self setupScrollable];
+}
+
+- (void)updateState:(const State::Shared &)state oldState:(const State::Shared &)oldState {
+  _state = std::static_pointer_cast<TrueSheetViewShadowNode::ConcreteState const>(state);
+
+  if (_controller && !_controller.isStackedBehindChild) {
+    CGSize size = _controller.view.frame.size;
+    if (size.width < 1 || size.height < 1) {
+      // Pre-present the controller has no layout yet. Seed with screen
+      // dimensions so content (e.g. a FlatList viewport) can lay out and
+      // measure before the sheet presents (parity with Android).
+      UIWindow *window = [WindowUtil keyWindow];
+      size = window ? window.bounds.size : UIScreen.mainScreen.bounds.size;
+    }
+    [self viewControllerDidChangeSize:size];
+  }
+}
+
+/**
+ * Updates Fabric state with container dimensions for Yoga layout.
+ */
+- (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);
+
+  // RN 0.82+ processes immediate state updates in the same layout pass, so Yoga
+  // resizes the container synchronously with the sheet (e.g. inside UIKit's
+  // animation block during detent transitions).
+  _state->updateState(std::move(stateData), facebook::react::EventQueue::UpdateMode::unstable_Immediate);
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  // Emit pending mount event now that eventEmitter is available
+  if (_pendingMountEvent && (updateMask & RNComponentViewUpdateMaskEventEmitter)) {
+    _pendingMountEvent = NO;
+    [TrueSheetLifecycleEvents emitMount:_eventEmitter];
+  }
+
+  if (!(updateMask & RNComponentViewUpdateMaskProps) || !_controller)
+    return;
+
+  [self setupScrollable];
+
+  if (_controller.isPresented) {
+    [self applySheetPropsUpdate];
+  } else if (_controller.isBeingPresented) {
+    _pendingPropsUpdate = YES;
+  } else if (_initialDetentIndex >= 0) {
+    _pendingLayoutUpdate = NO;
+    if (self.window) {
+      [self presentInitialIfNeeded];
+    }
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  // 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;
+  _dismissedByNavigation = NO;
+  _pendingNavigationRepresent = NO;
+}
+
+#pragma mark - Child Component Mounting
+
+- (void)cleanupContainerView {
+  if (_containerView == nil)
+    return;
+
+  _containerView.delegate = nil;
+  [_touchHandler detachFromView:_containerView];
+  [_containerView removeFromSuperview];
+
+  _containerView = nil;
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  if (![childComponentView isKindOfClass:[TrueSheetContainerView class]])
+    return;
+
+  if (_containerView != nil && _containerView != childComponentView) {
+    RCTLogWarn(@"TrueSheet: Sheet can only have one container component.");
+    [self cleanupContainerView];
+  }
+
+  if (_snapshotView) {
+    [_snapshotView removeFromSuperview];
+    _snapshotView = nil;
+  }
+
+  _containerView = (TrueSheetContainerView *)childComponentView;
+  _containerView.delegate = self;
+
+  [_touchHandler attachToView:_containerView];
+  [_controller.view addSubview:_containerView];
+  [_controller.view bringSubviewToFront:_containerView];
+  _controller.accessibilityContentView = _containerView;
+  [_controller setupAccessibilityContainer];
+
+  CGFloat contentHeight = [_containerView contentHeight];
+  if (contentHeight > 0) {
+    _controller.contentHeight = @(contentHeight);
+  }
+
+  CGFloat headerHeight = [_containerView headerHeight];
+  if (headerHeight > 0) {
+    _controller.headerHeight = @(headerHeight);
+  }
+
+  if ([_containerView footerHeight] > 0) {
+    [self syncFooterMetrics];
+  }
+
+  CGFloat peekContentHeight = [_containerView peekContentHeight];
+  if (peekContentHeight > 0) {
+    _controller.peekContentHeight = @(peekContentHeight);
+  }
+
+  if (_eventEmitter) {
+    [TrueSheetLifecycleEvents emitMount:_eventEmitter];
+  } else {
+    _pendingMountEvent = YES;
+  }
+}
+
+- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
+  if (![childComponentView isKindOfClass:[TrueSheetContainerView class]])
+    return;
+
+  if (_containerView == nil || _containerView != childComponentView)
+    return;
+
+  if (_controller.isPresented) {
+    UIView *superView = _containerView.superview;
+    UIView *snapshot = [_containerView snapshotViewAfterScreenUpdates:NO];
+    if (snapshot) {
+      snapshot.frame = _containerView.frame;
+      [superView insertSubview:snapshot belowSubview:_containerView];
+      _snapshotView = snapshot;
+    }
+  }
+
+  [self cleanupContainerView];
+}
+
 #pragma mark - TurboModule Methods
 
 - (void)presentAtIndex:(NSInteger)index
               animated:(BOOL)animated
             completion:(nullable TrueSheetCompletionBlock)completion {
-  if (_controller.isPresented) {
-    [_controller.sheetPresentationController animateChanges:^{
-      [self->_controller setupActiveDetentWithIndex:index];
-    }];
-
+  if (_controller.isBeingPresented || _controller.isPresented) {
+    RCTLogWarn(@"TrueSheet: sheet is already presented. Use resize() to change detent.");
     if (completion) {
       completion(YES, nil);
     }
     return;
   }
 
-  UIViewController *presentingViewController = [self findPresentingViewController];
+  // Reset navigation dismiss flag when presenting (handles view recycling edge cases)
+  _dismissedByNavigation = NO;
 
+  UIViewController *presentingViewController = [self findPresentingViewController];
   if (!presentingViewController) {
     NSError *error = [NSError errorWithDomain:@"com.lodev09.TrueSheet"
                                          code:1001
                                      userInfo:@{NSLocalizedDescriptionKey : @"No presenting view controller found"}];
-
     if (completion) {
       completion(NO, error);
     }
     return;
   }
 
-  // Setup our sheet properties
+  [_controller setupAnchorViewInView:presentingViewController.view];
+  [_controller setupSheetSizing];
   [_controller setupSheetProps];
-  [_controller setupSheetDetents];
 
-  // Set to the given detent index
+  // 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 —
+  // async size reports would otherwise land mid-animation and force a
+  // detent retarget that snaps the presentation stack.
+  if (_containerView) {
+    _controller.contentHeight = @([_containerView contentHeight]);
+    _controller.headerHeight = @([_containerView headerHeight]);
+    [self syncFooterMetrics];
+    _controller.peekContentHeight = @([_containerView peekContentHeight]);
+  }
+  _pendingSizeChange = NO;
+
+  [self refreshFooterBottomInset];
+  [_controller setupSheetDetents];
   [_controller setupActiveDetentWithIndex:index];
 
-  // Present our sheet
-  [presentingViewController presentViewController:self->_controller
+  [_screensEventObserver capturePresenterScreenFromView:self];
+  [_screensEventObserver startObservingWithState:_state.get()->getData()];
+
+  UIWindow *window = presentingViewController.view.window;
+  [presentingViewController presentViewController:_controller
                                          animated:animated
                                        completion:^{
-                                         // Call completion handler
+                                         [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)dismissAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion {
+- (void)resizeToIndex:(NSInteger)index completion:(nullable TrueSheetCompletionBlock)completion {
   if (!_controller.isPresented) {
+    RCTLogWarn(@"TrueSheet: Cannot resize. Sheet is not presented.");
     if (completion) {
       completion(YES, nil);
     }
     return;
   }
 
-  [_controller dismissViewControllerAnimated:animated
-                                  completion:^{
-                                    if (completion) {
-                                      completion(YES, nil);
-                                    }
-                                  }];
-}
+  [_controller.sheetPresentationController animateChanges:^{
+    [self->_controller resizeToDetentIndex:index];
+  }];
 
-- (void)resizeToIndex:(NSInteger)index {
-  if (_controller.isPresented) {
-    [_controller.sheetPresentationController animateChanges:^{
-      [self->_controller setupActiveDetentWithIndex:index];
-    }];
+  if (completion) {
+    completion(YES, nil);
   }
 }
 
-- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
-  [super updateProps:props oldProps:oldProps];
+- (TrueSheetViewController *)viewController {
+  return _controller;
+}
 
-  const auto &newProps = *std::static_pointer_cast<TrueSheetViewProps const>(props);
+- (void)emitDismissedPosition {
+  [TrueSheetStateEvents emitPositionChange:_eventEmitter
+                                     index:-1
+                                  position:_controller.screenHeight
+                                    detent:0
+                                  realtime:NO];
+}
 
-  // Update detents - pass numbers directly (-1 represents "auto")
-  NSMutableArray *detents = [NSMutableArray new];
-  for (const auto &detent : newProps.detents) {
-    [detents addObject:@(detent)];
+- (void)dismissAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion {
+  if (_controller.isBeingDismissed || !_controller.isPresented) {
+    RCTLogWarn(@"TrueSheet: sheet is already dismissed. No need to dismiss it again.");
+
+    if (completion) {
+      completion(YES, nil);
+    }
+    return;
   }
 
-  _controller.detents = detents;
+  // Dismiss from the presenting view controller to dismiss this sheet and all its children
+  UIViewController *presenter = _controller.presentingViewController;
+  [presenter dismissViewControllerAnimated:animated
+                                completion:^{
+                                  if (completion) {
+                                    completion(YES, nil);
+                                  }
+                                }];
+}
 
-  // Update background color - always set it, even if 0 (which could be a valid color like black)
-  UIColor *color = RCTUIColorFromSharedColor(SharedColor(newProps.background));
-  _controller.backgroundColor = color;
+- (void)dismissStackAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion {
+  if (_controller.isBeingDismissed || !_controller.isPresented) {
+    RCTLogWarn(@"TrueSheet: sheet is already dismissed. No need to dismiss it again.");
 
-  // Update blur tint - always set it to clear when removed
-  _controller.blurTint = !newProps.blurTint.empty() ? RCTNSStringFromString(newProps.blurTint) : nil;
+    if (completion) {
+      completion(YES, nil);
+    }
+    return;
+  }
 
-  // Update corner radius
-  if (newProps.cornerRadius < 0) {
-    _controller.cornerRadius = nil;
-  } else {
-    _controller.cornerRadius = @(newProps.cornerRadius);
+  // Only dismiss presented children, not this sheet itself
+  if (!_controller.presentedViewController) {
+    if (completion) {
+      completion(YES, nil);
+    }
+    return;
   }
 
-  // Update max height
-  if (newProps.maxHeight != 0.0) {
-    _controller.maxHeight = @(newProps.maxHeight);
+  // Calling dismiss on _controller dismisses all VCs presented on top of it, but keeps _controller presented
+  [_controller dismissViewControllerAnimated:animated
+                                  completion:^{
+                                    if (completion) {
+                                      completion(YES, nil);
+                                    }
+                                  }];
+}
+
+#pragma mark - TrueSheetContainerViewDelegate
+
+/**
+ * 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.
+  if (_controller.isBeingPresented) {
+    _pendingSizeChange = YES;
+    return;
   }
 
-  // Update grabber
-  _controller.grabber = newProps.grabber;
+  // 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)
+    return;
 
-  // Update dismissible
-  _controller.modalInPresentation = !newProps.dismissible;
+  if (_isSheetUpdatePending)
+    return;
 
-  // Update dimmed
-  _controller.dimmed = newProps.dimmed;
+  _isSheetUpdatePending = YES;
 
-  // Update dimmedIndex
-  if (newProps.dimmedIndex >= 0) {
-    _controller.dimmedIndex = @(newProps.dimmedIndex);
-  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    self->_isSheetUpdatePending = NO;
+    if (!self->_containerView || self->_controller.isBeingDismissed)
+      return;
 
-  // Store initial presentation settings
-  _initialDetentIndex = newProps.initialDetentIndex;
-  _initialDetentAnimated = newProps.initialDetentAnimated;
+    // 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];
+  });
 }
 
-- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
-  [super finalizeUpdates:updateMask];
+- (void)containerViewContentDidChangeSize:(CGSize)newSize {
+  _controller.contentHeight = @(newSize.height);
+  [self setupSheetDetentsForSizeChange];
+}
 
-  // Apply controller updates after all props and children are updated
-  if (updateMask & RNComponentViewUpdateMaskProps) {
-    // Apply changes to presented sheet if needed
-    if (_controller.isPresented) {
-      [_controller.sheetPresentationController animateChanges:^{
-        [self->_controller setupSheetDetents];
-        [self->_controller applyActiveDetent];
-      }];
-    } else {
-      // Handle initial presentation
-      if (_initialDetentIndex >= 0 && !_controller.isPresented) {
-        [self presentAtIndex:_initialDetentIndex animated:_initialDetentAnimated completion:nil];
-      }
-    }
-  }
+- (void)containerViewHeaderDidChangeSize:(CGSize)newSize {
+  _controller.headerHeight = @(newSize.height);
+  [self setupSheetDetentsForSizeChange];
 }
 
-- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
-  // Check if it's a container view
-  if ([childComponentView isKindOfClass:[TrueSheetContainerView class]]) {
-    if (_containerView != nil) {
-      NSLog(@"TrueSheet: Sheet can only have one container component.");
-      return;
-    }
+- (void)containerViewFooterDidChangeSize:(CGSize)newSize {
+  [self syncFooterMetrics];
+  [self setupSheetDetentsForSizeChange];
+  [_controller setupAccessibilityContainer];
+}
 
-    _containerView = (TrueSheetContainerView *)childComponentView;
+- (void)containerViewPeekDidChangeSize:(CGSize)newSize {
+  [self setupSheetDetentsForSizeChange];
+}
 
-    // Set this view as the container's delegate
-    _containerView.delegate = self;
+// When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView.
+- (void)containerViewScrollViewDidChange {
+  [self setupScrollable];
+}
 
-    // Attach touch handler to container for touch event handling
-    [_touchHandler attachToView:_containerView];
+#pragma mark - TrueSheetViewControllerDelegate
 
-    // Add to parent view hierarchy
-    [_controller.view addSubview:_containerView];
+- (void)viewControllerWillPresentAtIndex:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent {
+  _controller.activeDetentIndex = index;
+  [TrueSheetLifecycleEvents emitWillPresent:_eventEmitter index:index position:position detent:detent];
+}
 
-    // Pin container to fill the entire parent view
-    [LayoutUtil pinView:_containerView toParentView:_controller.view edges:UIRectEdgeAll];
+- (void)viewControllerDidPresentAtIndex:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent {
+  [_containerView setupKeyboardObserverWithViewController:_controller];
+  [TrueSheetLifecycleEvents emitDidPresent:_eventEmitter index:index position:position detent:detent];
 
-    // Ensure container is above background view
-    [_controller.view bringSubviewToFront:_containerView];
+  if (_pendingPropsUpdate) {
+    _pendingPropsUpdate = NO;
+    [self applySheetPropsUpdate];
+  }
 
-    // Get initial content height from container
-    CGFloat contentHeight = [_containerView contentHeight];
-    if (contentHeight > 0) {
-      _controller.contentHeight = @(contentHeight);
-    }
+  if (_pendingSizeChange) {
+    _pendingSizeChange = NO;
+    [self setupSheetDetentsForSizeChange];
+  }
+}
 
-    // Emit onMount event when container is mounted
-    [OnMountEvent emit:_eventEmitter];
+- (void)viewControllerDidDrag:(UIGestureRecognizerState)state
+                        index:(NSInteger)index
+                     position:(CGFloat)position
+                       detent:(CGFloat)detent {
+  switch (state) {
+    case UIGestureRecognizerStateBegan:
+      [TrueSheetDragEvents emitDragBegin:_eventEmitter index:index position:position detent:detent];
+      break;
+    case UIGestureRecognizerStateChanged:
+      [TrueSheetDragEvents emitDragChange:_eventEmitter index:index position:position detent:detent];
+      break;
+    case UIGestureRecognizerStateEnded:
+    case UIGestureRecognizerStateCancelled:
+      [TrueSheetDragEvents emitDragEnd:_eventEmitter index:index position:position detent:detent];
+      break;
+    default:
+      break;
   }
 }
 
-- (void)unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index {
-  if ([childComponentView isKindOfClass:[TrueSheetContainerView class]]) {
-    _containerView.delegate = nil;
+- (void)viewControllerWillDismiss {
+  if (!_dismissedByNavigation) {
+    [TrueSheetLifecycleEvents emitWillDismiss:_eventEmitter];
+  }
+}
 
-    // Detach touch handler
-    if (_touchHandler) {
-      [_touchHandler detachFromView:_containerView];
-    }
+- (void)viewControllerDidAttemptDismiss {
+  [TrueSheetLifecycleEvents emitDismissAttempt:_eventEmitter];
+}
 
-    // Unpin and remove from view hierarchy
-    [LayoutUtil unpinView:_containerView];
-    [_containerView removeFromSuperview];
+- (void)viewControllerDidDismiss {
+  [_containerView cleanupKeyboardObserver];
+  if (!_dismissedByNavigation) {
+    _dismissedByNavigation = NO;
+    _pendingNavigationRepresent = NO;
 
-    _containerView = nil;
+    _controller.activeDetentIndex = -1;
+    [TrueSheetLifecycleEvents emitDidDismiss:_eventEmitter];
   }
 }
 
-- (void)prepareForRecycle {
-  [super prepareForRecycle];
-  [self invalidate];
+- (void)viewControllerDidChangeDetent:(NSInteger)index position:(CGFloat)position detent:(CGFloat)detent {
+  if (_controller.activeDetentIndex != index) {
+    _controller.activeDetentIndex = index;
+  }
+  [TrueSheetStateEvents emitDetentChange:_eventEmitter index:index position:position detent:detent];
+}
 
-  // Unregister from the registry
-  // Note: Re-registration will happen automatically when the component is reused
-  [TrueSheetModule unregisterViewWithTag:@(self.tag)];
+- (void)viewControllerDidChangePosition:(CGFloat)index
+                               position:(CGFloat)position
+                                 detent:(CGFloat)detent
+                               realtime:(BOOL)realtime {
+  [TrueSheetStateEvents emitPositionChange:_eventEmitter index:index position:position detent:detent realtime:realtime];
 }
 
-#pragma mark - TrueSheetContainerViewDelegate
+- (void)viewControllerDidChangeSize:(CGSize)size {
+  [self updateStateWithSize:size];
+}
 
-- (void)containerViewContentDidChangeSize:(CGSize)newSize {
-  // Clamp content height to container height to prevent unbounded growth with scrollable content
-  CGFloat containerHeight = _controller.containerHeight;
-  CGFloat contentHeight = containerHeight > 0 ? MIN(newSize.height, containerHeight) : newSize.height;
+- (void)viewControllerSafeAreaInsetsDidChange {
+  [self refreshFooterBottomInset];
+}
 
-  _controller.contentHeight = @(contentHeight);
+- (void)viewControllerWillFocus {
+  [TrueSheetFocusEvents emitWillFocus:_eventEmitter];
+}
 
-  // Update detents if sheet is already presented
-  if (_controller.isPresented) {
-    // Tell controller that we are transitioning from layout changes.
-    // Controller viewDidLayoutSubviews will handle position notification.
-    _controller.layoutTransitioning = YES;
+- (void)viewControllerDidFocus {
+  [TrueSheetFocusEvents emitDidFocus:_eventEmitter];
+}
 
-    [_controller.sheetPresentationController animateChanges:^{
-      [self->_controller setupSheetDetents];
-    }];
-  }
+- (void)viewControllerWillBlur {
+  [TrueSheetFocusEvents emitWillBlur:_eventEmitter];
 }
 
-#pragma mark - TrueSheetViewControllerDelegate
+- (void)viewControllerDidBlur {
+  [TrueSheetFocusEvents emitDidBlur:_eventEmitter];
+}
 
-- (void)viewControllerWillPresent {
-  NSInteger index = [_controller currentDetentIndex];
-  CGFloat position = _controller.currentPosition;
+#pragma mark - RNScreensEventObserverDelegate
 
-  _controller.activeDetentIndex = index;
+- (void)presenterScreenWillDisappear {
+  if (_controller.isPresented && !_controller.isBeingDismissed) {
+    _dismissedByNavigation = YES;
+    [self dismissAnimated:YES completion:nil];
+  }
+}
 
-  [OnWillPresentEvent emit:_eventEmitter index:index position:position];
+- (void)presenterScreenWillAppear {
+  if (_dismissedByNavigation && !_controller.isPresented && !_controller.isBeingPresented) {
+    _dismissedByNavigation = NO;
 
-  // Emit onChangeSize event to layout our container on JS
-  CGSize controllerSize = _controller.view.frame.size;
-  [OnSizeChangeEvent emit:_eventEmitter width:controllerSize.width height:controllerSize.height];
+    if (self.window) {
+      [self presentAtIndex:_controller.activeDetentIndex animated:YES completion:nil];
+    } else {
+      _pendingNavigationRepresent = YES;
+    }
+  }
 }
 
-- (void)viewControllerDidPresent {
-  NSInteger index = [_controller currentDetentIndex];
-  CGFloat position = _controller.currentPosition;
+- (void)presenterInteractiveDismissDidBegin {
+  [_controller beginInteractiveDismiss];
+}
 
-  [OnDidPresentEvent emit:_eventEmitter index:index position:position];
+- (void)presenterInteractiveDismissDidUpdate:(CGFloat)progress {
+  [_controller updateInteractiveDismiss:progress];
 }
 
-- (void)viewControllerDidDrag:(UIGestureRecognizerState)state index:(NSInteger)index position:(CGFloat)position {
-  switch (state) {
-    case UIGestureRecognizerStateBegan:
-      [OnDragBeginEvent emit:_eventEmitter index:index position:position];
-      break;
+- (void)presenterInteractiveDismissDidEnd:(BOOL)cancelled duration:(NSTimeInterval)duration {
+  if (cancelled) {
+    [_controller cancelInteractiveDismissWithDuration:duration];
+    return;
+  }
 
-    case UIGestureRecognizerStateChanged:
-      [OnDragChangeEvent emit:_eventEmitter index:index position:position];
-      break;
+  _dismissedByNavigation = YES;
+  __weak __typeof(self) weakSelf = self;
+  [_controller finishInteractiveDismissWithDuration:duration
+                                         completion:^{
+                                           [weakSelf dismissAnimated:NO completion:nil];
+                                         }];
+}
 
-    case UIGestureRecognizerStateEnded:
-    case UIGestureRecognizerStateCancelled:
-      [OnDragEndEvent emit:_eventEmitter index:index position:position];
-      break;
+#pragma mark - Private Helpers
 
-    default:
-      break;
-  }
+- (void)setupScrollable {
+  if (!_containerView)
+    return;
+
+  _containerView.scrollableOptions = _scrollableOptions;
+  _containerView.scrollableHandle = _scrollableHandle;
+  _containerView.contentInsetAdjustment = (_scrollableOptions ? _scrollableOptions.contentInsetAdjustment : YES) &&
+                                          _insetAdjustment == TrueSheetViewInsetAdjustment::Automatic;
+  [self refreshFooterBottomInset];
+  [_containerView setupScrollable];
 }
 
-- (void)viewControllerWillDismiss {
-  [OnWillDismissEvent emit:_eventEmitter];
+// 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];
 }
 
-- (void)viewControllerDidDismiss {
-  _controller.activeDetentIndex = -1;
+// 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;
 
-  [OnDidDismissEvent emit:_eventEmitter];
+  // 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(inset);
+  }
 }
 
-- (void)viewControllerDidChangeDetent:(NSInteger)index position:(CGFloat)position {
-  if (_controller.activeDetentIndex != index) {
-    _controller.activeDetentIndex = index;
+- (void)applySheetPropsUpdate {
+  BOOL pendingLayoutUpdate = _pendingLayoutUpdate;
+  _pendingLayoutUpdate = NO;
+
+  if (_pendingDetents) {
+    _controller.detents = _pendingDetents;
+    _pendingDetents = nil;
+    [self refreshFooterBottomInset];
   }
 
-  [OnDetentChangeEvent emit:_eventEmitter index:index position:position];
-}
+  UIView *presenterView = _controller.presentingViewController.view;
+  [_controller setupAnchorViewInView:presenterView];
 
-- (void)viewControllerDidChangePosition:(NSInteger)index position:(CGFloat)position transitioning:(BOOL)transitioning {
-  [OnPositionChangeEvent emit:_eventEmitter index:index position:position transitioning:transitioning];
-}
+  [_controller setupSheetSizing];
 
-- (void)viewControllerDidChangeSize:(CGSize)size {
-  [OnSizeChangeEvent emit:_eventEmitter width:size.width height:size.height];
+  [_controller.sheetPresentationController animateChanges:^{
+    [self->_controller setupSheetProps];
+    if (pendingLayoutUpdate) {
+      [self->_controller setupSheetDetentsForDetentsChange];
+    } else {
+      [self->_controller setupSheetDetents];
+    }
+    [self->_controller applyActiveDetent];
+  }];
+  [_controller setupDraggable];
 }
 
-#pragma mark - Private Helpers
-
 - (UIViewController *)findPresentingViewController {
-  UIWindow *keyWindow = [WindowUtil keyWindow];
-
-  if (!keyWindow) {
+  if (!self.window)
     return nil;
-  }
 
-  UIViewController *rootViewController = keyWindow.rootViewController;
+  UIViewController *rootViewController = self.window.rootViewController;
+  if (!rootViewController)
+    return nil;
 
-  // Find the top-most presented view controller
+  // Find topmost presented view controller that is not being dismissed
   while (rootViewController.presentedViewController) {
     UIViewController *presented = rootViewController.presentedViewController;
 
-    // Skip TrueSheetViewController if it's being dismissed
-    if ([presented isKindOfClass:[TrueSheetViewController class]] && presented.isBeingDismissed) {
+    // Skip any view controller that is being dismissed
+    if (presented.isBeingDismissed) {
       break;
     }
-
     rootViewController = presented;
   }