@lodev09/react-native-true-sheet 3.11.10 → 4.0.0-beta.1

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

@@ -218,13 +218,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   override var sheetBackgroundColor: Int? = null
   var insetAdjustment: TrueSheetInsetAdjustment = TrueSheetInsetAdjustment.AUTOMATIC
 
-  var scrollable: Boolean = false
-
   var scrollableOptions: ScrollableOptions? = null
     set(value) {
       field = value
       behavior?.scrollingExpandsSheet = value?.scrollingExpandsSheet ?: true
-      if (isPresented) sheetView?.let { updateScrollExpansionPadding(it.top) }
     }
 
   override var sheetCornerRadius: Float = DEFAULT_CORNER_RADIUS.dpToPx()
@@ -287,9 +284,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   override val headerHeight: Int
     get() = containerView?.headerHeight ?: cachedHeaderHeight
 
+  override var absoluteHeader: Boolean = false
+
   override val footerHeight: Int
     get() = containerView?.footerHeight ?: cachedFooterHeight
 
+  override var absoluteFooter: Boolean = false
+
   override val peekContentHeight: Int
     get() = containerView?.peekContentHeight ?: cachedPeekContentHeight
 
@@ -564,29 +565,20 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       else -> { }
     }
 
-    updateScrollExpansionPadding(sheetView.top)
     emitChangePositionDelegate(sheetView.top)
 
-    // On older APIs, use onSlide for footer positioning during keyboard transitions
-    val useLegacyKeyboardHandling = Build.VERSION.SDK_INT < Build.VERSION_CODES.R
-    if (!isKeyboardTransitioning || useLegacyKeyboardHandling) {
-      positionFooter(slideOffset)
-    }
+    // Position on every slide frame — during keyboard transitions the IME
+    // animation callbacks are sparser than the sheet's settle frames, and the
+    // footer rides the sheet between them, jittering against the keyboard.
+    // positionFooter derives from current state, so double-driving it with
+    // keyboardDidChangeHeight is harmless.
+    positionFooter(slideOffset)
 
     if (!isKeyboardTransitioning) {
       updateDimAmount(sheetView.top)
     }
   }
 
-  private fun updateScrollExpansionPadding(sheetTop: Int) {
-    if (!scrollable) {
-      containerView?.contentView?.updateScrollExpansionPadding(0)
-      return
-    }
-    val expandedOffset = behavior?.expandedOffset ?: return
-    containerView?.contentView?.updateScrollExpansionPadding(maxOf(0, sheetTop - expandedOffset))
-  }
-
   private fun handleStateSettled(sheetView: View, newState: Int) {
     if (interactionState is InteractionState.Reconfiguring) return
 
@@ -634,6 +626,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       }
     }
 
+    // Settled — resize the container to the settled detent (applies deferred shrinks)
+    updateStateDimensions()
+
     if (!isKeyboardTransitioning) {
       updateDimAmount(animated = true)
     }
@@ -743,6 +738,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
     pendingDetentIndex = detentIndex
+    updateStateDimensions(deferShrink = true)
     setupDimmedBackground()
     setStateForDetentIndex(detentIndex)
     resizePromise?.invoke()
@@ -893,7 +889,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       animate = isPresented
     )
 
