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

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

@@ -1,102 +1,128 @@
 package com.lodev09.truesheet.utils
 
-import android.annotation.SuppressLint
-import android.content.Context
+import android.content.res.Configuration
+import android.graphics.Point
 import android.os.Build
-import android.util.DisplayMetrics
 import android.view.View
 import android.view.WindowInsets
 import android.view.WindowManager
 import com.facebook.react.bridge.ReactContext
+import kotlin.math.min
 
 /**
- * Utility object for screen dimension calculations
+ * Data class for top/bottom insets
  */
-object ScreenUtils {
-  @SuppressLint("DiscouragedApi")
-  private fun getIdentifierHeight(context: ReactContext, name: String): Int =
-    context.resources.getDimensionPixelSize(
-      context.resources.getIdentifier(name, "dimen", "android")
-    ).takeIf { it > 0 } ?: 0
+data class Insets(val top: Int, val bottom: Int)
 
+/**
+ * Utility object for screen dimension calculations.
+ * Inset calculation approach inspired by react-native-safe-area-context.
+ *
+ * Note: This library requires React Native 0.76+ which has minSdk API 24.
+ */
+object ScreenUtils {
   /**
-   * Get the status bar height
-   *
-   * @param context React context
-   * @return Status bar height in pixels
+   * Get root window insets for API 30+ (Android R)
    */
-  fun getStatusBarHeight(context: ReactContext): Int {
-    // Modern approach using WindowInsets (API 30+)
+  private fun getInsetsR(rootView: View): Insets? {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      val windowManager = context.getSystemService(WindowManager::class.java)
-      val windowMetrics = windowManager?.currentWindowMetrics
-      val insets = windowMetrics?.windowInsets?.getInsetsIgnoringVisibility(WindowInsets.Type.statusBars())
-      if (insets != null) {
-        return insets.top
-      }
+      val insets = rootView.rootWindowInsets?.getInsets(
+        WindowInsets.Type.statusBars() or
+          WindowInsets.Type.displayCutout() or
+          WindowInsets.Type.navigationBars()
+      ) ?: return null
+      return Insets(
+        top = insets.top,
+        bottom = insets.bottom
+      )
     }
+    return null
+  }
 
-    // Fallback to legacy approach for older APIs
-    return getIdentifierHeight(context, "status_bar_height")
+  /**
+   * Get root window insets for API 24-29
+   */
+  @Suppress("DEPRECATION")
+  private fun getInsetsLegacy(rootView: View): Insets? {
+    val insets = rootView.rootWindowInsets ?: return null
+    return Insets(
+      top = insets.systemWindowInsetTop,
+      // Use min to avoid including soft keyboard
+      bottom = min(insets.systemWindowInsetBottom, insets.stableInsetBottom)
+    )
   }
 
   /**
-   * Calculate the screen height
+   * Get safe area insets from ReactContext using the activity's decor view.
    *
-   * @param context React context
-   * @param edgeToEdge Whether edge-to-edge mode is enabled
-   * @return Screen height in pixels
+   * @param reactContext The ReactContext to get insets from
+   * @return Insets with top (status bar) and bottom (navigation bar) values in pixels
    */
-  @SuppressLint("InternalInsetResource", "DiscouragedApi")
-  fun getScreenHeight(context: ReactContext, edgeToEdge: Boolean): Int {
-    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
-    val displayMetrics = DisplayMetrics()
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      context.display?.getRealMetrics(displayMetrics)
+  fun getInsets(reactContext: ReactContext): Insets {
+    val activity = reactContext.currentActivity ?: return Insets(0, 0)
+    val decorView = activity.window?.decorView ?: return Insets(0, 0)
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      getInsetsR(decorView)
     } else {
-      windowManager.defaultDisplay.getMetrics(displayMetrics)
-    }
-
-    val screenHeight = displayMetrics.heightPixels
-    val statusBarHeight = getStatusBarHeight(context)
+      getInsetsLegacy(decorView)
+    } ?: Insets(0, 0)
+  }
 
-    val hasNavigationBar = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-      context.getSystemService(WindowManager::class.java)
-        ?.currentWindowMetrics
-        ?.windowInsets
-        ?.isVisible(WindowInsets.Type.navigationBars()) ?: false
+  /**
+   * Get the real physical device screen height, including system bars.
+   * This is consistent across all API levels.
+   *
+   * @param reactContext The ReactContext to get context from
+   * @return Real screen height in pixels
+   */
+  @Suppress("DEPRECATION")
+  fun getRealScreenHeight(reactContext: ReactContext): Int {
+    val windowManager = reactContext.getSystemService(WindowManager::class.java)
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      windowManager.currentWindowMetrics.bounds.height()
     } else {
-      context.resources.getIdentifier("navigation_bar_height", "dimen", "android") > 0
+      val size = Point()
+      windowManager.defaultDisplay.getRealSize(size)
+      size.y
     }
+  }
 
