@lodev09/react-native-true-sheet 3.11.0-beta.9 → 3.11.0

package/android/src/main/java/com/lodev09/truesheet/TrueSheetFooterView.kt

@@ -3,6 +3,7 @@ package com.lodev09.truesheet
 import android.annotation.SuppressLint
 import android.view.MotionEvent
 import android.view.View
+import android.view.ViewParent
 import com.facebook.react.uimanager.JSPointerDispatcher
 import com.facebook.react.uimanager.JSTouchDispatcher
 import com.facebook.react.uimanager.PointerEvents
@@ -10,6 +11,7 @@ import com.facebook.react.uimanager.RootView
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
+import com.lodev09.truesheet.core.TrueSheetCoordinatorLayout
 
 /**
  * Delegate interface for footer view size changes and event dispatching
@@ -90,12 +92,21 @@ class TrueSheetFooterView(private val reactContext: ThemedReactContext) :
   }
 
   override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    findCoordinatorLayout()?.childDidClaimNativeGesture()
     eventDispatcher?.let { dispatcher ->
       jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
       jsPointerDispatcher?.onChildStartedNativeGesture(childView, ev, dispatcher)
     }
   }
 
+  private fun findCoordinatorLayout(): TrueSheetCoordinatorLayout? {
+    var current: ViewParent? = parent
+    while (current != null && current !is TrueSheetCoordinatorLayout) {
+      current = current.parent
+    }
+    return current as? TrueSheetCoordinatorLayout
+  }
+
   override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
     eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
     jsPointerDispatcher?.onChildEndedNativeGesture()

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -153,6 +153,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   var currentDetentIndex: Int = -1
     private set
 
+  // Target detent index during an in-flight resize animation. -1 when idle.
+  // Used by setupSheetDetents so a layout-driven reconfigure during the
+  // animation doesn't snap the sheet back to the stale currentDetentIndex.
+  private var pendingDetentIndex: Int = -1
+
   private var interactionState: InteractionState = InteractionState.Idle
   internal var isBeingDismissed = false
     private set
@@ -187,6 +192,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private val jsTouchDispatcher = JSTouchDispatcher(this)
   private val jsPointerDispatcher = JSPointerDispatcher(this)
 
+  // True when the active touch stream began inside the footer. Latched on
+  // ACTION_DOWN so subsequent MOVE events keep routing to the footer even if
+  // the finger drifts outside the footer's rect mid-gesture.
+  private var footerOwnsTouchStream = false
+
   private val eventDispatcher
     get() = delegate?.eventDispatcher
 
@@ -376,6 +386,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     isPresentAnimating = false
     lastEmittedPositionPx = -1
     detentIndexBeforeKeyboard = -1
+    pendingDetentIndex = -1
     isKeyboardDismissProgrammatic = false
     focusedViewBeforeBlur = null
     shouldAnimatePresent = true
@@ -568,6 +579,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun handleStateSettled(sheetView: View, newState: Int) {
     if (interactionState is InteractionState.Reconfiguring) return
 
+    // Sheet has reached a stable state — any in-flight resize target is now stale,
+    // whether settled at the target, interrupted by drag, or superseded.
+    pendingDetentIndex = -1
+
     val index = detentCalculator.getDetentIndexForState(newState) ?: return
     val position = getPositionDpForView(sheetView)
     val detentInfo = DetentInfo(index, position)
@@ -711,6 +726,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       detentIndexBeforeKeyboard = detentIndex
     }
 
+    pendingDetentIndex = detentIndex
     setupDimmedBackground()
     setStateForDetentIndex(detentIndex)
     resizePromise?.invoke()
@@ -859,7 +875,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     updateStateDimensions(expandedOffset)
 
     if (isPresented && applyState) {
-      setStateForDetentIndex(currentDetentIndex)
+      // Prefer the pending target while a resize animation is in flight so a
+      // layout-driven reconfigure doesn't revert to the stale currentDetentIndex.
+      val targetIndex = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
+      setStateForDetentIndex(targetIndex)
     }
 
     interactionState = InteractionState.Idle
@@ -1019,7 +1038,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       delegate = object : TrueSheetKeyboardObserverDelegate {
         override fun keyboardWillShow(height: Int) {
           if (!shouldHandleKeyboard()) return
-          detentIndexBeforeKeyboard = currentDetentIndex
+          // If a resize is in flight, restore to its target — not the stale current
+          detentIndexBeforeKeyboard = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
+          pendingDetentIndex = -1
           setupSheetDetents()
           currentDetentIndex = detents.size - 1
           setStateForDetentIndex(currentDetentIndex)
@@ -1097,6 +1118,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   private fun handleDragBegin(sheetView: View) {
     detentIndexBeforeKeyboard = -1
+    pendingDetentIndex = -1
 
     val position = getPositionDpForView(sheetView)
     val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
@@ -1274,26 +1296,36 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override fun dispatchTouchEvent(event: MotionEvent): Boolean {
     val footer = containerView?.footerView
+    val action = event.actionMasked
+
     if (footer != null && footer.isShown) {
-      val footerLocation = ScreenUtils.getScreenLocation(footer)
-      val touchX = event.rawX.toInt()
-      val touchY = event.rawY.toInt()
-
-      if (touchX >= footerLocation[0] &&
-        touchX <= footerLocation[0] + footer.width &&
-        touchY >= footerLocation[1] &&
-        touchY <= footerLocation[1] + footer.height
-      ) {
+      if (action == MotionEvent.ACTION_DOWN) {
+        val loc = ScreenUtils.getScreenLocation(footer)
+        val x = event.rawX.toInt()
+        val y = event.rawY.toInt()
+        footerOwnsTouchStream = x >= loc[0] &&
+          x <= loc[0] + footer.width &&
+          y >= loc[1] &&
+          y <= loc[1] + footer.height
+      }
+
+      if (footerOwnsTouchStream) {
+        val loc = ScreenUtils.getScreenLocation(footer)
         val localEvent = MotionEvent.obtain(event)
-        localEvent.setLocation(
-          (touchX - footerLocation[0]).toFloat(),
-          (touchY - footerLocation[1]).toFloat()
-        )
+        localEvent.setLocation(event.rawX - loc[0], event.rawY - loc[1])
         val handled = footer.dispatchTouchEvent(localEvent)
         localEvent.recycle()
+
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+          footerOwnsTouchStream = false
+        }
         if (handled) return true
       }
     }
+
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+      footerOwnsTouchStream = false
+    }
     return super.dispatchTouchEvent(event)
   }
 
@@ -1325,6 +1357,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    coordinatorLayout?.childDidClaimNativeGesture()
     eventDispatcher?.let {
       jsTouchDispatcher.onChildStartedNativeGesture(ev, it)
       jsPointerDispatcher.onChildStartedNativeGesture(childView, ev, it)

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

@@ -4,8 +4,10 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.content.res.Configuration
 import android.view.MotionEvent
+import android.view.View
 import android.view.ViewConfiguration
 import android.view.ViewGroup
+import android.widget.EditText
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import com.facebook.react.uimanager.PointerEvents
@@ -36,6 +38,23 @@ class TrueSheetCoordinatorLayout(context: Context) :
   private var initialY = 0f
   private var activePointerId = 0
 
+  // Horizontal-dominance tracking. iOS lets horizontal child gestures win over
+  // the sheet's vertical pan; we mirror that by locking out BottomSheetBehavior
+  // interception once the first significant movement of a stream is horizontal.
+  private var streamInitialX = 0f
+  private var streamInitialY = 0f
+  private var streamHorizontalLocked = false
+  private var streamDirectionDecided = false
+
+  // Native-gesture-claim tracking. RNGH handlers activate past BottomSheetBehavior's
+  // drag slop and never call requestDisallowInterceptTouchEvent, so the sheet would
+  // steal vertical gestures (e.g. a vertical pan) before they can activate. While the
+  // touch is inside a descendant GestureHandlerRootView we hold off interception within
+  // a grace distance; once a child claims the gesture (relayed from the RootView impls
+  // via childDidClaimNativeGesture) we yield the rest of the stream, mirroring iOS.
+  private var streamHasGestureRoot = false
+  private var streamGestureClaimed = false
+
   init {
     layoutParams = LayoutParams(
       LayoutParams.MATCH_PARENT,
@@ -86,6 +105,48 @@ class TrueSheetCoordinatorLayout(context: Context) :
     } catch (_: Exception) {}
   }
 
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // RN's ReactEditText fires this(true) on ACTION_DOWN, killing sheet drag over an input.
+    // Swallow only that case — an EditText under the touch with nothing vertically scrollable
+    // (a pinned ScrollView or an overflowing multiline EditText still scrolls). Other children
+    // (maps, sliders, scrollables) keep the standard disallow contract.
+    if (disallowIntercept && touchedViewIsEditText() && !touchedViewCanScrollVertically()) return
+    super.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  private fun touchedViewIsEditText(): Boolean = findDescendantAt(this, streamInitialX.toInt(), streamInitialY.toInt()) { it is EditText }
+
+  private fun touchedViewCanScrollVertically(): Boolean {
+    delegate?.findScrollView()?.let {
+      if (it.canScrollVertically(1) || it.canScrollVertically(-1)) return true
+    }
+    return findDescendantAt(this, streamInitialX.toInt(), streamInitialY.toInt()) {
+      it.canScrollVertically(1) || it.canScrollVertically(-1)
+    }
+  }
+
+  private fun findDescendantAt(view: View, rawX: Int, rawY: Int, predicate: (View) -> Boolean): Boolean {
+    val loc = IntArray(2)
+    view.getLocationOnScreen(loc)
+    if (rawX < loc[0] || rawX > loc[0] + view.width || rawY < loc[1] || rawY > loc[1] + view.height) return false
+    if (predicate(view)) return true
+    if (view is ViewGroup) {
+      for (i in 0 until view.childCount) {
+        if (findDescendantAt(view.getChildAt(i), rawX, rawY, predicate)) return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Called by descendant RootView implementations (controller, footer) when a child
+   * starts a native gesture — e.g. an RNGH handler activated or a scrollable began
+   * scrolling. Yields sheet interception for the rest of the touch stream.
+   */
+  fun childDidClaimNativeGesture() {
+    streamGestureClaimed = true
+  }
+
   /**
    * Intercepts touch events for ScrollViews that can't scroll (content < viewport),
    * allowing the sheet to be dragged in these cases.
@@ -94,8 +155,55 @@ class TrueSheetCoordinatorLayout(context: Context) :
    * See: https://github.com/facebook/react-native/pull/44099
    */
   override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