-    updateStateDimensions(expandedOffset)
+    updateStateDimensions()
 
     if (isPresented && applyState) {
       // Prefer the pending target while a resize animation is in flight so a
@@ -923,6 +919,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   fun setupSheetDetentsForSizeChange() {
+    // Skip while dragging — the size change is driven by the drag itself (the
+    // container tracks the sheet's visible height), and reconfiguring resets
+    // behavior state, killing the gesture.
+    if (interactionState is InteractionState.Dragging) return
+
     setupSheetDetents()
     positionFooter()
   }
@@ -1007,15 +1008,28 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val footerView = containerView?.footerView ?: return
     val sheet = sheetView ?: return
 
+    val keyboardShift = if (currentKeyboardInset > 0) maxOf(0, currentKeyboardInset + footerKeyboardOffset) else 0
+
+    // A relative footer is laid out by Yoga (pinned to the container's bottom
+    // edge) and stays in the layout flow behind the keyboard — only an
+    // absolute footer floats above it
+    if (!absoluteFooter) {
+      footerView.translationY = 0f
+      return
+    }
+
     val footerHeight = footerView.height
     val sheetHeight = sheet.height
     val sheetTop = sheet.top
 
-    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) {
+    // Adjust during dismiss animation when slideOffset is negative. Skipped
+    // while the keyboard is open — the detents collapse to the expanded
+    // position, so any downward drag reads as a negative slideOffset and the
+    // adjustment would sink the footer behind the keyboard, snapping back up
+    // when the keyboard detents reset on release.
+    if (slideOffset != null && slideOffset < 0 && keyboardShift == 0) {
       footerY -= (footerHeight * slideOffset)
     }
 
@@ -1062,17 +1076,22 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       delegate = object : TrueSheetKeyboardObserverDelegate {
         override fun keyboardWillShow(height: Int) {
           if (!shouldHandleKeyboard()) return
+          // An absolute footer rises above the keyboard, so it drops the bottom
+          // inset padding — before detents are configured against its height
+          if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
           // If a resize is in flight, restore to its target — not the stale current
           detentIndexBeforeKeyboard = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
           pendingDetentIndex = -1
-          setupSheetDetents()
+          // Commit the target index first so the container grows before the sheet expands
           currentDetentIndex = detents.size - 1
-          setStateForDetentIndex(currentDetentIndex)
+          setupSheetDetents()
+          positionFooter()
           updateDimAmount(animated = true)
         }
 
         override fun keyboardWillHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
+          containerView?.footerView?.keyboardVisible = false
           val restoring = !isBeingDismissed && detentIndexBeforeKeyboard >= 0
 
           // Skip reconfigure during interactive keyboard dismiss (e.g. keyboardDismissMode="on-drag")
@@ -1085,6 +1104,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
             }
           }
 
+          // Same-frame reposition — the reconfigure above shrinks the container
+          // to the target detent, which yanks the bottom-pinned footer up until
+          // the next keyboard animation frame repositions it.
+          positionFooter()
           updateDimAmount(
             sheetTop = detentCalculator.getSheetTopForDetentIndex(currentDetentIndex),
             animated = true
@@ -1093,6 +1116,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun keyboardDidHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
+          containerView?.footerView?.keyboardVisible = false
           detentIndexBeforeKeyboard = -1
           isKeyboardDismissProgrammatic = false
           setupSheetDetents(applyState = false)
@@ -1114,9 +1138,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
           // Handle case where keyboard is already visible and focus moves into the sheet
           if (!shouldHandleKeyboard()) return
           if (detentIndexBeforeKeyboard < 0 && (keyboardObserver?.currentHeight ?: 0) > 0) {
+            if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
             detentIndexBeforeKeyboard = currentDetentIndex
             currentDetentIndex = detents.size - 1
             setupSheetDetents()
+            positionFooter()
           }
         }
       }
@@ -1185,6 +1211,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun handleDragChange(sheetView: View) {
     if (interactionState !is InteractionState.Dragging) return
 
+    updateStateDimensionsForDrag(sheetView.top)
+
     val position = getPositionDpForView(sheetView)
     val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
     delegate?.viewControllerDidDragChange(currentDetentIndex, position, detent)
@@ -1253,19 +1281,56 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     behavior.maxWidth = newMaxWidth
   }
 
