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

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

@@ -2,72 +2,84 @@ package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
 import android.view.View
-import android.view.ViewStructure
+import android.view.ViewGroup
 import android.view.accessibility.AccessibilityEvent
 import androidx.annotation.UiThread
 import com.facebook.react.bridge.LifecycleEventListener
+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
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.util.RNLog
 import com.facebook.react.views.view.ReactViewGroup
-import com.lodev09.truesheet.events.DetentChangeEvent
-import com.lodev09.truesheet.events.DidDismissEvent
-import com.lodev09.truesheet.events.DidPresentEvent
-import com.lodev09.truesheet.events.DragBeginEvent
-import com.lodev09.truesheet.events.DragChangeEvent
-import com.lodev09.truesheet.events.DragEndEvent
-import com.lodev09.truesheet.events.MountEvent
-import com.lodev09.truesheet.events.PositionChangeEvent
-import com.lodev09.truesheet.events.SizeChangeEvent
-import com.lodev09.truesheet.events.WillDismissEvent
-import com.lodev09.truesheet.events.WillPresentEvent
+import com.lodev09.truesheet.core.AccessibilityOptions
+import com.lodev09.truesheet.core.GrabberOptions
+import com.lodev09.truesheet.core.RNScreensEventObserver
+import com.lodev09.truesheet.core.RNScreensEventObserverDelegate
+import com.lodev09.truesheet.core.TrueSheetStackManager
+import com.lodev09.truesheet.events.*
+import com.lodev09.truesheet.utils.KeyboardUtils
+import com.lodev09.truesheet.utils.findRootContainerView
 
 /**
- * Main TrueSheet host view.
- * Manages the sheet dialog and container, and dispatches events to JavaScript.
+ * Main TrueSheet host view that manages the sheet and dispatches events to JavaScript.
+ * This view is hidden (GONE) and delegates all rendering to TrueSheetViewController
+ * using a CoordinatorLayout approach (no separate dialog window).
  */
 @SuppressLint("ViewConstructor")
 class TrueSheetView(private val reactContext: ThemedReactContext) :
   ReactViewGroup(reactContext),
   LifecycleEventListener,
   TrueSheetViewControllerDelegate,