-    if (ev.actionMasked == MotionEvent.ACTION_DOWN) {
+    val action = ev.actionMasked
+
+    if (action == MotionEvent.ACTION_DOWN) {
       clearStaleNestedScrollingChildRef()
+
+      streamInitialX = ev.rawX
+      streamInitialY = ev.rawY
+      streamHorizontalLocked = false
+      streamDirectionDecided = false
+      streamGestureClaimed = false
+      streamHasGestureRoot = findDescendantAt(this, ev.rawX.toInt(), ev.rawY.toInt()) {
+        it.javaClass.name == GESTURE_HANDLER_ROOT_VIEW_CLASS
+      }
+    }
+
+    // Decide gesture direction on first significant movement of the stream.
+    // If horizontal wins, lock out BottomSheetBehavior for the rest of the stream
+    // so child handlers (carousels, swipe buttons, etc.) can claim the touch.
+    if (!streamDirectionDecided && action == MotionEvent.ACTION_MOVE) {
+      val dx = kotlin.math.abs(ev.rawX - streamInitialX)
+      val dy = kotlin.math.abs(ev.rawY - streamInitialY)
+      if (dx > touchSlop || dy > touchSlop) {
+        streamDirectionDecided = true
+        streamHorizontalLocked = dx > dy
+      }
+    }
+
+    if (streamHorizontalLocked) {
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+        streamHorizontalLocked = false
+        streamDirectionDecided = false
+      }
+      return false
+    }
+
+    if (streamGestureClaimed) {
+      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+        streamGestureClaimed = false
+      }
+      return false
+    }
+
+    // Hold off BottomSheetBehavior within the grace distance so a gesture handler
+    // under the touch can activate and claim the stream first.
+    if (streamHasGestureRoot &&
+      action == MotionEvent.ACTION_MOVE &&
+      kotlin.math.abs(ev.rawY - streamInitialY) < touchSlop * GESTURE_CLAIM_SLOP_FACTOR
+    ) {
+      return false
     }
 
     val scrollView = delegate?.findScrollView()