-  private fun updateStateDimensions(expandedOffset: Int? = null) {
-    val offset = expandedOffset ?: (realScreenHeight - detentCalculator.getDetentHeight(detents.last()))
-    val topOffset = if (offset == 0) topInset else 0
-    val newHeight = realScreenHeight - offset - topOffset
+  /**
+   * Updates the Fabric state with the current/target detent size so Yoga sizes
+   * the container to the sheet's visible height.
+   *
+   * Unlike iOS, resize animations run over multiple frames (ViewDragHelper), so
+   * shrinking is deferred to settle ([deferShrink]) when a resize animation is
+   * about to run — growing applies immediately so content is laid out before
+   * the sheet reveals it.
+   */
+  private fun updateStateDimensions(deferShrink: Boolean = false) {
+    if (detents.isEmpty()) return
+
+    val targetIndex = (if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex)
+      .coerceIn(0, detents.size - 1)
+    val maxAvailableHeight = realScreenHeight - topInset
+    val newHeight = minOf(detentCalculator.getDetentHeight(detents[targetIndex]), maxAvailableHeight)
+    val newWidth = getStateWidth()
+
+    if (deferShrink && newWidth == lastStateWidth && newHeight < lastStateHeight) return
+
+    setStateDimensions(newWidth, newHeight)
+  }
+
+  /**
+   * Tracks the sheet's visible height during drag (and the post-release settle
+   * animation) so the container resizes with the finger, like iOS. Clamped to the
+   * smallest detent — dragging below it slides the sheet out without resizing.
+   */
+  private fun updateStateDimensionsForDrag(sheetTop: Int) {
+    if (detents.isEmpty()) return
+
+    val maxAvailableHeight = realScreenHeight - topInset
+    val minHeight = minOf(detentCalculator.getDetentHeight(detents.first()), maxAvailableHeight)
+    val newHeight = detentCalculator.getVisibleSheetHeight(sheetTop).coerceIn(minHeight, maxAvailableHeight)
+
+    setStateDimensions(getStateWidth(), newHeight)
+  }
+
+  private fun getStateWidth(): Int {
     val applyMaxWidth = maxContentWidth != null && !ScreenUtils.isPortraitPhone(reactContext)
     val effectiveMaxWidth = if (applyMaxWidth) maxContentWidth!! else DEFAULT_MAX_WIDTH.dpToPx().toInt()
-    val newWidth = minOf(screenWidth, effectiveMaxWidth)
+    return minOf(screenWidth, effectiveMaxWidth)
+  }
 
-    if (lastStateWidth != newWidth || lastStateHeight != newHeight) {
-      lastStateWidth = newWidth
-      lastStateHeight = newHeight
-      delegate?.viewControllerDidChangeSize(newWidth, newHeight)
-    }
+  private fun setStateDimensions(width: Int, height: Int) {
+    if (lastStateWidth == width && lastStateHeight == height) return
+
+    lastStateWidth = width
+    lastStateHeight = height
+    delegate?.viewControllerDidChangeSize(width, height)
   }
 
   fun translateSheet(translationY: Int, onEnd: (() -> Unit)? = null) {

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

@@ -221,11 +221,6 @@ class TrueSheetViewManager :
     view.setInsetAdjustment(insetAdjustment ?: "automatic")
   }
 
-  @ReactProp(name = "scrollable", defaultBoolean = false)
-  override fun setScrollable(view: TrueSheetView, value: Boolean) {
-    view.setScrollable(value)
-  }
-
   @ReactProp(name = "presentation")
   override fun setPresentation(view: TrueSheetView, value: String?) {
     // iOS/web-specific prop - no-op on Android
@@ -250,8 +245,17 @@ class TrueSheetViewManager :
     view.setScrollableOptions(scrollableOptions)
   }
 
+  @ReactProp(name = "headerOptions")
+  override fun setHeaderOptions(view: TrueSheetView, options: ReadableMap?) {
+    val position = if (options != null && options.hasKey("position")) options.getString("position") else null
+    view.setAbsoluteHeader(position == "absolute")
+  }
+
   @ReactProp(name = "footerOptions")
   override fun setFooterOptions(view: TrueSheetView, options: ReadableMap?) {
+    val position = if (options != null && options.hasKey("footerPosition")) options.getString("footerPosition") else null
+    view.setAbsoluteFooter(position == "absolute")
+
     val keyboardOffset =
       if (options != null && options.hasKey("keyboardOffset")) options.getDouble("keyboardOffset").toFloat() else 0f
     view.setFooterKeyboardOffset(keyboardOffset)

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

@@ -118,8 +118,9 @@ class TrueSheetCoordinatorLayout(context: Context) :
   override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
     // RN's ReactEditText fires this(true) on ACTION_DOWN, killing sheet drag over an input.
     // Swallow only that case — nothing between the touched EditText and the sheet scrolls
-    // (an overflowing multiline EditText or an input inside a scrollable still scrolls).
-    // Other children (maps, sliders, scrollables) keep the standard disallow contract.
+    // (an overflowing multiline EditText or an input inside a scrollable that can actually
+    // scroll still scrolls). Other children (maps, sliders, scrollables) keep the standard
+    // disallow contract.
     if (disallowIntercept && streamDraggableEditText) return
     super.requestDisallowInterceptTouchEvent(disallowIntercept)
   }
@@ -138,8 +139,16 @@ class TrueSheetCoordinatorLayout(context: Context) :
       .firstNotNullOfOrNull { it.getView() } ?: return
     if (target !== sheet && !target.isDescendantOf(sheet)) return
 
+    // A pinned scrollable that can scroll (or hosts pull-to-refresh) owns its
+    // touches — nested scrolling drags the sheet. When it can't scroll (e.g.
+    // the sheet is fully expanded and the content fits) it eats the gesture
+    // instead, so fall through and let the sheet drag from it — an EditText
+    // target needs the disallow-intercept swallow or its stream dies.
     val scrollView = delegate?.findScrollView()
-    if (scrollView != null && (target === scrollView || target.isDescendantOf(scrollView))) return
+    if (scrollView != null && (target === scrollView || target.isDescendantOf(scrollView))) {
+      val hasRefreshControl = scrollView.parent is SwipeRefreshLayout
+      if (hasRefreshControl || scrollView.scrollY > 0 || scrollView.canScrollVertically(1)) return
+    }
 
     var view: View? = target
     while (view != null && view !== this) {

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

@@ -15,7 +15,9 @@ interface TrueSheetDetentCalculatorDelegate {
   val detents: MutableList<Double>
   val contentHeight: Int
   val headerHeight: Int
+  val absoluteHeader: Boolean
   val footerHeight: Int
+  val absoluteFooter: Boolean
   val peekContentHeight: Int
   val contentBottomInset: Int
   val maxContentHeight: Int?
@@ -34,6 +36,7 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val realScreenHeight: Int get() = delegate?.realScreenHeight ?: 0
   private val detents: List<Double> get() = delegate?.detents ?: emptyList()
   private val contentHeight: Int get() = delegate?.contentHeight ?: 0
+
   private val headerHeight: Int get() = delegate?.headerHeight ?: 0
   private val footerHeight: Int get() = delegate?.footerHeight ?: 0
   private val peekContentHeight: Int get() = delegate?.peekContentHeight ?: 0
@@ -42,13 +45,39 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val keyboardInset: Int get() = delegate?.keyboardInset ?: 0
   private val topInset: Int get() = delegate?.topInset ?: 0
 
+  /**
+   * Height for auto (-1.0) detents: content + header + footer height.
+   * An absolute (floating) header or footer overlaps the content, so it contributes no height.
+   */
+  private val autoDetentHeight: Int
+    get() = contentHeight +
+      (if (delegate?.absoluteHeader == true) 0 else headerHeight) +
+      (if (delegate?.absoluteFooter == true) 0 else footerHeight)
+
+  /**
+   * Bottom inset for auto detents. A relative footer owns the sheet's bottom
+   * edge, so it absorbs the inset instead of adding it to the auto height.
+   */
+  private val autoDetentBottomInset: Int
+    get() = if (footerHeight > 0 && delegate?.absoluteFooter == false) 0 else contentBottomInset
+
+  /**
+   * Bottom inset for peek detents. An absolute footer counts toward the peek
+   * height and absorbs the inset, so it isn't added again.
+   */
+  private val peekDetentBottomInset: Int
+    get() = if (footerHeight > 0 && delegate?.absoluteFooter == true) 0 else contentBottomInset
+
   /**
    * Height for peek (-2.0) detents: header + footer + peek content height.
+   * A relative footer is pushed off-screen at peek, so it contributes no height.
    * Falls back to 150dp when none is present.
    */
   private val peekDetentHeight: Int
     get() {
-      val height = headerHeight + footerHeight + peekContentHeight
+      val height = headerHeight +
+        (if (delegate?.absoluteFooter == true) footerHeight else 0) +
+        peekContentHeight
       return if (height > 0) height else DEFAULT_PEEK_HEIGHT.dpToPx().toInt()
     }
 
@@ -58,9 +87,9 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    */
   fun getDetentHeight(detent: Double, includeKeyboard: Boolean = true): Int {
     val baseHeight = if (detent == -1.0) {
-      contentHeight + headerHeight + contentBottomInset
+      autoDetentHeight + autoDetentBottomInset
     } else if (detent == -2.0) {
-      peekDetentHeight + contentBottomInset
+      peekDetentHeight + peekDetentBottomInset
     } else {
       if (detent <= 0.0 || detent > 1.0) {
         throw IllegalArgumentException("TrueSheet: detent fraction ($detent) must be between 0 and 1")
@@ -106,7 +135,7 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
     if (index < 0 || index >= detents.size) return 0f
     val value = detents[index]
     return if (value == -1.0) {
-      (contentHeight + headerHeight).toFloat() / screenHeight.toFloat()
+      autoDetentHeight.toFloat() / screenHeight.toFloat()
     } else if (value == -2.0) {
       peekDetentHeight.toFloat() / screenHeight.toFloat()
     } else {

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

@@ -3,6 +3,8 @@
 #include <ReactCommon/JavaTurboModule.h>
 #include <ReactCommon/TurboModule.h>
 #include <jsi/jsi.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetViewComponentDescriptor.h>
 
 namespace facebook {

package/android/src/main/jni/TrueSheetStateUpdater.cpp

@@ -0,0 +1,96 @@
+//
+//  Created by Jovanni Lo (@lodev09)
+//  Copyright (c) 2024-present. All rights reserved.
+//
+//  This source code is licensed under the MIT license found in the
+//  LICENSE file in the root directory of this source tree.
+//
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewState.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetInsets.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetViewState.h>
+#include <react/renderer/core/ConcreteState.h>
+
+namespace facebook::react {
+
+static std::shared_ptr<const State> getStateFromWrapper(jni::alias_ref<jobject> stateWrapper) {
+  static const auto stateWrapperImplClass =
+      jni::findClassStatic(StateWrapperImpl::StateWrapperImplJavaDescriptor);
+  if (!stateWrapper->isInstanceOf(stateWrapperImplClass)) {
+    return nullptr;
+  }
+
+  auto impl = jni::static_ref_cast<StateWrapperImpl::jhybridobject>(stateWrapper);
+  return impl->cthis()->getState();
+}
+
+// Kotlin's StateWrapper.updateState is hardcoded async. This bridges to
+// ConcreteState::updateState with unstable_Immediate so the commit — and, when
+// called from the UI thread, the mount — run synchronously, letting Yoga resize
+// the container in the same frame as the sheet (parity with iOS).
+static jboolean updateStateImmediate(
+    jni::alias_ref<jclass> /*clazz*/,
+    jni::alias_ref<jobject> stateWrapper,
+    jfloat containerWidth,
+    jfloat containerHeight) {
+  auto state = getStateFromWrapper(stateWrapper);
+  if (!state) {
+    return JNI_FALSE;
+  }
+
+  auto concreteState = std::static_pointer_cast<const ConcreteState<TrueSheetViewState>>(state);
+
+  // Copy the latest data so fields this bridge doesn't set survive the update
+  TrueSheetViewState newState = concreteState->getData();
+  newState.containerWidth = containerWidth;
+  newState.containerHeight = containerHeight;
+  concreteState->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+
+  return JNI_TRUE;
+}
+
+// Same synchronous bridge for the footer's bottom inset — the footer must be
+// padded (and resized) before detents are configured, otherwise the behavior
+// is set up against the unpadded footer height and the auto detent lands an
+// inset short.
+static jboolean updateFooterStateImmediate(
+    jni::alias_ref<jclass> /*clazz*/,
+    jni::alias_ref<jobject> stateWrapper,
+    jfloat bottomInset) {
+  auto state = getStateFromWrapper(stateWrapper);
+  if (!state) {
+    return JNI_FALSE;
+  }
+
+  auto concreteState =
+      std::static_pointer_cast<const ConcreteState<TrueSheetFooterViewState>>(state);
+
+  // Copy the latest data so fields this bridge doesn't set survive the update
+  TrueSheetFooterViewState newState = concreteState->getData();
+  newState.bottomInset = bottomInset;
+  newState.initialized = true;
+  concreteState->updateState(std::move(newState), EventQueue::UpdateMode::unstable_Immediate);
+
+  return JNI_TRUE;
+}
+
+// Publishes the precalculated bottom safe-area inset so a late-mounted
+// footer's first layout is already padded (see TrueSheetFooterViewShadowNode).
+static void setBottomSafeArea(jni::alias_ref<jclass> /*clazz*/, jfloat insetDp) {
+  TrueSheetInsets::setBottomSafeArea(insetDp);
+}
+
+} // namespace facebook::react
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void * /*reserved*/) {
+  return facebook::jni::initialize(vm, [] {
+    facebook::jni::findClassStatic("com/lodev09/truesheet/TrueSheetStateUpdater")
+        ->registerNatives({
+            makeNativeMethod("nativeUpdateState", facebook::react::updateStateImmediate),
+            makeNativeMethod("nativeUpdateFooterState", facebook::react::updateFooterStateImmediate),
+            makeNativeMethod("nativeSetBottomSafeArea", facebook::react::setBottomSafeArea),
+        });
+  });
+}

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+/*
+ * Descriptor for <TrueSheetContentView> component.
+ */
+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

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

@@ -0,0 +1,43 @@
+#include "TrueSheetContentViewShadowNode.h"
+
+#include <react/renderer/components/view/conversions.h>
+
+namespace facebook::react {
+
+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);
+  }
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/TrueSheetSpec/EventEmitters.h>
+#include <react/renderer/components/TrueSheetSpec/Props.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char TrueSheetContentViewComponentName[];
+
+/*
+ * `ShadowNode` for <TrueSheetContentView> component.
+ */
+class JSI_EXPORT TrueSheetContentViewShadowNode final
+    : public ConcreteViewShadowNode<
+          TrueSheetContentViewComponentName,
+          TrueSheetContentViewProps,
+          TrueSheetContentViewEventEmitter,
+          TrueSheetContentViewState> {
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+ public:
+  void adjustLayoutWithState();
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,11 @@
+#include "TrueSheetContentViewState.h"
+
+namespace facebook::react {
+
+#ifdef ANDROID
+folly::dynamic TrueSheetContentViewState::getDynamic() const {
+  return folly::dynamic::object("scrollableBounded", scrollableBounded);
+}
+#endif
+
+} // namespace facebook::react

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+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).
+ */
+class TrueSheetContentViewState final {
+ public:
+  TrueSheetContentViewState() = default;
+
+#ifdef ANDROID
+  TrueSheetContentViewState(
+      TrueSheetContentViewState const &previousState,
+      folly::dynamic data)
+      : scrollableBounded(data["scrollableBounded"].getBool()) {}
+#endif
+
+  bool scrollableBounded{false};
+
+#ifdef ANDROID
+  folly::dynamic getDynamic() const;
+  MapBuffer getMapBuffer() const {
+    return MapBufferBuilder::EMPTY();
+  }
+#endif
+};
+
+} // namespace facebook::react