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

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

@@ -0,0 +1,31 @@
+package com.lodev09.truesheet.utils
+
+import android.view.MotionEvent
+
+/**
+ * Guards a nested RootView against dispatching the same [MotionEvent] to JS twice.
+ *
+ * An event that no child consumes reaches both `onInterceptTouchEvent` and `onTouchEvent`,
+ * so dispatching from both starts a second JS touch stream for the same gesture.
+ *
+ * A plain root can live with that, but the sheet's roots are nested: touches that hit no
+ * React child resolve to the root's own tag, and the second stream then finds that view
+ * already holding the responder, so React only asks its ancestors - handing the touch to
+ * touchables outside the sheet.
+ */
+internal class TouchEventDeduper {
+  private var downTime = Long.MIN_VALUE
+  private var eventTime = Long.MIN_VALUE
+  private var action = -1
+
+  fun shouldDispatch(event: MotionEvent): Boolean {
+    if (event.downTime == downTime && event.eventTime == eventTime && event.action == action) {
+      return false
+    }
+
+    downTime = event.downTime
+    eventTime = event.eventTime
+    action = event.action
+    return true
+  }
+}

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

@@ -0,0 +1,42 @@
+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
+  var current: View? = this
+  while (current != null) {
+    if (current === ancestor) return true
+    current = (current.parent as? View)
+  }
+  return false
+}
+
+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/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,20 @@
+#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/TrueSheetOverlayViewComponentDescriptor.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,16 @@
+#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;
+};
+
+} // namespace facebook::react

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

@@ -0,0 +1,68 @@
+#include "TrueSheetContentViewShadowNode.h"
+
+#include <limits>
+
+#include <react/renderer/components/view/conversions.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/core/LayoutContext.h>
+
+namespace facebook::react {
+
+using namespace yoga;
+
+extern const char TrueSheetContentViewComponentName[] = "TrueSheetContentView";
+
+// measure() lays out a clone of this node, which re-enters layout() on the
+// clone — guard so the measurement pass doesn't measure again recursively.
+static thread_local bool gIsMeasuringNaturalHeight = false;
+
+void TrueSheetContentViewShadowNode::layout(LayoutContext layoutContext) {
+  ConcreteViewShadowNode::layout(layoutContext);
+  updateNaturalHeightIfNeeded(layoutContext);
+}
+
+// The content's committed height follows the container instead of its own
+// content when it can grow/shrink along the main axis or uses a percent
+// height. Reporting that height as the natural height would echo the sheet's
+// own size back as a content size change — e.g. flex: 1 content tracking a
+// drag frame by frame.
+static bool isHeightContainerDerived(const yoga::Style &style) {
+  return style.flexGrow().unwrapOrDefault(0) > 0 ||
+      style.flexShrink().unwrapOrDefault(0) > 0 ||
+      style.dimension(Dimension::Height).isPercent();
+}
+
+// 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) {
+  if (gIsMeasuringNaturalHeight) {
+    return;
+  }
+
+  auto stateData = getStateData();
+  auto size = getLayoutMetrics().frame.size;
+
+  Float naturalHeight = size.height;
+  if (isHeightContainerDerived(getConcreteProps().yogaStyle)) {
+    auto constraints = LayoutConstraints{};
+    constraints.minimumSize = {size.width, 0};
+    constraints.maximumSize = {size.width, std::numeric_limits<Float>::infinity()};
+    constraints.layoutDirection = getLayoutMetrics().layoutDirection;
+
+    gIsMeasuringNaturalHeight = true;
+    naturalHeight = measure(layoutContext, constraints).height;
+    gIsMeasuringNaturalHeight = false;
+  }
+
+  if (stateData.naturalHeight != naturalHeight) {
+    stateData.naturalHeight = naturalHeight;
+    setStateData(std::move(stateData));
+  }
+}
+
+} // namespace facebook::react

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

@@ -0,0 +1,33 @@
+#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:
+#pragma mark - LayoutableShadowNode
+
+  void layout(LayoutContext layoutContext) override;
+
+ private:
+  void updateNaturalHeightIfNeeded(const LayoutContext &layoutContext);
+};
+
+} // 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("naturalHeight", naturalHeight);
+}
+#endif
+
+} // namespace facebook::react

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+
+#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.
+ * `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)
+      : naturalHeight(previousState.naturalHeight) {}
+#endif
+
+  Float naturalHeight{0};
+
+#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