@@ -151,4 +259,9 @@ class TrueSheetCoordinatorLayout(context: Context) :
     }
     return super.onTouchEvent(ev)
   }
+
+  companion object {
+    private const val GESTURE_HANDLER_ROOT_VIEW_CLASS = "com.swmansion.gesturehandler.react.RNGestureHandlerRootView"
+    private const val GESTURE_CLAIM_SLOP_FACTOR = 3
+  }
 }

package/ios/TrueSheetContainerView.h

@@ -31,6 +31,7 @@ NS_ASSUME_NONNULL_BEGIN
 @optional
 
 - (void)containerViewHeaderDidChangeSize:(CGSize)newSize;
+- (void)containerViewFooterDidChangeSize:(CGSize)newSize;
 
 @end
 
@@ -71,6 +72,8 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (void)layoutFooter;
 
+- (BOOL)hasAccessibilityFooterElements;
+
 /**
  * Setup scrollable content
  */

package/ios/TrueSheetContainerView.mm

@@ -72,10 +72,38 @@ using namespace facebook::react;
     _headerView = nil;
     _footerView = nil;
     _scrollableSet = NO;
+    self.isAccessibilityElement = NO;
   }
   return self;
 }
 
+#pragma mark - Accessibility
+
+- (NSArray *)accessibilityElements {
+  NSMutableArray *elements = [NSMutableArray array];
+  if (_headerView) {
+    [elements addObject:_headerView];
+  }
+  if (_contentView) {
+    [elements addObject:_contentView];
+  }
+  if (_footerView) {
+    // Footer hosts are layout containers; expose their children when present so
+    // VoiceOver and XCTest can target the actual footer controls.
+    NSArray *footerElements = _footerView.accessibilityElements;
+    if (footerElements.count > 0) {
+      [elements addObjectsFromArray:footerElements];
+    } else {
+      [elements addObject:_footerView];
+    }
+  }
+  return elements;
+}
+
+- (BOOL)hasAccessibilityFooterElements {
+  return _footerView && _footerView.accessibilityElements.count > 0;
+}
+
 #pragma mark - Layout
 
 - (void)layoutSubviews {
@@ -234,6 +262,7 @@ using namespace facebook::react;
 #pragma mark - TrueSheetFooterViewDelegate
 
 - (void)footerViewDidChangeSize:(CGSize)newSize {
+  [self.delegate containerViewFooterDidChangeSize:newSize];
   if (@available(iOS 26.0, *)) {
     [self setupEdgeInteractions];
   }

package/ios/TrueSheetFooterView.mm

@@ -37,6 +37,7 @@ using namespace facebook::react;
     _props = defaultProps;
 
     self.backgroundColor = [UIColor clearColor];
+    self.isAccessibilityElement = NO;
 
     _lastHeight = 0;
     _pendingHeight = 0;
@@ -47,6 +48,30 @@ using namespace facebook::react;
   return self;
 }
 
+#pragma mark - Accessibility
+
+- (NSArray *)accessibilityElements {
+  NSMutableArray *elements = [NSMutableArray array];
+  [self collectAccessibilityElementsFromView:self into:elements];
+  if (elements.count > 0) {
+    return elements;
+  }
+
+  return [super accessibilityElements];
+}
+
+- (void)collectAccessibilityElementsFromView:(UIView *)view into:(NSMutableArray *)elements {
+  for (UIView *subview in view.subviews) {
+    if (subview.isAccessibilityElement || subview.accessibilityLabel || subview.accessibilityIdentifier) {
+      [elements addObject:subview];
+    } else if (subview.accessibilityElements.count > 0) {
+      [elements addObjectsFromArray:subview.accessibilityElements];
+    } else {
+      [self collectAccessibilityElementsFromView:subview into:elements];
+    }
+  }
+}
+
 #pragma mark - Layout
 
 - (void)setupConstraintsWithHeight:(CGFloat)height {

package/ios/TrueSheetView.mm

@@ -373,6 +373,9 @@ using namespace facebook::react;
   [_controller.view addSubview:_containerView];
   [LayoutUtil pinView:_containerView toParentView:_controller.view edges:UIRectEdgeAll];
   [_controller.view bringSubviewToFront:_containerView];
+  _containerView.accessibilityViewIsModal = YES;
+  _controller.accessibilityContentView = _containerView;
+  [_controller setupAccessibilityContainer];
 
   CGFloat contentHeight = [_containerView contentHeight];
   if (contentHeight > 0) {
@@ -570,6 +573,10 @@ using namespace facebook::react;
   [self setupSheetDetentsForSizeChange];
 }
 
+- (void)containerViewFooterDidChangeSize:(CGSize)newSize {
+  [_controller setupAccessibilityContainer];
+}
+
 // When the ScrollView changes (e.g. conditional remount), re-pin the new ScrollView.
 - (void)containerViewScrollViewDidChange {
   [self setupScrollable];

package/ios/TrueSheetViewController.h

@@ -75,9 +75,11 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL isPresented;
 @property (nonatomic, assign) NSInteger activeDetentIndex;
 @property (nonatomic, readonly) BOOL isTopmostPresentedController;
+@property (nonatomic, weak, nullable) UIView *accessibilityContentView;
 
 @property (nonatomic, readonly) CGFloat screenHeight;
 
+- (void)setupAccessibilityContainer;
 - (void)applyActiveDetent;
 - (void)setupActiveDetentWithIndex:(NSInteger)index;
 - (void)resizeToDetentIndex:(NSInteger)index;

package/ios/TrueSheetViewController.mm

@@ -7,6 +7,7 @@
 //
 
 #import "TrueSheetViewController.h"
+#import "TrueSheetContainerView.h"
 #import "TrueSheetContentView.h"
 #import "core/TrueSheetBlurView.h"
 #import "core/TrueSheetDetentCalculator.h"
@@ -18,6 +19,7 @@
 
 #import <React/RCTLog.h>
 #import <React/RCTScrollViewComponentView.h>
+#import <objc/runtime.h>
 #import <react/renderer/components/TrueSheetSpec/Props.h>
 
 using namespace facebook::react;
@@ -32,8 +34,16 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
   return fabs(a.position - b.position) <= 0.01 && fabs(a.detent - b.detent) <= 0.01 && fabs(a.index - b.index) <= 0.01;
 }
 
+static char TrueSheetAccessibilityWindowOwnerKey;
+static char TrueSheetAccessibilityWindowPreviousElementsKey;
+
 @interface TrueSheetViewController ()
 
+- (UIViewController *)accessibilityPresentingViewController;
+- (void)restoreWindowAccessibilityElements;
+- (void)setSheetAccessibilityElementsHidden:(BOOL)hidden;
+- (void)setAccessibilityContentElement:(UIView *)contentView;
+
 @end
 
 @implementation TrueSheetViewController {
@@ -55,6 +65,8 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
 
   UIView *_anchorView;
 
+  __weak UIWindow *_accessibilityWindow;
+
   TrueSheetBlurView *_blurView;
   TrueSheetGrabberView *_grabberView;
   TrueSheetDetentCalculator *_detentCalculator;
@@ -95,6 +107,7 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
 }
 
 - (void)dealloc {
+  [self restoreWindowAccessibilityElements];
   [_transitioningTimer invalidate];
   _transitioningTimer = nil;
   [[NSNotificationCenter defaultCenter] removeObserver:self];
@@ -207,6 +220,7 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
     if ([presenter isKindOfClass:[TrueSheetViewController class]]) {
       _parentSheetController = (TrueSheetViewController *)presenter;
       [_parentSheetController.delegate viewControllerWillBlur];
+      [_parentSheetController setAccessibilityContentElement:self.accessibilityContentView ?: self.view];
     }
 
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -224,6 +238,7 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
 
 - (void)viewDidAppear:(BOOL)animated {
   [super viewDidAppear:animated];
+  [self setSheetAccessibilityElementsHidden:NO];
 
   if (!_isPresented) {
     [_parentSheetController.delegate viewControllerDidBlur];
@@ -243,6 +258,137 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
     [self setupGestureRecognizer];
     _isPresented = YES;
   }
+
+  [self setupAccessibilityContainer];
+}
+
+- (void)setupAccessibilityContainer {
+  UIView *contentView = self.accessibilityContentView;
+  if (!contentView) {
+    return;
+  }
+
+  [self setAccessibilityContentElement:contentView];
+}
+
+- (UIViewController *)accessibilityPresentingViewController {
+  UIViewController *presentingViewController = self.presentingViewController;
+  while ([presentingViewController isKindOfClass:[TrueSheetViewController class]] &&
+         presentingViewController.presentingViewController) {
+    presentingViewController = presentingViewController.presentingViewController;
+  }
+  return presentingViewController;
+}
+
+- (void)restoreWindowAccessibilityElements {
+  UIWindow *window = _accessibilityWindow;
+  if (window) {
+    // The active sheet may temporarily own window accessibility traversal. Only
+    // restore the previous value when this controller still owns that override.
+    NSValue *ownerValue = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey);
+    if (ownerValue && ownerValue.nonretainedObjectValue == self) {
+      id previousElements = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey);
+      window.accessibilityElements = previousElements == [NSNull null] ? nil : previousElements;
+      objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+      objc_setAssociatedObject(
+        window, &TrueSheetAccessibilityWindowPreviousElementsKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+
+    _accessibilityWindow = nil;
+  }
+}
+
+- (void)setSheetAccessibilityElementsHidden:(BOOL)hidden {
+  self.view.accessibilityElementsHidden = hidden;
+
+  UIView *presentedView = self.presentationController.presentedView;
+  if (presentedView) {
+    presentedView.accessibilityElementsHidden = hidden;
+  }
+}
+
+- (void)setAccessibilityContentElement:(UIView *)contentView {
+  BOOL hasAccessibilityFooterElements = [contentView isKindOfClass:[TrueSheetContainerView class]] &&
+                                        [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements];
+  // Footer controls exposed as separate accessibility elements can be skipped
+  // by XCTest when the presented sheet is a hard modal accessibility boundary.
+  BOOL isAccessibilityModal = _dimmed && !hasAccessibilityFooterElements;
+
+  // At a hard modal boundary XCTest skips nested elements, so flatten the
+  // container's children into the array. Otherwise expose the container itself:
+  // its accessibilityElements getter recomputes live, so a footer/content subtree
+  // that remounts (e.g. swapping a footer button on a state change) stays
+  // discoverable instead of leaving this snapshot pointing at destroyed views.
+  NSArray *accessibilityElements;
+  if (isAccessibilityModal) {
+    NSArray *contentElements = contentView.accessibilityElements;
+    accessibilityElements = contentElements.count > 0 ? contentElements : @[ contentView ];
+  } else {
+    accessibilityElements = @[ contentView ];
+  }
+
+  self.view.isAccessibilityElement = NO;
+  self.view.accessibilityViewIsModal = YES;
+  self.view.accessibilityElements = accessibilityElements;
+
+  UIView *presentedView = self.presentationController.presentedView;
+  if (presentedView) {
+    presentedView.isAccessibilityElement = NO;
+    presentedView.accessibilityViewIsModal = isAccessibilityModal;
+    presentedView.accessibilityElements = accessibilityElements;
+
+    UIWindow *window = self.view.window;
+    UIViewController *presentingViewController = [self accessibilityPresentingViewController];
+    if (window && presentingViewController.view) {
+      if (!_accessibilityWindow) {
+        _accessibilityWindow = window;
+        id previousElements = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey);
+        if (!previousElements) {
+          previousElements = window.accessibilityElements ?: [NSNull null];
+          objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey, previousElements,
+            OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+        }
+      }
+      objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey, [NSValue valueWithNonretainedObject:self],
+        OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+      window.accessibilityElements =
+        isAccessibilityModal ? @[ presentedView ] : @[ presentingViewController.view, presentedView ];
+      return;
+    }
+  }
+
+  [self restoreWindowAccessibilityElements];
+}
+
+#pragma mark - Presentation
+
+- (void)presentViewController:(UIViewController *)viewControllerToPresent
+                     animated:(BOOL)flag
+                   completion:(void (^)(void))completion {
+  // A non-sheet controller (e.g. an action sheet, alert, or image picker) is about
+  // to present over us. Clear our window accessibility override so UIKit's default
+  // traversal surfaces it for XCTest and assistive technologies; we reclaim the
+  // override when it dismisses. Nested sheets claim their own override.
+  if (![viewControllerToPresent isKindOfClass:[TrueSheetViewController class]]) {
+    self.view.window.accessibilityElements = nil;
+  }
+
+  [super presentViewController:viewControllerToPresent animated:flag completion:completion];
+}
+
+- (void)dismissViewControllerAnimated:(BOOL)flag completion:(void (^)(void))completion {
+  [super dismissViewControllerAnimated:flag
+                            completion:^{
+                              if (completion) {
+                                completion();
+                              }
+
+                              // Reclaim the window accessibility override once nothing
+                              // else is presented over us.
+                              if (self.isPresented && self.presentedViewController == nil) {
+                                [self setupAccessibilityContainer];
+                              }
+                            }];
 }
 
 - (void)emitWillDismissEvents {
@@ -257,6 +403,7 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
 
 - (void)emitDidDismissEvents {
   if (self.isBeingDismissed) {
+    [self restoreWindowAccessibilityElements];
     _isPresented = NO;
     _isWillDismissEmitted = NO;
 
@@ -264,6 +411,8 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
     _anchorView = nil;
 
     [_parentSheetController.delegate viewControllerDidFocus];
+    [_parentSheetController setSheetAccessibilityElementsHidden:NO];
+    [_parentSheetController setupAccessibilityContainer];
     _parentSheetController = nil;
 
     [self.delegate viewControllerDidBlur];
@@ -273,6 +422,8 @@ static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPosi
 
 - (void)viewWillDisappear:(BOOL)animated {
   [super viewWillDisappear:animated];
+  [self restoreWindowAccessibilityElements];
+  [self setSheetAccessibilityElementsHidden:YES];
 
   // Dispatch to allow pan gesture to set _isDragging before checking
   // handleTransitionTracker will emit when sheet is transitioning to dismiss