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

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetBottomSheetView.kt

@@ -1,7 +1,6 @@
 package com.lodev09.truesheet.core
 
 import android.annotation.SuppressLint
-import android.content.res.Configuration
 import android.graphics.Color
 import android.graphics.Outline
 import android.graphics.Rect
@@ -20,6 +19,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.lodev09.truesheet.TrueSheetPlacement
 import com.lodev09.truesheet.utils.ScreenUtils
+import com.lodev09.truesheet.utils.isDarkMode
 
 interface TrueSheetBottomSheetViewDelegate {
   val isTopmostSheet: Boolean
@@ -186,13 +186,8 @@ class TrueSheetBottomSheetView(private val reactContext: ThemedReactContext) : F
     }
   }
 
-  fun getDefaultBackgroundColor(): Int {
-    val isNight = (
-      reactContext.resources.configuration.uiMode and
-        Configuration.UI_MODE_NIGHT_MASK
-      ) == Configuration.UI_MODE_NIGHT_YES
-    return if (isNight) COLOR_SURFACE_CONTAINER_LOW_DARK else COLOR_SURFACE_CONTAINER_LOW_LIGHT
-  }
+  fun getDefaultBackgroundColor(): Int =
+    if (reactContext.isDarkMode) COLOR_SURFACE_CONTAINER_LOW_DARK else COLOR_SURFACE_CONTAINER_LOW_LIGHT
 
   fun setupElevation() {
     val value = delegate?.sheetElevation ?: DEFAULT_ELEVATION

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetCoordinatorLayout.kt

@@ -28,6 +28,9 @@ interface TrueSheetCoordinatorLayoutDelegate {
    * didn't follow, `keyboardWasVisible` whether the keyboard was up when it began.
    */
   fun coordinatorLayoutDidPullDown(overdragPx: Int, keyboardWasVisible: Boolean)
+
+  // A touch that began inside the sheet ended, after the behavior handled the release
+  fun coordinatorLayoutDidEndTouch()
 }
 
 /**
@@ -86,6 +89,10 @@ class TrueSheetCoordinatorLayout(context: Context) :
   private var pullOverdrag = 0f
   private var pullKeyboardVisible = false
 
+  // A touch that began inside the sheet is still down
+  val isTouchingSheet: Boolean
+    get() = pullTracking
+
   init {
     layoutParams = LayoutParams(
       LayoutParams.MATCH_PARENT,
@@ -150,10 +157,16 @@ class TrueSheetCoordinatorLayout(context: Context) :
         if (dy > dx && pullOverdrag > PULL_DOWN_THRESHOLD_DP.dpToPx()) {
           delegate?.coordinatorLayoutDidPullDown(pullOverdrag.toInt(), pullKeyboardVisible)
         }
+        delegate?.coordinatorLayoutDidEndTouch()
         return handled
       }
 
-      MotionEvent.ACTION_CANCEL -> pullTracking = false
+      MotionEvent.ACTION_CANCEL -> if (pullTracking) {
+        pullTracking = false
+        val handled = super.dispatchTouchEvent(ev)
+        delegate?.coordinatorLayoutDidEndTouch()
+        return handled
+      }
     }
     return super.dispatchTouchEvent(ev)
   }

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDimView.kt

@@ -34,10 +34,6 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   View(reactContext),
   ReactPointerEventsView {
 
-  companion object {
-    private const val MAX_ALPHA = 0.5f
-  }
-
   var delegate: TrueSheetDimViewDelegate? = null
 
   private var targetView: ViewGroup? = null
@@ -48,6 +44,10 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   private val blockGestures: Boolean
     get() = alpha > 0f
 
+  fun setDimColor(color: Int) {
+    setBackgroundColor(color)
+  }
+
   init {
     layoutParams = ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
@@ -109,30 +109,24 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   }
 
   // =============================================================================
-  // MARK: - Alpha Calculation
+  // MARK: - Progress Calculation
   // =============================================================================
 
-  fun calculateAlpha(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int): Float {
+  /**
+   * How far the sheet is into its dimmed range, from 0 (undimmed) to 1 (fully dimmed).
+   */
+  fun calculateProgress(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int): Float {
     val realHeight = ScreenUtils.getRealScreenHeight(reactContext)
     val dimmedDetentTop = getSheetTopForDetentIndex(dimmedDetentIndex)
     val belowDimmedTop = if (dimmedDetentIndex > 0) getSheetTopForDetentIndex(dimmedDetentIndex - 1) else realHeight
 
     return when {
-      sheetTop <= dimmedDetentTop -> MAX_ALPHA
-
+      sheetTop <= dimmedDetentTop -> 1f
       sheetTop >= belowDimmedTop -> 0f
-
-      else -> {
-        val progress = 1f - (sheetTop - dimmedDetentTop).toFloat() / (belowDimmedTop - dimmedDetentTop)
-        (progress * MAX_ALPHA).coerceIn(0f, MAX_ALPHA)
-      }
+      else -> (1f - (sheetTop - dimmedDetentTop).toFloat() / (belowDimmedTop - dimmedDetentTop)).coerceIn(0f, 1f)
     }
   }
 
-  fun interpolateAlpha(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int) {
-    alpha = calculateAlpha(sheetTop, dimmedDetentIndex, getSheetTopForDetentIndex)
-  }
-
   // =============================================================================
   // MARK: - Touch Handling
   // =============================================================================

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetGrabberView.kt

@@ -2,7 +2,6 @@ package com.lodev09.truesheet.core
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.content.res.Configuration
 import android.graphics.Color
 import android.graphics.drawable.GradientDrawable
 import android.os.Bundle
@@ -13,6 +12,7 @@ import android.widget.FrameLayout
 import androidx.core.graphics.ColorUtils
 import androidx.core.view.ViewCompat
 import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.lodev09.truesheet.utils.isDarkMode
 
 /**
  * Options for customizing the grabber appearance.
@@ -165,9 +165,7 @@ class TrueSheetGrabberView(
   }
 
   private fun getAdaptiveColor(baseColor: Int? = null): Int {
-    val nightMode = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
-    val isDarkMode = nightMode == Configuration.UI_MODE_NIGHT_YES
-    val modeColor = if (isDarkMode) Color.WHITE else Color.BLACK
+    val modeColor = if (context.isDarkMode) Color.WHITE else Color.BLACK
 
     return if (baseColor != null) {
       // Blend user color with mode color for adaptive effect

package/android/src/main/java/com/lodev09/truesheet/utils/ColorUtils.kt

@@ -0,0 +1,19 @@
+package com.lodev09.truesheet.utils
+
+import android.content.Context
+import android.content.res.Configuration
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+/**
+ * Resolves a processed color (number or `PlatformColor` map) at [key], or null when missing.
+ */
+fun ReadableMap.getColorOrNull(key: String, context: Context): Int? {
+  if (!hasKey(key) || isNull(key)) return null
+  val value = if (getType(key) == ReadableType.Map) getMap(key) else getDouble(key)
+  return ColorPropConverter.getColor(value, context)
+}
+
+val Context.isDarkMode: Boolean
+  get() = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES

package/ios/TrueSheetModule.mm

@@ -149,11 +149,17 @@ RCT_EXPORT_MODULE(TrueSheetModule)
 - (void)dismissAll:(BOOL)animated resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   RCTExecuteOnMainQueue(^{
     @synchronized(viewRegistry) {
+      // Drop presents still waiting on another sheet's dismissal
+      for (TrueSheetView *view in viewRegistry.objectEnumerator) {
+        [view cancelPendingPresent];
+      }
+
       // Find the root presented sheet (one without a parent TrueSheet)
       TrueSheetView *rootSheet = nil;
 
       for (TrueSheetView *view in viewRegistry.objectEnumerator) {
-        if (!view.viewController.isPresented) {
+        // A sheet still animating in counts too — dismissAnimated waits for it to land
+        if (!view.viewController.isPresented && !view.viewController.isBeingPresented) {
           continue;
         }
 
@@ -171,7 +177,10 @@ RCT_EXPORT_MODULE(TrueSheetModule)
         return;
       }
 
-      [rootSheet emitDismissedPosition];
+      // Mid-present, the deferred dismiss tracks its own position like a regular dismiss
+      if (rootSheet.viewController.isPresented) {
+        [rootSheet emitDismissedPosition];
+      }
       [rootSheet dismissAnimated:animated
                       completion:^(BOOL success, NSError *_Nullable error) {
                         if (success) {

package/ios/TrueSheetView.h

@@ -34,6 +34,8 @@ typedef void (^TrueSheetCompletionBlock)(BOOL success, NSError *_Nullable error)
 
 - (void)emitDismissedPosition;
 
+- (BOOL)cancelPendingPresent;
+
 - (void)resizeToIndex:(NSInteger)index completion:(nullable TrueSheetCompletionBlock)completion;
 
 - (void)dismissStackAnimated:(BOOL)animated completion:(nullable TrueSheetCompletionBlock)completion;

package/ios/TrueSheetView.mm

@@ -317,6 +317,8 @@ using namespace facebook::react;
   _controller.dismissible = newProps.dismissible;
   _controller.draggable = newProps.draggable;
   _controller.dimmed = newProps.dimmed;
+  _controller.dimOpacity = newProps.dimOpacity < 0 ? nil : @(newProps.dimOpacity);
+  _controller.dimColor = RCTUIColorFromSharedColor(newProps.dimColor);
 
   if (newProps.dimmedDetentIndex >= 0) {
     _controller.dimmedDetentIndex = @(newProps.dimmedDetentIndex);
@@ -419,7 +421,8 @@ using namespace facebook::react;
   [self setupScrollable];
 
   if (_controller.isPresented) {
-    [self applySheetPropsUpdate];
+    _pendingPropsUpdate = YES;
+    [self setupSheetDetentsForSizeChange];
   } else if (_controller.isBeingPresented) {
     _pendingPropsUpdate = YES;
   } else if (_initialDetentIndex >= 0) {
@@ -630,6 +633,8 @@ using namespace facebook::react;
     _controller.peekContentHeight = @([_containerView peekContentHeight]);
   }
   _pendingSizeChange = NO;
+  // Props queued while the previous presentation dismissed — applied above.
+  _pendingPropsUpdate = NO;
 
   [self refreshFooterBottomInset];
   [_controller setupSheetDetents];
@@ -719,6 +724,20 @@ using namespace facebook::react;
     return;
   }
 
+  // Still animating in (isPresented flips at viewDidAppear): dismiss once the presentation lands
+  id<UIViewControllerTransitionCoordinator> presentCoordinator =
+    _controller.isBeingPresented ? _controller.transitionCoordinator : nil;
+  if (presentCoordinator) {
+    __weak __typeof(self) weakSelf = self;
+    [presentCoordinator animateAlongsideTransition:nil
+                                        completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                          dispatch_async(dispatch_get_main_queue(), ^{
+                                            [weakSelf dismissAnimated:animated completion:completion];
+                                          });
+                                        }];
+    return;
+  }
+
   if (_controller.isBeingDismissed || !_controller.isPresented) {
     RCTLogWarn(@"TrueSheet: sheet is already dismissed. No need to dismiss it again.");
 
@@ -768,7 +787,8 @@ using namespace facebook::react;
 #pragma mark - TrueSheetContainerViewDelegate
 
 /**
- * Debounced sheet update to handle rapid content/header size changes.
+ * Coalesces prop and size changes outside Fabric's mount transaction so
+ * the footer's layout can mount inside UIKit's resize animation.
  */
 - (void)setupSheetDetentsForSizeChange {
   // Keep the footer's absorbed inset in sync with the latest measured heights
@@ -784,26 +804,52 @@ using namespace facebook::react;
   }
 
   // Not presented: presentAtIndex measures at present time.
-  // Dismissing: the sheet is going away — touching detents perturbs the
-  // presentation stack, visibly glitching the sheet behind.
-  if (!_controller.isPresented || _controller.isBeingDismissed)
+  if (!_controller.isPresented || _isSheetUpdatePending)
     return;
 
-  if (_isSheetUpdatePending)
+  // Dismissing: the sheet is going away — touching detents perturbs the
+  // presentation stack, visibly glitching the sheet behind. An interactive
+  // dismiss can still cancel, so retry once the transition resolves.
+  if (_controller.isBeingDismissed) {
+    id<UIViewControllerTransitionCoordinator> coordinator = _controller.transitionCoordinator;
+    if (coordinator) {
+      _isSheetUpdatePending = YES;
+
+      __weak __typeof(self) weakSelf = self;
+      [coordinator animateAlongsideTransition:nil
+                                   completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+                                     dispatch_async(dispatch_get_main_queue(), ^{
+                                       __typeof(self) strongSelf = weakSelf;
+                                       if (!strongSelf)
+                                         return;
+
+                                       strongSelf->_isSheetUpdatePending = NO;
+                                       [strongSelf setupSheetDetentsForSizeChange];
+                                     });
+                                   }];
+    }
     return;
+  }
 
   _isSheetUpdatePending = YES;
 
   dispatch_async(dispatch_get_main_queue(), ^{
     self->_isSheetUpdatePending = NO;
-    if (!self->_containerView || self->_controller.isBeingDismissed)
+    if (!self->_containerView || !self->_controller.isPresented || self->_controller.isBeingDismissed)
       return;
 
     // Refresh here (not just on peek size events) since the peek's offset
     // within the content can change without its own size changing.
     self->_controller.peekContentHeight = @([self->_containerView peekContentHeight]);
     [self refreshFooterBottomInset];
+
+    // Size first: the props rebuild refreshes the heights itself, hiding the
+    // change from the controller and skipping its post-resize settle.
     [self->_controller setupSheetDetentsForSizeChange];
+    if (self->_pendingPropsUpdate) {
+      self->_pendingPropsUpdate = NO;
+      [self applySheetPropsUpdate];
+    }
   });
 }
 

package/ios/TrueSheetViewController.h

@@ -78,6 +78,8 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) facebook::react::TrueSheetViewAccessibilityOptionsStruct accessibilityOptions;
 @property (nonatomic, assign) BOOL draggable;
 @property (nonatomic, assign) BOOL dimmed;
+@property (nonatomic, strong, nullable) UIColor *dimColor;
+@property (nonatomic, strong, nullable) NSNumber *dimOpacity;
 @property (nonatomic, strong, nullable) NSNumber *dimmedDetentIndex;
 @property (nonatomic, assign) facebook::react::TrueSheetViewBackgroundBlur backgroundBlur;
 @property (nonatomic, assign) facebook::react::TrueSheetViewPresentation presentation;

package/ios/TrueSheetViewController.mm

@@ -11,10 +11,12 @@
 #import "TrueSheetContentView.h"
 #import "core/TrueSheetBlurView.h"
 #import "core/TrueSheetDetentCalculator.h"
+#import "core/TrueSheetDimView.h"
 #import "core/TrueSheetGrabberView.h"
 #import "utils/BlurUtil.h"
 #import "utils/GestureUtil.h"
 #import "utils/PlatformUtil.h"
+#import "utils/UIView+FirstResponder.h"
 #import "utils/WindowUtil.h"
 
 #import <React/RCTLog.h>
@@ -81,6 +83,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   // coordinator — started alongside the transition, stopped in its completion.
   CADisplayLink *_transitionLink;
   BOOL _isTransitioning;
+  // Where the sheet rests during the transition: the target on present, the start on dismiss
+  CGFloat _transitionRestPosition;
 
   BOOL _pendingContentSizeChange;
   BOOL _pendingDetentsChange;
@@ -91,6 +95,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   // for the next present (beats the float-threshold guess for re-presents).
   BOOL _hasObservedBottomInset;
   CGFloat _observedBottomInset;
+  BOOL _isRefreshingSafeArea;
 
   BOOL _isInteractiveDismiss;
   CGFloat _interactiveStartPosition;
@@ -99,6 +104,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   CADisplayLink *_interactivePositionLink;
 
   __weak TrueSheetViewController *_parentSheetController;
+  __weak UIView *_presenterFirstResponder;
 
   UIView *_anchorView;
 
@@ -107,6 +113,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   TrueSheetBlurView *_blurView;
   TrueSheetGrabberView *_grabberView;
   TrueSheetDetentCalculator *_detentCalculator;
+  TrueSheetDimView *_dimView;
 }
 
 #pragma mark - Initialization
@@ -126,6 +133,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _footerAvoidsKeyboard = YES;
     _dismissible = YES;
     _dimmed = YES;
+    _dimColor = nil;
+    _dimOpacity = nil;
     _dimmedDetentIndex = @(0);
     _presentation = facebook::react::TrueSheetViewPresentation::Page;
     _lastEmittedPositionState = (TrueSheetPositionState){0, 0, 0};
@@ -316,6 +325,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // wrong leaves the safe-area region unfilled (gap) or double-padded.
   UIView *view = self.viewIfLoaded;
   if (view.window) {
+    // Mid-present, hold the expected inset over a stale zero so the footer
+    // doesn't shrink and regrow — viewDidAppear forces the real value.
+    if (!_isPresented && [self hasStaleBottomSafeArea]) {
+      return [self bottomSafeAreaForHeight:view.bounds.size.height];
+    }
+
     _hasObservedBottomInset = YES;
     _observedBottomInset = view.safeAreaInsets.bottom;
     return _observedBottomInset;
@@ -430,6 +445,67 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [_grabberView addToView:self.view];
 }
 
+#pragma mark - Custom Dimming
+
+// UISheetPresentationController has no API for the dim's color or opacity, so a custom
+// color/opacity turns the native dim off and fades in our own view behind the sheet.
+- (BOOL)useCustomDimming {
+  return self.dimmed && (self.dimColor != nil || self.dimOpacity != nil);
+}
+
+- (BOOL)isDimmedAtEveryDetent {
+  return self.dimmed && [self.dimmedDetentIndex integerValue] == 0;
+}
+
+// Like the system dim, fades in between the detent below `dimmedDetentIndex` and the dimmed detent.
+- (CGFloat)dimAlphaForIndex:(CGFloat)index {
+  if (![self useCustomDimming]) {
+    return 0;
+  }
+
+  CGFloat progress = index - [self.dimmedDetentIndex integerValue] + 1;
+  return fmax(0, fmin(1, progress));
+}
+
+// Present and dismiss fade the dim over the whole travel below the resting position.
+- (CGFloat)dimAlphaForPosition:(CGFloat)position index:(CGFloat)index {
+  if (!_isTransitioning || position <= _transitionRestPosition) {
+    return [self dimAlphaForIndex:index];
+  }
+
+  CGFloat travel = self.screenHeight - _transitionRestPosition;
+  CGFloat progress = travel > 0 ? fmax(0, (self.screenHeight - position) / travel) : 0;
+  return [self dimAlphaForIndex:[self interpolatedIndexForPosition:_transitionRestPosition]] * progress;
+}
+
+- (void)setupDimView {
+  UIView *container = self.presentationController.containerView;
+  if (!container || (!_dimView && ![self useCustomDimming])) {
+    return;
+  }
+
+  if (!_dimView) {
+    _dimView = [[TrueSheetDimView alloc] init];
+
+    __weak __typeof(self) weakSelf = self;
+    _dimView.onTap = ^{
+      [weakSelf handleDimViewTap];
+    };
+  }
+
+  // Keep opacity in the color so a transparent dim still receives touches.
+  UIColor *color = self.dimColor ?: [UIColor blackColor];
+  CGFloat opacity = self.dimOpacity ? [self.dimOpacity doubleValue] : 0.5;
+  _dimView.backgroundColor = [color colorWithAlphaComponent:CGColorGetAlpha(color.CGColor) * opacity];
+  [_dimView addToView:container];
+}
+
+- (void)handleDimViewTap {
+  if (self.dismissible) {
+    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  }
+}
+
 - (void)viewWillAppear:(BOOL)animated {
   [super viewWillAppear:animated];
 
@@ -443,6 +519,17 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       [_parentSheetController setAccessibilityContentElement:self.accessibilityContentView ?: self.view];
     }
 
+    [self setupDimView];
+
+    // UIKit hides the presenter's keyboard under a sheet dimmed at every detent and
+    // brings it back on dismiss, but custom dimming leaves the native sheet undimmed.
+    if ([self useCustomDimming] && [self isDimmedAtEveryDetent]) {
+      UIView *firstResponder = [presenter.view findFirstResponder];
+      if ([firstResponder resignFirstResponder]) {
+        _presenterFirstResponder = firstResponder;
+      }
+    }
+
     dispatch_async(dispatch_get_main_queue(), ^{
       NSInteger index = self.currentDetentIndex;
       CGFloat position = self.currentPosition;
@@ -475,11 +562,41 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
     [self setupGestureRecognizer];
     _isPresented = YES;
+    [self refreshStaleBottomSafeArea];
   }
 
   [self setupAccessibilityContainer];
 }
 
+/**
+ * A present that overlaps another transition (e.g. re-presenting while a
+ * native stack pops) can leave the root view's bottom safe area at zero, and
+ * UIKit doesn't recompute it until the sheet's frame next changes. Suspect a
+ * zero the presented height says shouldn't be there — a small floating sheet
+ * legitimately has none.
+ */
+- (BOOL)hasStaleBottomSafeArea {
+  UIView *view = self.viewIfLoaded;
+  return view.window && view.safeAreaInsets.bottom <= 0 && [self bottomSafeAreaForHeight:view.bounds.size.height] > 0;
+}
+
+// Toggling additionalSafeAreaInsets forces UIKit to recompute the safe area.
+// The toggle's intermediate value isn't reported, so the footer only sees the
+// settled one.
+- (void)refreshStaleBottomSafeArea {
+  if (![self hasStaleBottomSafeArea]) {
+    return;
+  }
+
+  _isRefreshingSafeArea = YES;
+  UIEdgeInsets insets = self.additionalSafeAreaInsets;
+  self.additionalSafeAreaInsets = UIEdgeInsetsMake(insets.top, insets.left, insets.bottom + 1, insets.right);
+  self.additionalSafeAreaInsets = insets;
+  _isRefreshingSafeArea = NO;
+
+  [self.delegate viewControllerSafeAreaInsetsDidChange];
+}
+
 - (void)setupAccessibilityContainer {
   UIView *contentView = self.accessibilityContentView;
   if (!contentView) {
@@ -656,6 +773,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     [self.delegate viewControllerWillBlur];
     [self.delegate viewControllerWillDismiss];
     [_parentSheetController.delegate viewControllerWillFocus];
+
+    // Restored once the dismiss commits, like UIKit's own keyboard preservation.
+    UIView *firstResponder = _presenterFirstResponder;
+    _presenterFirstResponder = nil;
+    if (!self.presentingViewController.isBeingDismissed) {
+      [firstResponder becomeFirstResponder];
+    }
   }
 }
 
@@ -666,6 +790,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _isWillDismissEmitted = NO;
     _hasObservedBottomInset = NO;
 
+    [_dimView removeFromSuperview];
+    _dimView = nil;
+
     [_anchorView removeFromSuperview];
     _anchorView = nil;
 
@@ -684,6 +811,15 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self restoreWindowAccessibilityElements];
   [self setSheetAccessibilityElementsHidden:YES];
 
+  // Dismissing with a child on top only animates the child out — this sheet
+  // doesn't move and isn't part of that transition, so fade its dim over it.
+  if (self.isBeingDismissed && self.presentedViewController) {
+    [UIView animateWithDuration:self.transitionCoordinator.transitionDuration
+                     animations:^{
+                       self->_dimView.alpha = 0;
+                     }];
+  }
+
   // Dispatch to allow pan gesture to set _isDragging before checking;
   // the transition tracker emits when the sheet is transitioning to dismiss
   dispatch_async(dispatch_get_main_queue(), ^{
@@ -779,7 +915,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   // Mid-dismiss the frame moves off-screen and reports transient insets —
   // don't let them pollute the observed value (matches viewDidLayoutSubviews).
-  if (!self.isBeingDismissed) {
+  if (!self.isBeingDismissed && !_isRefreshingSafeArea) {
     [self.delegate viewControllerSafeAreaInsetsDidChange];
   }
 }
@@ -928,6 +1064,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 
   _isTransitioning = YES;
+  _transitionRestPosition = self.isBeingDismissed ? self.livePosition : self.currentPosition;
 
   // Learn the resolver-vs-actual offset before emitting transition positions so
   // the interpolated index lands exactly on the target detent. The presented
@@ -963,10 +1100,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       // Settle after a present, cancelled dismiss, or detent-snap transition.
       // Delayed because the presentedView frame isn't final until UIKit
       // completes its layout pass after the transition animation — learning
-      // here absorbs any sub-pixel drift since the earlier learns.
+      // here absorbs any sub-pixel drift since the earlier learns. A dismiss
+      // cancelled mid-drag leaves the finger down, so the drag end settles instead.
       if (strongSelf->_isPresented && !strongSelf.isBeingDismissed) {
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-          [strongSelf settleAtDetentIndex:strongSelf.currentDetentIndex debug:@"transition end"];
+          if (!strongSelf->_isDragging) {
+            [strongSelf settleAtDetentIndex:strongSelf.currentDetentIndex debug:@"transition end"];
+          }
         });
       }
     }];
@@ -1145,6 +1285,11 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     .index = [self interpolatedIndexForPosition:position],
   };
 