-  TrueSheetContainerViewDelegate {
+  TrueSheetContainerViewDelegate,
+  RNScreensEventObserverDelegate {
 
-  /**
-   * The TrueSheetViewController instance that acts as both root view and controller
-   */
-  private val viewController: TrueSheetViewController = TrueSheetViewController(reactContext)
-
-  /**
-   * Gets the container view (first child of view controller)
-   */
-  private val containerView: TrueSheetContainerView?
-    get() = viewController.getChildAt(0) as? TrueSheetContainerView
+  // ==================== Properties ====================
 
-  var eventDispatcher: EventDispatcher? = null
+  internal val viewController: TrueSheetViewController = TrueSheetViewController(reactContext)
+  override var eventDispatcher: EventDispatcher? = null
 
+  // Initial present configuration (set by ViewManager before mount)
   var initialDetentIndex: Int = -1
   var initialDetentAnimated: Boolean = true
+  private var didInitiallyPresent: Boolean = false
 
-  /**
-   * Tracks if initial presentation has been handled
-   */
-  private var hasHandledInitialPresentation = false
+  private var lastContainerWidth: Int = 0
+  private var lastContainerHeight: Int = 0
+
+  var stateWrapper: StateWrapper? = null
+    set(value) {
+      field = value
+
+      // On first state wrapper assignment, immediately update state with screen dimensions.
+      // This ensures Yoga has initial width/height for content layout before presenting.
+      if (value != null && lastContainerWidth == 0 && lastContainerHeight == 0) {
+        updateState(viewController.screenWidth, viewController.screenHeight)
+      }
+    }
+
+  // Debounce flag to coalesce rapid layout changes into a single sheet update
+  private var isSheetUpdatePending: Boolean = false
+
+  // Root container for the coordinator layout (activity or Modal dialog content view)
+  internal var rootContainerView: ViewGroup? = null
+
+  // Screen event observer for react-native-screens integration
+  internal var screensEventObserver: RNScreensEventObserver? = null
+
+  // ==================== Initialization ====================
 
   init {
     reactContext.addLifecycleEventListener(this)
-
-    // Set delegates
     viewController.delegate = this
 
-    // Hide the host view from layout and touch handling
-    // The actual content is shown in a dialog window
+    // Hide the host view - actual content is rendered in the dialog window
     visibility = GONE
   }
 
-  override fun dispatchProvideStructure(structure: ViewStructure) {
-    super.dispatchProvideStructure(structure)
-  }
+  // ==================== ReactViewGroup Overrides ====================
 
   override fun onLayout(
     changed: Boolean,
@@ -76,317 +88,643 @@ class TrueSheetView(private val reactContext: ThemedReactContext) :
     right: Int,
     bottom: Int
   ) {
-    // Do nothing as we are laid out by UIManager
+    // No-op: layout is managed by React Native's UIManager
   }
 
   override fun setId(id: Int) {
     super.setId(id)
-
     viewController.id = id
     TrueSheetModule.registerView(this, id)
   }
 
+  // ==================== View Hierarchy Management ====================
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-  }
-
-  override fun onDetachedFromWindow() {
-    super.onDetachedFromWindow()
-    onDropInstance()
-
-    TrueSheetModule.unregisterView(id)
+    presentInitialIfNeeded()
   }
 
   /**
-   * showOrUpdate will display the Dialog. It is called by the manager once all properties are set
-   * because we need to know all of them before creating the Dialog. It is also smart during updates
-   * if the changed properties can be applied directly to the Dialog or require the recreation of a
-   * new Dialog.
+   * JS holds initialDetentIndex back one commit so effect-driven content (e.g. a
+   * navigation footer set via setOptions) commits together with it. The prop then
+   * arrives after attach, so the ViewManager triggers this on prop update too.
+   * Posted so sibling mounts from the current transaction land before measuring.
    */
-  fun showOrUpdate() {
-    // Only handle initial presentation once on mount
-    if (!hasHandledInitialPresentation && initialDetentIndex >= 0) {
-      hasHandledInitialPresentation = true
-
-      // Create dialog if not created yet
-      if (!viewController.isPresented) {
-        viewController.createDialog()
+  fun presentInitialIfNeeded() {
+    if (initialDetentIndex < 0 || didInitiallyPresent || !isAttachedToWindow) return
+
+    didInitiallyPresent = true
+    post {
+      // The view may have been dropped (flag reset) or detached before this
+      // ran — roll back so a later attach retries instead of presenting a
+      // sheet with no live host.
+      if (!didInitiallyPresent) return@post
+      if (!isAttachedToWindow) {
+        didInitiallyPresent = false
+        return@post
       }
-
-      post {
+      if (!viewController.isPresented) {
         present(initialDetentIndex, initialDetentAnimated) { }
       }
-    } else if (viewController.isPresented) {
-      viewController.setupSheetDetents()
-      viewController.setStateForDetentIndex(viewController.currentDetentIndex)
-      viewController.positionFooter()
     }
   }
 
-  // ==================== View Management ====================
-
   override fun addView(child: View?, index: Int) {
-    // Add the child to our ViewController
-    // This is the TrueSheetContainerView
+    if (child is TrueSheetContainerView) {
+      viewController.removeSheetSnapshot()
+    }
+
     viewController.addView(child, index)
 
-    // Create dialog and dispatch mount event when TrueSheetContainerView is added
     if (child is TrueSheetContainerView) {
-      // Set up container delegate to listen for content size changes
       child.delegate = this
-
-      // Get initial content height from container
-      val contentHeight = child.contentHeight
-      if (contentHeight > 0) {
-        viewController.contentHeight = contentHeight
-      }
-
-      // Create the dialog now that the container is mounted
-      viewController.createDialog()
-
       val surfaceId = UIManagerHelper.getSurfaceId(this)
-      eventDispatcher?.dispatchEvent(
-        MountEvent(surfaceId, id)
-      )
+      eventDispatcher?.dispatchEvent(MountEvent(surfaceId, id))
     }
   }
 
   override fun getChildCount(): Int = viewController.childCount
-  override fun getChildAt(index: Int): View? = viewController.getChildAt(index)
 
-  override fun removeView(child: View?) {
-    if (child != null) {
-      // Clean up container delegate
-      if (child is TrueSheetContainerView) {
-        child.delegate = null
-      }
-
-      viewController.removeView(child)
-    }
-  }
+  override fun getChildAt(index: Int): View? = viewController.getChildAt(index)
 
   override fun removeViewAt(index: Int) {
     val child = getChildAt(index)
+    if (child is TrueSheetContainerView) {
+      child.delegate = null
+
+      // Skip if already dismissing - snapshot preserves visuals during dismiss
+      if (!viewController.isBeingDismissed) {
+        viewController.createSheetSnapshot()
+        if (viewController.isPresented) {
+          dismiss(true) {}
+        }
+      }
+    }
     viewController.removeView(child)
   }
 
-  override fun addChildrenForAccessibility(outChildren: ArrayList<View>) {
-    // Explicitly override this to prevent accessibility events being passed down to children
-    // Those will be handled by the mHostView which lives in the dialog
-  }
-
-  // Explicitly override this to prevent accessibility events being passed down to children
-  // Those will be handled by the mHostView which lives in the dialog
+  // Accessibility: delegate to dialog's host view since this view is hidden
+  override fun addChildrenForAccessibility(outChildren: ArrayList<View>) {}
   override fun dispatchPopulateAccessibilityEvent(event: AccessibilityEvent): Boolean = false
 
-  fun onDropInstance() {
-    reactContext.removeLifecycleEventListener(this)
-    TrueSheetModule.unregisterView(id)
-
-    if (viewController.isPresented) {
-      viewController.dismiss()
-    }
-    viewController.delegate = null
-  }
+  // ==================== Lifecycle ====================
 
   override fun onHostResume() {
-    showOrUpdate()
+    viewController.reapplyHiddenState()
+    finalizeUpdates()
   }
 
-  override fun onHostPause() {
-  }
+  override fun onHostPause() {}
 
   override fun onHostDestroy() {
     onDropInstance()
   }
 
-  // ==================== TrueSheetViewControllerDelegate Implementation ====================
+  fun onDropInstance() {
+    reactContext.removeLifecycleEventListener(this)
 
-  override fun viewControllerWillPresent(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      WillPresentEvent(surfaceId, id, index, position)
-    )
-  }
+    TrueSheetModule.unregisterView(id)
+    TrueSheetStackManager.removeSheet(this)
 
-  override fun viewControllerDidPresent(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DidPresentEvent(surfaceId, id, index, position)
-    )
+    cleanupScreenEventObserver()
+    didInitiallyPresent = false
 
-    // Set our touch event dispatcher on the view controller
-    viewController.eventDispatcher = eventDispatcher
-  }
+    viewController.dismissPromise = { viewController.delegate = null }
 
-  override fun viewControllerWillDismiss() {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      WillDismissEvent(surfaceId, id)
-    )
-
-    // Clear our touch event dispatcher on the view controller
-    viewController.eventDispatcher = null
+    if (viewController.isPresented && !viewController.isBeingDismissed) {
+      viewController.dismiss(animated = false)
+    }
   }
 
-  override fun viewControllerDidDismiss() {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DidDismissEvent(surfaceId, id)
-    )
-  }
+  /**
+   * Called by the ViewManager after all properties are set.
+   * Reconfigures the sheet if it's currently presented.
+   */
+  fun finalizeUpdates() {
+    setupScrollable()
 
-  override fun viewControllerDidChangeDetent(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DetentChangeEvent(surfaceId, id, index, position)
-    )
+    if (viewController.isPresented) {
+      viewController.sheetView?.setupBackground()
+      viewController.sheetView?.setupGrabber()
+      viewController.sheetView?.updateGravity()
+      viewController.updateBehaviorMaxWidth()
+      updateSheetIfNeeded()
+    }
   }
 
-  override fun viewControllerDidDragBegin(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DragBeginEvent(surfaceId, id, index, position)
-    )
-  }
+  // ==================== Property Setters ====================
 
-  override fun viewControllerDidDragChange(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DragChangeEvent(surfaceId, id, index, position)
-    )
+  fun setMaxContentHeight(height: Int?) {
+    if (viewController.maxContentHeight == height) return
+    viewController.maxContentHeight = height
   }
 
-  override fun viewControllerDidDragEnd(index: Int, position: Float) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      DragEndEvent(surfaceId, id, index, position)
-    )
+  fun setMaxContentWidth(width: Int?) {
+    if (viewController.maxContentWidth == width) return
+    viewController.maxContentWidth = width
   }
 