-    val navigationBarHeight = if (hasNavigationBar) {
-      getIdentifierHeight(context, "navigation_bar_height")
-    } else {
-      0
-    }
+  /**
+   * Get the screen width using the same method as React Native's useWindowDimensions.
+   *
+   * @param reactContext The ReactContext to get resources from
+   * @return Screen width in pixels
+   */
+  fun getScreenWidth(reactContext: ReactContext): Int = reactContext.resources.displayMetrics.widthPixels
 
-    return if (edgeToEdge) {
-      // getRealMetrics includes navigation bar height
-      // windowManager.defaultDisplay.getMetrics doesn't
-      when (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-        true -> screenHeight
-        false -> screenHeight + navigationBarHeight
-      }
-    } else {
-      screenHeight - statusBarHeight - navigationBarHeight
-    }
-  }
+  /**
+   * Calculate the screen height using the same method as React Native's useWindowDimensions.
+   * This returns the window height which automatically accounts for edge-to-edge mode.
+   *
+   * @param reactContext The ReactContext to get resources from
+   * @return Screen height in pixels
+   */
+  fun getScreenHeight(reactContext: ReactContext): Int = reactContext.resources.displayMetrics.heightPixels
 
   /**
-   * Get the Y coordinate of a view in screen coordinates
+   * Get the location of a view in screen coordinates
    *
-   * @param view The view to get screen Y coordinate for
-   * @return Y coordinate in screen space
+   * @param view The view to get screen location for
+   * @return IntArray with [x, y] coordinates in screen space
    */
-  fun getScreenY(view: View): Int {
+  fun getScreenLocation(view: View): IntArray {
     val location = IntArray(2)
     view.getLocationOnScreen(location)
-    return location[1]
+    return location
+  }
+
+  /**
+   * Returns true if the device is a phone in portrait orientation.
+   */
+  fun isPortraitPhone(reactContext: ReactContext): Boolean {
+    val config = reactContext.resources.configuration
+    val isPortrait = config.orientation == Configuration.ORIENTATION_PORTRAIT
+    val isPhone = config.smallestScreenWidthDp < 600
+    return isPortrait && isPhone
   }
 }

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

@@ -0,0 +1,30 @@
+package com.lodev09.truesheet.utils
+
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ScrollView
+import androidx.core.widget.NestedScrollView
+
+fun View.isDescendantOf(ancestor: View): Boolean {
+  if (!isAttachedToWindow) return false
+  var current: View? = this
+  while (current != null) {
+    if (current === ancestor) return true
+    current = (current.parent as? View)
+  }
+  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)
+  }
+}

