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

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/TrueSheetView.kt

@@ -7,6 +7,7 @@ import android.view.accessibility.AccessibilityEvent
 import androidx.annotation.UiThread
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PixelUtil.pxToDp
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
@@ -283,6 +284,11 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     setupScrollable()
   }
 
+  fun setFooterKeyboardOffset(offset: Float) {
+    viewController.footerKeyboardOffset = offset.dpToPx().toInt()
+    viewController.positionFooter()
+  }
+
   private fun setupScrollable() {
     viewController.containerView?.let {
       it.insetAdjustment = viewController.insetAdjustment

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
@@ -960,6 +979,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // MARK: - Footer Positioning
   // =============================================================================
 
+  var footerKeyboardOffset: Int = 0
+
   fun positionFooter(slideOffset: Float? = null) {
     if (!isPresented) return
     val footerView = containerView?.footerView ?: return
@@ -969,7 +990,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val sheetHeight = sheet.height
     val sheetTop = sheet.top
 
-    var footerY = (sheetHeight - sheetTop - footerHeight - currentKeyboardInset).toFloat()
+    val keyboardShift = if (currentKeyboardInset > 0) maxOf(0, currentKeyboardInset + footerKeyboardOffset) else 0
+    var footerY = (sheetHeight - sheetTop - footerHeight - keyboardShift).toFloat()
 
     // Adjust during dismiss animation when slideOffset is negative
     if (slideOffset != null && slideOffset < 0) {
@@ -1019,7 +1041,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 +1121,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 +1299,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 +1360,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/TrueSheetViewManager.kt

@@ -230,6 +230,13 @@ class TrueSheetViewManager :
     view.setScrollableOptions(scrollableOptions)
   }
 
+  @ReactProp(name = "footerOptions")
+  override fun setFooterOptions(view: TrueSheetView, options: ReadableMap?) {
+    val keyboardOffset =
+      if (options != null && options.hasKey("keyboardOffset")) options.getDouble("keyboardOffset").toFloat() else 0f
+    view.setFooterKeyboardOffset(keyboardOffset)
+  }
+
   companion object {
     const val REACT_CLASS = "TrueSheetView"
     const val TAG_NAME = "TrueSheet"

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,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (void)layoutFooter;
 
+/**
+ * Re-applies the footer's keyboard slide to reflect a live `keyboardOffset` change.
+ */
+- (void)updateFooterKeyboardOffset;
+
+- (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 {
@@ -100,6 +128,10 @@ using namespace facebook::react;
   }
 }
 
+- (void)updateFooterKeyboardOffset {
+  [_footerView applyKeyboardOffset];
+}
+
 - (void)setScrollableEnabled:(BOOL)scrollableEnabled {
   _scrollableEnabled = scrollableEnabled;
   _scrollableSet = YES;
@@ -234,6 +266,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.h

@@ -29,6 +29,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)setupConstraintsWithHeight:(CGFloat)height;
 
+/**
+ * Re-applies the footer's keyboard slide using the current keyboard height.
+ * No-op when the keyboard is hidden. Used to reflect live `keyboardOffset` changes.
+ */
+- (void)applyKeyboardOffset;
+
 @end
 
 NS_ASSUME_NONNULL_END

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 {
@@ -126,13 +151,15 @@ using namespace facebook::react;
     return;
   }
 
-  _currentKeyboardOffset = height;
+  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
+  CGFloat slide = MAX(0, height + keyboardOffset);
+  _currentKeyboardOffset = slide;
 
   [UIView animateWithDuration:duration
                         delay:0
                       options:curve | UIViewAnimationOptionBeginFromCurrentState
                    animations:^{
-                     self->_bottomConstraint.constant = -height;
+                     self->_bottomConstraint.constant = -slide;
                      [self.superview layoutIfNeeded];
                    }
                    completion:nil];
@@ -155,6 +182,19 @@ using namespace facebook::react;
                    completion:nil];
 }
 
+- (void)applyKeyboardOffset {
+  CGFloat height = self.keyboardObserver.currentHeight;
+  if (!_bottomConstraint || height <= 0) {
+    return;
+  }
+
+  CGFloat keyboardOffset = self.keyboardObserver.viewController.footerKeyboardOffset;
+  CGFloat slide = MAX(0, height + keyboardOffset);
+  _currentKeyboardOffset = slide;
+  _bottomConstraint.constant = -slide;
+  [self.superview layoutIfNeeded];
+}
+
 @end
 
 Class<RCTComponentViewProtocol> TrueSheetFooterViewCls(void) {

package/ios/TrueSheetView.mm

@@ -264,6 +264,12 @@ using namespace facebook::react;
 
   _controller.scrollingExpandsSheet = scrollingExpandsSheet;
 
+  CGFloat footerKeyboardOffset = newProps.footerOptions.keyboardOffset;
+  if (_controller.footerKeyboardOffset != footerKeyboardOffset) {
+    _controller.footerKeyboardOffset = footerKeyboardOffset;
+    [_containerView updateFooterKeyboardOffset];
+  }
+
   _insetAdjustment = newProps.insetAdjustment;
   _controller.insetAdjustment = _insetAdjustment;
 
@@ -373,6 +379,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 +579,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

@@ -71,13 +71,16 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) facebook::react::TrueSheetViewAnchor anchor;
 @property (nonatomic, assign) facebook::react::TrueSheetViewInsetAdjustment insetAdjustment;
 @property (nonatomic, assign) BOOL scrollingExpandsSheet;
+@property (nonatomic, assign) CGFloat footerKeyboardOffset;
 @property (nonatomic, assign) BOOL dismissible;
 @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;