-  override fun viewControllerDidChangePosition(index: Int, position: Float, transitioning: Boolean) {
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      PositionChangeEvent(surfaceId, id, index, position, transitioning)
-    )
+  fun setAnchor(anchor: String?) {
+    val value = TrueSheetAnchor.fromString(anchor)
+    if (viewController.anchor == value) return
+    viewController.anchor = value
   }
 
-  // ==================== Property Setters (forward to controller) ====================
-
-  fun setMaxHeight(height: Int) {
-    if (viewController.maxSheetHeight == height) return
-    viewController.maxSheetHeight = height
+  fun setAnchorOffset(offset: Int) {
+    if (viewController.anchorOffset == offset) return
+    viewController.anchorOffset = offset
   }
 
   fun setDimmed(dimmed: Boolean) {
     if (viewController.dimmed == dimmed) return
     viewController.dimmed = dimmed
     if (viewController.isPresented) {
-      viewController.setupDimmedBackground(viewController.currentDetentIndex)
+      viewController.setupDimmedBackground()
+      viewController.updateDimAmount()
+      TrueSheetStackManager.updateBackgroundAccessibility()
     }
   }
 
-  fun setDimmedIndex(index: Int) {
-    if (viewController.dimmedIndex == index) return
-    viewController.dimmedIndex = index
+  fun setDimmedDetentIndex(index: Int) {
+    if (viewController.dimmedDetentIndex == index) return
+    viewController.dimmedDetentIndex = index
     if (viewController.isPresented) {
-      viewController.setupDimmedBackground(viewController.currentDetentIndex)
+      viewController.setupDimmedBackground()
+      viewController.updateDimAmount()
+      TrueSheetStackManager.updateBackgroundAccessibility()
     }
   }
 
   fun setCornerRadius(radius: Float) {
-    if (viewController.cornerRadius == radius) return
-    viewController.cornerRadius = radius
-    viewController.setupBackground()
+    if (viewController.sheetCornerRadius == radius) return
+    viewController.sheetCornerRadius = radius
   }
 
-  fun setSheetBackgroundColor(color: Int) {
+  fun setSheetBackgroundColor(color: Int?) {
     if (viewController.sheetBackgroundColor == color) return
     viewController.sheetBackgroundColor = color
-    viewController.setupBackground()
-  }
-
-  fun setSoftInputMode(mode: Int) {
-    viewController.setSoftInputMode(mode)
   }
 
   fun setDismissible(dismissible: Boolean) {
     viewController.dismissible = dismissible
   }
 
-  fun setGrabber(grabber: Boolean) {}
+  fun setDraggable(draggable: Boolean) {
+    viewController.draggable = draggable
+  }
+
+  fun setGrabber(grabber: Boolean) {
+    viewController.grabber = grabber
+  }
+
+  fun setGrabberOptions(options: GrabberOptions?) {
+    viewController.grabberOptions = options
+  }
+
+  fun setAccessibilityOptions(options: AccessibilityOptions?) {
+    viewController.accessibilityOptions = options
+  }
+
+  fun setSheetElevation(elevation: Float) {
+    viewController.sheetElevation = elevation
+  }
 
   fun setDetents(newDetents: MutableList<Double>) {
     viewController.detents = newDetents
+    setupScrollable()
   }
 
-  fun setBlurTint(tint: String?) {}
+  fun setInsetAdjustment(insetAdjustment: String) {
+    viewController.insetAdjustment = TrueSheetInsetAdjustment.fromString(insetAdjustment)
+    setupScrollable()
+  }
+
+  fun setScrollableOptions(options: ScrollableOptions?) {
+    viewController.scrollableOptions = options
+    setupScrollable()
+  }
+
+  fun setScrollableHandle(handle: Int) {
+    if (viewController.scrollableHandle == handle) return
+    viewController.scrollableHandle = handle
+    setupScrollable()
+  }
+
+  fun setAbsoluteHeader(absolute: Boolean) {
+    viewController.absoluteHeader = absolute
+  }
+
+  fun setAbsoluteFooter(absolute: Boolean) {
+    viewController.absoluteFooter = absolute
+  }
+
+  fun setFooterKeyboardOffset(offset: Float) {
+    viewController.footerKeyboardOffset = offset.dpToPx().toInt()
+    viewController.positionFooter()
+  }
+
+  private fun setupScrollable() {
+    viewController.containerView?.let {
+      it.scrollableOptions = viewController.scrollableOptions
+      it.scrollableHandle = viewController.scrollableHandle
+      it.scrollableBottomInset = viewController.contentBottomInset
+      it.footerBottomInset = viewController.contentBottomInset
+      it.absoluteFooter = viewController.absoluteFooter
+      it.setupScrollable()
+    }
+
+    // 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 (viewController.insetAdjustment == TrueSheetInsetAdjustment.AUTOMATIC) {
+      TrueSheetStateUpdater.setBottomSafeArea(viewController.contentBottomInset.toFloat().pxToDp())
+    }
+  }
 
-  fun setEdgeToEdgeFullScreen(edgeToEdgeFullScreen: Boolean) {
-    viewController.edgeToEdgeFullScreen = edgeToEdgeFullScreen
+  // ==================== Screen Event Observer ====================
+
+  private fun setupScreenEventObserver() {
+    screensEventObserver = RNScreensEventObserver().apply {
+      delegate = this@TrueSheetView
+
+      // For stacked sheets on the same screen, inherit parent's presenter screen tag.
+      // If parent was hidden by screen navigation, this sheet is on a different screen.
+      val parentScreenTag = viewController.parentSheetView?.screensEventObserver?.presenterScreenTag ?: 0
+      val parentHiddenByScreen = viewController.parentSheetView?.viewController?.wasHiddenByScreen == true
+      if (parentScreenTag != 0 && !parentHiddenByScreen) {
+        presenterScreenTag = parentScreenTag
+      } else {
+        capturePresenterScreenFromView(this@TrueSheetView)
+      }
+      startObserving(eventDispatcher)
+    }
   }
 
+  private fun cleanupScreenEventObserver() {
+    screensEventObserver?.stopObserving()
+    screensEventObserver = null
+  }
+
+  // ==================== State Management ====================
+
   /**
-   * Presents the sheet at the given detent index.
-   *
-   * @param detentIndex The detent index to present at
-   * @param animated Whether to animate the presentation
-   * @param promiseCallback Callback invoked when presentation completes
+   * Updates the Fabric state with container dimensions for Yoga layout.
+   * Converts pixel values to density-independent pixels (dp).
    */
+  fun updateState(width: Int, height: Int) {
+    if (width == lastContainerWidth && height == lastContainerHeight) return
+
+    lastContainerWidth = width
+    lastContainerHeight = height
+
+    stateWrapper?.let { TrueSheetStateUpdater.updateContainerSize(it, width, height) }
+  }
+
+  // ==================== Sheet Actions ====================
+
   @UiThread
   fun present(detentIndex: Int, animated: Boolean = true, promiseCallback: () -> Unit) {
+    if (viewController.isPresented) {
+      RNLog.w(reactContext, "TrueSheet: sheet is already presented. Use resize() to change detent.")
+      promiseCallback()
+      return
+    }
+
+    viewController.createSheet()
+    setupScrollable()
+
+    // Dismiss keyboard if focused view is within a sheet or if target detent will be dimmed
+    val parentSheet = TrueSheetStackManager.getTopmostSheet()
+    val isFocusedViewWithinSheet = parentSheet?.viewController?.isFocusedViewWithinSheet() == true
+    val shouldDismissKeyboard = isFocusedViewWithinSheet || viewController.isDimmedAtDetentIndex(detentIndex)
+    if (KeyboardUtils.isKeyboardVisible(reactContext) && shouldDismissKeyboard) {
+      viewController.saveFocusedView()
+      KeyboardUtils.dismiss(this) {
+        post { present(detentIndex, animated, promiseCallback) }
+      }
+      return
+    }
+
+    // Attach coordinator to the root container
+    rootContainerView = findRootContainerView()
+    viewController.coordinatorLayout?.let { rootContainerView?.addView(it) }
+
+    // Register with observer to track sheet stack hierarchy
+    viewController.parentSheetView = TrueSheetStackManager.registerSheet(this)
+
     viewController.presentPromise = promiseCallback
     viewController.present(detentIndex, animated)
   }
 
-  /**
-   * Dismisses the sheet.
-   *
-   * @param promiseCallback Callback invoked when dismissal completes
-   */
   @UiThread
-  fun dismiss(promiseCallback: () -> Unit) {
+  fun handleBackPress() {
+    viewController.handleBackPress()
+  }
+
+  @UiThread
+  fun dismiss(animated: Boolean = true, promiseCallback: () -> Unit) {
+    if (viewController.isBeingDismissed || !viewController.isPresented) {
+      RNLog.w(reactContext, "TrueSheet: sheet is already dismissed. No need to dismiss it again.")
+      promiseCallback()
+      return
+    }
+
+    // Dismiss all sheets above first
+    dismissStack(animated) {}
+
+    // Then dismiss itself
     viewController.dismissPromise = promiseCallback
-    viewController.dismiss()
+    viewController.dismiss(animated)
   }
 
-  override fun viewControllerDidChangeSize(width: Int, height: Int) {
-    // Dispatch size change event to JS
-    val surfaceId = UIManagerHelper.getSurfaceId(this)
-    eventDispatcher?.dispatchEvent(
-      SizeChangeEvent(surfaceId, id, width, height)
+  @UiThread
+  fun dismissStack(animated: Boolean = true, promiseCallback: () -> Unit) {
+    if (viewController.isBeingDismissed || !viewController.isPresented) {
+      RNLog.w(reactContext, "TrueSheet: sheet is already dismissed. No need to dismiss it again.")
+      promiseCallback()
+      return
+    }
+
+    val sheetsAbove = TrueSheetStackManager.getSheetsAbove(this)
+    // Create snapshot only for topmost sheet (first in reversed list)
+    sheetsAbove.firstOrNull()?.viewController?.createSheetSnapshot()
+
+    for (sheet in sheetsAbove) {
+      sheet.viewController.dismiss(animated)
+    }
+
+    promiseCallback()
+  }
+
+  @UiThread
+  fun resize(detentIndex: Int, promiseCallback: () -> Unit) {
+    if (!viewController.isPresented) {
+      RNLog.w(reactContext, "TrueSheet: Cannot resize. Sheet is not presented.")
+      promiseCallback()
+      return
+    }
+
+    viewController.resizePromise = promiseCallback
+    viewController.resize(detentIndex)
+  }
+
+  /**
+   * Debounced sheet update to handle rapid content/header size changes.
+   * Uses post() to ensure all layout passes complete before reconfiguring.
+   */
+  fun updateSheetIfNeeded() {
+    if (!viewController.isPresented || isSheetUpdatePending) return
+
+    isSheetUpdatePending = true
+    viewController.post {
+      isSheetUpdatePending = false
+      if (viewController.containerView == null) return@post
+
+      viewController.setupSheetDetentsForSizeChange()
+      // While settling, onSlide drives the parent translation in realtime —
+      // an animated update here would race it frame-by-frame, staggering the
+      // emitted position. Keyboard-driven resizes leave the parent alone (like
+      // iOS); keyboardDidHide resizes again once the detents are keyboard-free.
+      if (!viewController.isSettling && !viewController.isKeyboardActive) {
+        TrueSheetStackManager.updateParentTranslation(this)
+      }
+    }
+  }
+
+  // ==================== Sheet Stack Translation ====================
+
+  /**
+   * Updates this sheet's translation and disables dragging when a child sheet is presented.
+   * Parent sheets slide down to create a stacked appearance.
+   * Propagates additional translation to parent so the entire stack stays visually consistent.
+   */
+  fun updateTranslationForChild(childSheetTop: Int) {
+    if (!viewController.isSheetVisible || viewController.isExpanded) return
+
+    viewController.sheetView?.behavior?.isDraggable = false
+
+    val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
+    val newTranslation = maxOf(0, childSheetTop - mySheetTop)
+    val additionalTranslation = newTranslation - viewController.currentTranslationY
+
+    viewController.translateSheet(newTranslation)
+
+    // Propagate any additional translation up the stack
+    if (additionalTranslation > 0) {
+      TrueSheetStackManager.getParentSheet(this)?.addTranslation(additionalTranslation)
+    }
+  }
+
+  /**
+   * Realtime counterpart of updateTranslationForChild, driven by the child's
+   * onSlide frames so stacked sheets move in lockstep instead of on
+   * independently-timed animations.
+   */
+  fun syncTranslationForChild(childSheetTop: Int, childMinSheetTop: Int) {
+    if (!viewController.isSheetVisible || viewController.isExpanded) return
+
+    val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
+    val targetTranslation = maxOf(0, childMinSheetTop - mySheetTop)
+    val actualTranslation = maxOf(0, childSheetTop - mySheetTop)
+    val currentTranslation = viewController.currentTranslationY
+
+    // Ride the child's actual position, but only between the current
+    // translation and the settled target — tracks the child frame-by-frame
+    // when the alignment changes (auto detent resize) while staying put when
+    // the child moves between detents above its minimum. Returning early on
+    // no-ops avoids cancelling an in-flight realign animation.
+    val newTranslation = actualTranslation.coerceIn(
+      minOf(currentTranslation, targetTranslation),
+      maxOf(currentTranslation, targetTranslation)
     )
+    if (newTranslation == currentTranslation) return
+
+    viewController.translateSheet(newTranslation, animated = false)
+
+    val additionalTranslation = newTranslation - currentTranslation
+    if (additionalTranslation > 0) {
+      TrueSheetStackManager.getParentSheet(this)?.addTranslation(additionalTranslation, animated = false)
+    }
   }
 
-  // ==================== TrueSheetContainerViewDelegate Implementation ====================
+  /**
+   * Recursively adds translation to this sheet and all parent sheets.
+   */
+  private fun addTranslation(amount: Int, animated: Boolean = true) {
+    if (viewController.isExpanded) return
 
-  override fun containerViewContentDidChangeSize(width: Int, height: Int) {
-    // Clamp content height to container height to prevent unbounded growth with scrollable content
-    val containerHeight = viewController.maxScreenHeight
-    val contentHeight = if (containerHeight > 0) minOf(height, containerHeight) else height
+    viewController.translateSheet(viewController.currentTranslationY + amount, animated)
+    TrueSheetStackManager.getParentSheet(this)?.addTranslation(amount, animated)
+  }
+
+  /**
+   * Resets this sheet's translation and restores dragging when it becomes topmost.
+   * Parent recalculates its translation based on this sheet's position.
+   */
+  fun resetTranslation(onTranslateEnd: (() -> Unit)? = null) {
+    viewController.sheetView?.behavior?.isDraggable = viewController.draggable
+    viewController.translateSheet(0, onEnd = onTranslateEnd)
+
+    // Parent should recalculate its translation based on this sheet's position
+    val mySheetTop = viewController.detentCalculator.getSheetTopForDetentIndex(viewController.currentDetentIndex)
+    TrueSheetStackManager.getParentSheet(this)?.updateTranslationForChild(mySheetTop)
+  }
 
-    viewController.contentHeight = contentHeight
+  // ==================== TrueSheetViewControllerDelegate ====================
 
-    // Update detents if sheet is already presented
-    if (viewController.isPresented) {
-      // Reconfigure sheet detents with new content height
-      viewController.setupSheetDetents()
+  override fun viewControllerWillPresent(index: Int, position: Float, detent: Float) {
+    // Update parent sheet translation now that content is measured
+    TrueSheetStackManager.updateParentTranslation(this)
 
-      // Use post to ensure layout is complete before positioning footer
-      viewController.post {
-        viewController.positionFooter()
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(WillPresentEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerDidPresent(index: Int, position: Float, detent: Float) {
+    setupScreenEventObserver()
+
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DidPresentEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerWillDismiss() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(WillDismissEvent(surfaceId, id))
+  }
+
+  override fun viewControllerDidAttemptDismiss() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DismissAttemptEvent(surfaceId, id))
+  }
+
+  override fun viewControllerDidDismiss(parent: TrueSheetView?) {
+    // Detach coordinator from the root container view
+    viewController.coordinatorLayout?.let { rootContainerView?.removeView(it) }
+    rootContainerView = null
+
+    cleanupScreenEventObserver()
+
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DidDismissEvent(surfaceId, id))
+
+    TrueSheetStackManager.unregisterSheet(this)
+
+    parent?.resetTranslation {
+      val parentController = parent.viewController
+      if (parentController.isPresented && !parentController.isBeingDismissed) {
+        parent.viewControllerDidFocus()
       }
     }
   }
 
+  override fun viewControllerDidChangeDetent(index: Int, position: Float, detent: Float) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DetentChangeEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerDidDragBegin(index: Int, position: Float, detent: Float) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DragBeginEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerDidDragChange(index: Int, position: Float, detent: Float) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DragChangeEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerDidDragEnd(index: Int, position: Float, detent: Float) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(DragEndEvent(surfaceId, id, index, position, detent))
+  }
+
+  override fun viewControllerDidChangePosition(index: Float, position: Float, detent: Float, realtime: Boolean) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(PositionChangeEvent(surfaceId, id, index, position, detent, realtime))
+  }
+
+  override fun viewControllerDidChangeSize(width: Int, height: Int) {
+    updateState(width, height)
+  }
+
+  override fun viewControllerWillFocus() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(WillFocusEvent(surfaceId, id))
+  }
+
+  override fun viewControllerDidFocus() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(FocusEvent(surfaceId, id))
+  }
+
+  override fun viewControllerWillBlur() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(WillBlurEvent(surfaceId, id))
+  }
+
+  override fun viewControllerDidBlur() {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(BlurEvent(surfaceId, id))
+  }
+
+  override fun viewControllerDidChangeVisibility(visible: Boolean) {
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    eventDispatcher?.dispatchEvent(VisibilityChangeEvent(surfaceId, id, visible))
+  }
+
+  // ==================== TrueSheetContainerViewDelegate ====================
+
+  override fun containerViewContentDidChangeSize(width: Int, height: Int) {
+    updateSheetIfNeeded()
+  }
+
+  override fun containerViewContentDidScroll() {
+    viewController.commitKeyboardDetent()
+  }
+
+  // When the ScrollView changes (e.g. conditional remount), re-detect the new ScrollView
+  // and request layout so BottomSheetBehavior re-discovers the nested scrolling child.
+  override fun containerViewScrollViewDidChange() {
+    setupScrollable()
+    viewController.sheetView?.requestLayout()
+  }
+
+  override fun containerViewHeaderDidChangeSize(width: Int, height: Int) {
+    updateSheetIfNeeded()
+  }
+
   override fun containerViewFooterDidChangeSize(width: Int, height: Int) {
-    // Reposition footer when its size changes
-    if (viewController.isPresented) {
-      viewController.positionFooter()
+    // Footer height affects peek detents
+    updateSheetIfNeeded()
+    viewController.positionFooter()
+  }
+
+  override fun containerViewPeekDidChangeSize(width: Int, height: Int) {
+    // Peek content height affects peek detents
+    updateSheetIfNeeded()
+  }
+
+  // ==================== RNScreensEventObserverDelegate ====================
+
+  override fun presenterScreenWillDisappear() {
+    if (viewController.isPresented && viewController.isSheetVisible) {
+      KeyboardUtils.dismiss(this) {}
+      viewController.post { viewController.hideForScreen() }
     }
   }
 
-  companion object {
-    const val TAG_NAME = "TrueSheet"
+  override fun presenterScreenWillAppear() {
+    if (viewController.isPresented && viewController.wasHiddenByScreen) {
+      viewController.wasHiddenByScreen = false
+      viewController.showAfterScreen()
+    }
   }
+
+  // ==================== Private Helpers ====================
+
+  /**
+   * Find the root container view for presenting the sheet.
+   * This traverses up the view hierarchy to find the content view (android.R.id.content)
+   * of whichever window this view is in - whether that's the activity's window or a
+   * Modal's dialog window.
+   */
+  override fun findRootContainerView(): ViewGroup? = findRootContainerView(reactContext)
 }