@lodev09/react-native-true-sheet 4.0.0-beta.2 → 4.0.0-beta.20

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

@@ -0,0 +1,137 @@
+package com.lodev09.truesheet.core
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.TouchTargetHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.lodev09.truesheet.utils.TouchEventDeduper
+
+interface TrueSheetOverlayRootViewDelegate {
+  val eventDispatcher: EventDispatcher?
+  fun overlayRootViewDidChangeSize(width: Int, height: Int)
+}
+
+/**
+ * Window-level view hosting an overlay's children, attached to the activity's
+ * content view above the sheet coordinators.
+ *
+ * Implements RootView to dispatch touches to JS. Touches that miss every child
+ * fall through to the views beneath.
+ */
+@SuppressLint("ViewConstructor")
+class TrueSheetOverlayRootView(private val reactContext: ThemedReactContext) :
+  FrameLayout(reactContext),
+  RootView {
+
+  var delegate: TrueSheetOverlayRootViewDelegate? = null
+
+  private val eventDispatcher: EventDispatcher?
+    get() = delegate?.eventDispatcher
+
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private val jsPointerDispatcher = JSPointerDispatcher(this)
+  private val touchDeduper = TouchEventDeduper()
+
+  // Whether the current touch stream landed on a child
+  private var isHandlingStream = false
+
+  init {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+
+    // Draws and receives touches above the sheet coordinators regardless of add order
+    translationZ = OVERLAY_Z
+  }
+
+  // Children are positioned by Fabric — a FrameLayout pass would stretch them to match_parent
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int
+  ) {
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    delegate?.overlayRootViewDidChangeSize(w, h)
+  }
+
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_DOWN) {
+      // The path ends with this root, so a touch that misses every child resolves to it
+      val target = TouchTargetHelper
+        .findTargetPathAndCoordinatesForTouch(ev.x, ev.y, this, FloatArray(2))
+        .firstNotNullOfOrNull { it.getView() }
+      isHandlingStream = target != null && target !== this
+    }
+    if (!isHandlingStream) return false
+    return super.dispatchTouchEvent(ev)
+  }
+
+  // ==================== RootView Implementation ====================
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Mirrors ReactSurfaceView: keep receiving onInterceptTouchEvent so
+    // jsTouchDispatcher sees the gesture end, but forward the request up the tree.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, false)
+    }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, true) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
+      jsPointerDispatcher.onChildStartedNativeGesture(childView, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+
+  companion object {
+    private const val OVERLAY_Z = 1000f
+  }
+}

package/android/src/main/java/com/lodev09/truesheet/events/TrueSheetLifecycleEvents.kt

@@ -93,6 +93,21 @@ class DidDismissEvent(surfaceId: Int, viewId: Int) : Event<DidDismissEvent>(surf
   }
 }
 
+/**
+ * Fired when the user tries to dismiss a non-dismissible sheet
+ */
+class DismissAttemptEvent(surfaceId: Int, viewId: Int) : Event<DismissAttemptEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDismissAttempt"
+    const val REGISTRATION_NAME = "onDismissAttempt"
+  }
+}
+
 /**
  * Fired when the sheet visibility changes due to screen transitions
  */

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

@@ -3,6 +3,7 @@ package com.lodev09.truesheet.utils
 import android.content.Context
 import android.os.Build
 import android.view.View
+import android.view.WindowInsets
 import android.view.inputmethod.InputMethodManager
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsAnimationCompat
@@ -19,7 +20,7 @@ object KeyboardUtils {
     return isKeyboardVisible(rootView)
   }
 