package/android/src/main/jni/CMakeLists.txt

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+set(LIB_LITERAL TrueSheetSpec)
+set(LIB_TARGET_NAME react_codegen_${LIB_LITERAL})
+
+set(LIB_ANDROID_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(LIB_COMMON_DIR ${LIB_ANDROID_DIR}/../common/cpp)
+set(LIB_ANDROID_GENERATED_JNI_DIR ${LIB_ANDROID_DIR}/build/generated/source/codegen/jni)
+set(LIB_ANDROID_GENERATED_COMPONENTS_DIR ${LIB_ANDROID_GENERATED_JNI_DIR}/react/renderer/components/${LIB_LITERAL})
+
+file(GLOB LIB_CUSTOM_SRCS CONFIGURE_DEPENDS *.cpp ${LIB_COMMON_DIR}/react/renderer/components/${LIB_LITERAL}/*.cpp)
+file(GLOB LIB_CODEGEN_SRCS CONFIGURE_DEPENDS ${LIB_ANDROID_GENERATED_JNI_DIR}/*.cpp ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}/*.cpp)
+
+add_library(
+  ${LIB_TARGET_NAME}
+  SHARED
+  ${LIB_CUSTOM_SRCS}
+  ${LIB_CODEGEN_SRCS}
+)
+
+target_include_directories(
+  ${LIB_TARGET_NAME}
+  PUBLIC
+  .
+  ${LIB_COMMON_DIR}
+  ${LIB_ANDROID_GENERATED_JNI_DIR}
+  ${LIB_ANDROID_GENERATED_COMPONENTS_DIR}
+)
+
+target_link_libraries(
+  ${LIB_TARGET_NAME}
+  ReactAndroid::reactnative
+  ReactAndroid::jsi
+  fbjni::fbjni
+)
+
+target_include_directories(
+  ${CMAKE_PROJECT_NAME}
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 80)
+  target_compile_reactnative_options(${LIB_TARGET_NAME} PUBLIC)
+else()
+  target_compile_options(
+    ${LIB_TARGET_NAME}
+    PRIVATE
+    -fexceptions
+    -frtti
+    -std=c++20
+    -Wall
+  )
+endif()
+
+target_compile_options(
+  ${LIB_TARGET_NAME}
+  PRIVATE
+  -Wpedantic
+  -Wno-gnu-zero-variadic-macro-arguments
+  -Wno-dollar-in-identifier-extension
+)

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

@@ -0,0 +1,19 @@
+#pragma once
+
+#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 {
+namespace react {
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> TrueSheetSpec_ModuleProvider(
+    const std::string &moduleName,
+    const JavaTurboModule::InitParams &params);
+
+} // namespace react
+} // 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

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook::react {
+
+/*
+ * Descriptor for <TrueSheetFooterView> component.
+ */
+class TrueSheetFooterViewComponentDescriptor final
+    : public ConcreteComponentDescriptor<TrueSheetFooterViewShadowNode> {
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+
+  void adopt(ShadowNode &shadowNode) const override {
+    auto &concreteShadowNode =
+        static_cast<TrueSheetFooterViewShadowNode &>(shadowNode);
+    concreteShadowNode.adjustLayoutWithState();
+
+    ConcreteComponentDescriptor::adopt(shadowNode);
+  }
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,56 @@
+#include "TrueSheetFooterViewShadowNode.h"
+
+#include <react/renderer/components/view/conversions.h>
+
+#include "TrueSheetInsets.h"
+
+namespace facebook::react {
+
+using namespace yoga;
+
+extern const char TrueSheetFooterViewComponentName[] = "TrueSheetFooterView";
+
+void TrueSheetFooterViewShadowNode::adjustLayoutWithState() {
+  ensureUnsealed();
+
+  auto state = std::static_pointer_cast<
+      const TrueSheetFooterViewShadowNode::ConcreteState>(getState());
+  auto stateData = state->getData();
+
+  auto &props = getConcreteProps();
+
+  // Until native pushes the real inset (which requires this node to already
+  // exist), seed a late-mounted footer's first layout with the precalculated
+  // inset — otherwise it lays out unpadded and forces a second sheet resize.
+  float bottomInset = stateData.bottomInset;
+  if (!stateData.initialized && props.autoBottomInset) {
+    bottomInset = TrueSheetInsets::bottomSafeArea();
+  }
+
+  // A footer pinned to the sheet's bottom edge owns the bottom safe-area
+  // inset — pad it on top of any style padding so its content clears the
+  // home indicator while the background fills the inset.
+  auto padding = props.yogaStyle.padding(Edge::Bottom);
+  if (bottomInset > 0) {
+    // Base bottom padding from the style — Edge::Bottom wins over
+    // Vertical/All, mirroring Yoga's own resolution. Points only.
+    float base = 0;
+    for (auto edge : {Edge::Bottom, Edge::Vertical, Edge::All}) {
+      auto length = props.yogaStyle.padding(edge);
+      if (length.isDefined()) {
+        base = length.isPoints() ? length.value().unwrap() : 0;
+        break;
+      }
+    }
+    padding = StyleLength::points(base + bottomInset);
+  }
+
+  if (yogaNode_.style().padding(Edge::Bottom) != padding) {
+    yoga::Style adjustedStyle = props.yogaStyle;
+    adjustedStyle.setPadding(Edge::Bottom, padding);
+    yogaNode_.setStyle(adjustedStyle);
+    yogaNode_.setDirty(true);
+  }
+}
+
+} // namespace facebook::react

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetFooterViewShadowNode.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/TrueSheetFooterViewState.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+
+namespace facebook::react {
+
+JSI_EXPORT extern const char TrueSheetFooterViewComponentName[];
+
+/*
+ * `ShadowNode` for <TrueSheetFooterView> component.
+ */
+class JSI_EXPORT TrueSheetFooterViewShadowNode final
+    : public ConcreteViewShadowNode<
+          TrueSheetFooterViewComponentName,
+          TrueSheetFooterViewProps,
+          TrueSheetFooterViewEventEmitter,
+          TrueSheetFooterViewState> {
+  using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+ public:
+  void adjustLayoutWithState();
+};
+
+} // namespace facebook::react