+  // A child on top only pushes this sheet back, its detent stays.
+  if (!presented) {
+    _dimView.alpha = [self dimAlphaForPosition:position index:state.index];
+  }
+
   // Settle (non-realtime) emits are authoritative and bypass the dedupe — a
   // learn right before them can correct the interpolated index by less than
   // the tolerance, and the corrected value must still reach JS.
@@ -1263,7 +1408,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   sheet.detents = detents;
 
-  if (self.dimmed && [self.dimmedDetentIndex integerValue] == 0) {
+  if ([self useCustomDimming]) {
+    sheet.largestUndimmedDetentIdentifier = sheet.detents.lastObject.identifier;
+  } else if ([self isDimmedAtEveryDetent]) {
     sheet.largestUndimmedDetentIdentifier = nil;
   } else {
     sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
@@ -1702,6 +1849,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   [self setupBackground];
   [self setupGrabber];
+
+  // Dim props changed while presented. A hidden custom dim stays until dismiss;
+  // at alpha 0 it no longer takes touches.
+  if (_isPresented) {
+    [self setupDimView];
+    _dimView.alpha = [self dimAlphaForIndex:self.currentDetentIndex];
+  }
 }
 
 #pragma mark - UISheetPresentationControllerDelegate

package/ios/core/RNScreensEventObserver.mm

@@ -272,7 +272,24 @@ using namespace facebook::react;
 
   // Dismiss if presenter is no longer top of nav stack (pushed/popped)
   // Skip if still top (e.g. modal dismiss - sheet dismisses naturally)
-  return navController.topViewController != _presenterScreenController;
+  if (navController.topViewController != _presenterScreenController) {
+    return YES;
+  }
+
+  // A presenter inside a screen container (e.g. a bottom tab) stays the top of
+  // that container while an enclosing stack pushes a screen over it.
+  for (UINavigationController *outerNav = navController.navigationController; outerNav;
+    outerNav = outerNav.navigationController) {
+    UIViewController *ancestor = _presenterScreenController;
+    while (ancestor && ancestor != outerNav.topViewController) {
+      ancestor = ancestor.parentViewController;
+    }
+    if (!ancestor) {
+      return YES;
+    }
+  }
+
+  return NO;
 }
 
 @end