-  private fun isKeyboardVisible(view: View): Boolean {
+  fun isKeyboardVisible(view: View): Boolean {
     val insets = ViewCompat.getRootWindowInsets(view) ?: return false
     return insets.isVisible(WindowInsetsCompat.Type.ime())
   }
@@ -36,10 +37,22 @@ object KeyboardUtils {
    * Dismisses the soft keyboard with an optional callback when the animation completes.
    */
   fun dismiss(view: View, onComplete: (() -> Unit)?) {
+    if (!isKeyboardVisible(view)) {
+      onComplete?.invoke()
+      return
+    }
+
     val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
     val focusedView = view.rootView.findFocus()
 
-    if (focusedView == null || !isKeyboardVisible(view)) {
+    // A keyboard can stay up with nothing focused, e.g. a blur that lands after focus was restored,
+    // so hide it through the window instead of treating it as already hidden.
+    if (focusedView == null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        view.windowInsetsController?.hide(WindowInsets.Type.ime())
+      } else {
+        imm?.hideSoftInputFromWindow(view.windowToken, 0)
+      }
       onComplete?.invoke()
       return
     }

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

@@ -104,18 +104,6 @@ object ScreenUtils {
    */
   fun getScreenHeight(reactContext: ReactContext): Int = reactContext.resources.displayMetrics.heightPixels
 
-  /**
-   * Get the location of a view in screen coordinates
-   *
-   * @param view The view to get screen location for
-   * @return IntArray with [x, y] coordinates in screen space
-   */
-  fun getScreenLocation(view: View): IntArray {
-    val location = IntArray(2)
-    view.getLocationOnScreen(location)
-    return location
-  }
-
   /**
    * Returns true if the device is a phone in portrait orientation.
    */

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

@@ -2,8 +2,10 @@ package com.lodev09.truesheet.utils
 
 import android.view.View
 import android.view.ViewGroup
+import android.view.ViewParent
 import android.widget.ScrollView
 import androidx.core.widget.NestedScrollView
+import com.facebook.react.uimanager.ThemedReactContext
 
 fun View.isDescendantOf(ancestor: View): Boolean {
   if (!isAttachedToWindow) return false
@@ -15,16 +17,26 @@ fun View.isDescendantOf(ancestor: View): Boolean {
   return false
 }
 
-fun ViewGroup.smoothScrollBy(dx: Int, dy: Int) {
-  when (this) {
-    is ScrollView -> smoothScrollBy(dx, dy)
-    is NestedScrollView -> smoothScrollBy(dx, dy)
-  }
-}
-
 fun ViewGroup.smoothScrollTo(x: Int, y: Int) {
   when (this) {
     is ScrollView -> smoothScrollTo(x, y)
     is NestedScrollView -> smoothScrollTo(x, y)
   }
 }
+
+/**
+ * The content view hosting this view — the activity's, or a Modal dialog's.
+ * Window-level views (sheet coordinators, overlays) attach here.
+ */
+fun View.findRootContainerView(reactContext: ThemedReactContext): ViewGroup? {
+  var current: ViewParent? = parent
+
+  while (current != null) {
+    if (current is ViewGroup && current.id == android.R.id.content) {
+      return current
+    }
+    current = current.parent
+  }
+
+  return reactContext.currentActivity?.findViewById(android.R.id.content)
+}

package/android/src/main/jni/TrueSheetSpec.h

@@ -5,6 +5,7 @@
 #include <jsi/jsi.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetViewComponentDescriptor.h>
 
 namespace facebook {

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h

@@ -11,14 +11,6 @@ namespace facebook::react {
 class TrueSheetContentViewComponentDescriptor final
     : public ConcreteComponentDescriptor<TrueSheetContentViewShadowNode> {
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
-
-  void adopt(ShadowNode &shadowNode) const override {
-    auto &concreteShadowNode =
-        static_cast<TrueSheetContentViewShadowNode &>(shadowNode);
-    concreteShadowNode.adjustLayoutWithState();
-
-    ConcreteComponentDescriptor::adopt(shadowNode);
-  }
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.cpp

@@ -1,6 +1,12 @@
 #include "TrueSheetContentViewShadowNode.h"
 
+#include <folly/ScopeGuard.h>
 #include <react/renderer/components/view/conversions.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+
+#include <limits>
 
 namespace facebook::react {
 
@@ -8,36 +14,110 @@ using namespace yoga;
 
 extern const char TrueSheetContentViewComponentName[] = "TrueSheetContentView";
 
-void TrueSheetContentViewShadowNode::adjustLayoutWithState() {
-  ensureUnsealed();
-
-  auto state = std::static_pointer_cast<
-      const TrueSheetContentViewShadowNode::ConcreteState>(getState());
-  auto stateData = state->getData();
-
-  auto &props = getConcreteProps();
-
-  // When a ScrollView is pinned under an auto detent, fill the container so
-  // descendant flex layouts (flex:1 wrappers, the ScrollView itself) resolve
-  // against a definite height and the viewport is bounded — natural layout is
-  // circular there since the sheet height derives from the ScrollView's content
-  // size instead (see ContentView's naturalHeight on each platform). For fixed
-  // detents, content lays out naturally like a regular view.
-  auto flexGrow = stateData.scrollableBounded
-      ? FloatOptional{1.0f}
-      : props.yogaStyle.flexGrow();
-  auto flexShrink = stateData.scrollableBounded
-      ? FloatOptional{1.0f}
-      : props.yogaStyle.flexShrink();
-
-  if (yogaNode_.style().flexGrow() != flexGrow ||
-      yogaNode_.style().flexShrink() != flexShrink) {
-    yoga::Style adjustedStyle = props.yogaStyle;
-    adjustedStyle.setFlexGrow(flexGrow);
-    adjustedStyle.setFlexShrink(flexShrink);
-    yogaNode_.setStyle(adjustedStyle);
-    yogaNode_.setDirty(true);
+// The measurement pass re-enters layout() on a clone — guard so it doesn't
+// measure again recursively.
+static thread_local bool gIsMeasuringNaturalHeight = false;
+
+TrueSheetContentViewShadowNode::TrueSheetContentViewShadowNode(
+  const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment),
+      measurement_(static_cast<const TrueSheetContentViewShadowNode &>(sourceShadowNode).measurement_),
+      measurementSourceChildren_(
+        static_cast<const TrueSheetContentViewShadowNode &>(sourceShadowNode).measurementSourceChildren_),
+      contentChanged_(static_cast<const TrueSheetContentViewShadowNode &>(sourceShadowNode).contentChanged_ ||
+                      fragment.props || fragment.children) {
+}
+
+void TrueSheetContentViewShadowNode::layout(LayoutContext layoutContext) {
+  // The sizing tree needs Yoga's result, not Fabric state updates or events.
+  if (gIsMeasuringNaturalHeight) {
+    return;
+  }
+  ConcreteViewShadowNode::layout(layoutContext);
+  updateNaturalHeightIfNeeded(layoutContext);
+}
+
+// Every descendant must be detached from React's runtime references before
+// Yoga clones it during measurement. Disabling transfer only on the root
+// still lets descendant clones replace React's live nodes. Reuse unchanged
+// measurement subtrees; Yoga owns copy-on-write when their layout changes.
+std::shared_ptr<ShadowNode> TrueSheetContentViewShadowNode::cloneForMeasurement(
+  const ShadowNode &node, const Children &previousSourceChildren, const Children &previousMeasurementChildren) {
+  auto children = std::make_shared<Children>();
+  children->reserve(node.getChildren().size());
+  for (size_t index = 0; index < node.getChildren().size(); index++) {
+    const auto &child = node.getChildren()[index];
+    if (index < previousSourceChildren.size() && ShadowNode::sameFamily(*child, *previousSourceChildren[index])) {
+      const auto &previousSource = previousSourceChildren[index];
+      const auto &previousMeasurement = previousMeasurementChildren[index];
+      children->push_back(child == previousSource ? previousMeasurement
+                                                  : cloneForMeasurement(*child, previousSource->getChildren(),
+                                                      previousMeasurement->getChildren()));
+    } else {
+      children->push_back(cloneForMeasurement(*child, {}, {}));
+    }
+  }
+
+  auto clone = node.getComponentDescriptor().cloneShadowNode(
+    node, {.children = children, .state = node.getState(), .runtimeShadowNodeReference = false});
+  if (auto content = dynamic_cast<TrueSheetContentViewShadowNode *>(clone.get())) {
+    content->measurement_.reset();
+    content->measurementSourceChildren_.reset();
+  }
+  return clone;
+}
+
+// The natural height is the height the content wants when unbounded — the
+// source for the auto detent. When the content's height derives from the
+// container, the committed layout doesn't reflect it — lay out a clone of the
+// subtree with an unconstrained height instead. Yoga respects the user's
+// styles: an explicit-height ScrollView keeps its height while a flexible one
+// expands to its content — no ScrollView discovery involved.
+void TrueSheetContentViewShadowNode::updateNaturalHeightIfNeeded(const LayoutContext &layoutContext) {
+  auto stateData = getStateData();
+  auto size = getLayoutMetrics().frame.size;
+
+  Float naturalHeight = size.height;
+  // Auto-height content can also be capped by a shrinking ScrollView. Only
+  // a fixed, non-flexible height can be taken from the viewport layout.
+  if (yogaNode_.isNodeFlexible() || !getConcreteProps().yogaStyle.dimension(Dimension::Height).isPoints()) {
+    auto constraints = LayoutConstraints{};
+    constraints.minimumSize = {size.width, 0};
+    constraints.maximumSize = {size.width, std::numeric_limits<Float>::infinity()};
+    constraints.layoutDirection = getLayoutMetrics().layoutDirection;
+
+    auto measurementContext = layoutContext;
+    measurementContext.affectedNodes = nullptr;
+    auto errata = YGConfigGetErrata(&yogaConfig_);
+
+    // Yoga's viewport-only clones carry no new props or children. Reuse the
+    // intrinsic height across those layouts instead of measuring each drag frame.
+    if (contentChanged_ || !measurement_ || !(measurement_->constraints == constraints) ||
+        !(measurement_->context == measurementContext) || measurement_->errata != errata) {
+      gIsMeasuringNaturalHeight = true;
+      auto restoreMeasurement = folly::makeGuard([] { gIsMeasuringNaturalHeight = false; });
+      auto measurementNode =
+        measurement_ ? cloneForMeasurement(*this, *measurementSourceChildren_, measurement_->root->getChildren())
+                     : cloneForMeasurement(*this, {}, {});
+      auto &measurement = static_cast<LayoutableShadowNode &>(*measurementNode);
+      measurement.layoutTree(measurementContext, constraints);
+      measurement_ = std::make_shared<const Measurement>(Measurement{.root = measurementNode,
+        .constraints = constraints,
+        .context = measurementContext,
+        .errata = errata,
+        .height = measurement.getLayoutMetrics().frame.size.height});
+    }
+    naturalHeight = measurement_->height;
+  } else {
+    measurement_.reset();
+  }
+  measurementSourceChildren_ = children_;
+  contentChanged_ = false;
+
+  if (stateData.naturalHeight != naturalHeight) {
+    stateData.naturalHeight = naturalHeight;
+    setStateData(std::move(stateData));
   }
 }
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.h

@@ -5,6 +5,8 @@
 #include <react/renderer/components/TrueSheetSpec/Props.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewState.h>
 #include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
 
 namespace facebook::react {
 
@@ -14,15 +16,36 @@ JSI_EXPORT extern const char TrueSheetContentViewComponentName[];
  * `ShadowNode` for <TrueSheetContentView> component.
  */
 class JSI_EXPORT TrueSheetContentViewShadowNode final
-    : public ConcreteViewShadowNode<
-          TrueSheetContentViewComponentName,
-          TrueSheetContentViewProps,
-          TrueSheetContentViewEventEmitter,
-          TrueSheetContentViewState> {
+    : public ConcreteViewShadowNode<TrueSheetContentViewComponentName, TrueSheetContentViewProps,
+        TrueSheetContentViewEventEmitter, TrueSheetContentViewState> {
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
  public:
-  void adjustLayoutWithState();
+  TrueSheetContentViewShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
+
+#pragma mark - LayoutableShadowNode
+
+  void layout(LayoutContext layoutContext) override;
+
+ private:
+  using Children = std::vector<std::shared_ptr<const ShadowNode>>;
+
+  struct Measurement {
+    std::shared_ptr<const ShadowNode> root;
+    LayoutConstraints constraints;
+    LayoutContext context;
+    YGErrata errata;
+    Float height;
+  };
+
+  std::shared_ptr<const Measurement> measurement_;
+  std::shared_ptr<const Children> measurementSourceChildren_;
+  bool contentChanged_{true};
+
+  static std::shared_ptr<ShadowNode> cloneForMeasurement(
+    const ShadowNode &node, const Children &previousSourceChildren, const Children &previousMeasurementChildren);
+
+  void updateNaturalHeightIfNeeded(const LayoutContext &layoutContext);
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewState.cpp

@@ -4,8 +4,8 @@ namespace facebook::react {
 
 #ifdef ANDROID
 folly::dynamic TrueSheetContentViewState::getDynamic() const {
-  return folly::dynamic::object("scrollableBounded", scrollableBounded);
+  return folly::dynamic::object("naturalHeight", naturalHeight);
 }
 #endif
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewState.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <react/renderer/graphics/Float.h>
+
 #ifdef ANDROID
 #include <folly/dynamic.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
@@ -10,21 +12,20 @@ namespace facebook::react {
 
 /*
  * State for <TrueSheetContentView> component.
- * Set from native when a ScrollView is pinned so the shadow node bounds the
- * content to the container via flexShrink (see TrueSheetContentViewShadowNode).
+ * `naturalHeight` is measured by the shadow node during layout — the height
+ * the content wants when unbounded (see TrueSheetContentViewShadowNode).
  */
 class TrueSheetContentViewState final {
  public:
   TrueSheetContentViewState() = default;
 
 #ifdef ANDROID
-  TrueSheetContentViewState(
-      TrueSheetContentViewState const &previousState,
-      folly::dynamic data)
-      : scrollableBounded(data["scrollableBounded"].getBool()) {}
+  TrueSheetContentViewState(TrueSheetContentViewState const &previousState, folly::dynamic data)
+      : naturalHeight(previousState.naturalHeight) {
+  }
 #endif
 
-  bool scrollableBounded{false};
+  Float naturalHeight{0};
 
 #ifdef ANDROID
   folly::dynamic getDynamic() const;
@@ -34,4 +35,4 @@ class TrueSheetContentViewState final {
 #endif
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h

@@ -8,17 +8,15 @@ namespace facebook::react {
 /*
  * Descriptor for <TrueSheetFooterView> component.
  */
-class TrueSheetFooterViewComponentDescriptor final
-    : public ConcreteComponentDescriptor<TrueSheetFooterViewShadowNode> {
+class TrueSheetFooterViewComponentDescriptor final : public ConcreteComponentDescriptor<TrueSheetFooterViewShadowNode> {
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
 
   void adopt(ShadowNode &shadowNode) const override {
-    auto &concreteShadowNode =
-        static_cast<TrueSheetFooterViewShadowNode &>(shadowNode);
+    auto &concreteShadowNode = static_cast<TrueSheetFooterViewShadowNode &>(shadowNode);
     concreteShadowNode.adjustLayoutWithState();
 
     ConcreteComponentDescriptor::adopt(shadowNode);
   }
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.cpp

@@ -13,8 +13,7 @@ extern const char TrueSheetFooterViewComponentName[] = "TrueSheetFooterView";
 void TrueSheetFooterViewShadowNode::adjustLayoutWithState() {
   ensureUnsealed();
 
-  auto state = std::static_pointer_cast<
-      const TrueSheetFooterViewShadowNode::ConcreteState>(getState());
+  auto state = std::static_pointer_cast<const TrueSheetFooterViewShadowNode::ConcreteState>(getState());
   auto stateData = state->getData();
 
   auto &props = getConcreteProps();
@@ -25,6 +24,13 @@ void TrueSheetFooterViewShadowNode::adjustLayoutWithState() {
   float bottomInset = stateData.bottomInset;
   if (!stateData.initialized && props.autoBottomInset) {
     bottomInset = TrueSheetInsets::bottomSafeArea();
+    if (bottomInset != stateData.bottomInset) {
+      // Record the seeded value so the mounted view reads exactly the inset
+      // baked into this layout — the global may change before mount.
+      auto seededData = stateData;
+      seededData.bottomInset = bottomInset;
+      setStateData(std::move(seededData));
+    }
   }
 
   // A footer pinned to the sheet's bottom edge owns the bottom safe-area
@@ -53,4 +59,4 @@ void TrueSheetFooterViewShadowNode::adjustLayoutWithState() {
   }
 }
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.h

@@ -14,15 +14,12 @@ JSI_EXPORT extern const char TrueSheetFooterViewComponentName[];
  * `ShadowNode` for <TrueSheetFooterView> component.
  */
 class JSI_EXPORT TrueSheetFooterViewShadowNode final
-    : public ConcreteViewShadowNode<
-          TrueSheetFooterViewComponentName,
-          TrueSheetFooterViewProps,
-          TrueSheetFooterViewEventEmitter,
-          TrueSheetFooterViewState> {
+    : public ConcreteViewShadowNode<TrueSheetFooterViewComponentName, TrueSheetFooterViewProps,
+        TrueSheetFooterViewEventEmitter, TrueSheetFooterViewState> {
   using ConcreteViewShadowNode::ConcreteViewShadowNode;
 
  public:
   void adjustLayoutWithState();
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewState.cpp

@@ -8,4 +8,4 @@ folly::dynamic TrueSheetFooterViewState::getDynamic() const {
 }
 #endif
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewState.h

@@ -18,11 +18,9 @@ class TrueSheetFooterViewState final {
   TrueSheetFooterViewState() = default;
 
 #ifdef ANDROID
-  TrueSheetFooterViewState(
-      TrueSheetFooterViewState const &previousState,
-      folly::dynamic data)
-      : bottomInset(static_cast<float>(data["bottomInset"].getDouble())),
-        initialized(true) {}
+  TrueSheetFooterViewState(TrueSheetFooterViewState const &previousState, folly::dynamic data)
+      : bottomInset(static_cast<float>(data["bottomInset"].getDouble())), initialized(true) {
+  }
 #endif
 
   float bottomInset{0};
@@ -38,4 +36,4 @@ class TrueSheetFooterViewState final {
 #endif
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetInsets.cpp

@@ -15,4 +15,4 @@ float TrueSheetInsets::bottomSafeArea() {
   return gBottomSafeArea.load(std::memory_order_relaxed);
 }
 
-} // namespace facebook::react
+}  // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetInsets.h

@@ -13,4 +13,4 @@ class TrueSheetInsets {
   static float bottomSafeArea();
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react