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

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

@@ -1,20 +1,31 @@
 package com.lodev09.truesheet
 
 import android.graphics.Color
-import android.util.Log
 import android.view.WindowManager
-import com.facebook.react.bridge.ColorPropConverter
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableType
-import com.facebook.react.common.MapBuilder
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.lodev09.truesheet.core.Utils
+import com.facebook.react.viewmanagers.TrueSheetViewManagerDelegate
+import com.facebook.react.viewmanagers.TrueSheetViewManagerInterface
+import com.lodev09.truesheet.events.*
 
-class TrueSheetViewManager : ViewGroupManager<TrueSheetView>() {
-  override fun getName() = TAG
+/**
+ * ViewManager for TrueSheetView - Fabric architecture
+ * Main sheet component that manages the bottom sheet dialog
+ */
+@ReactModule(name = TrueSheetViewManager.REACT_CLASS)
+class TrueSheetViewManager :
+  ViewGroupManager<TrueSheetView>(),
+  TrueSheetViewManagerInterface<TrueSheetView> {
+
+  private val delegate: ViewManagerDelegate<TrueSheetView> = TrueSheetViewManagerDelegate(this)
+
+  override fun getName(): String = REACT_CLASS
 
   override fun createViewInstance(reactContext: ThemedReactContext): TrueSheetView = TrueSheetView(reactContext)
 
@@ -23,117 +34,128 @@ class TrueSheetViewManager : ViewGroupManager<TrueSheetView>() {
     view.onDropInstance()
   }
 
+  override fun onAfterUpdateTransaction(view: TrueSheetView) {
+    super.onAfterUpdateTransaction(view)
+    view.showOrUpdate()
+  }
+
   override fun addEventEmitters(reactContext: ThemedReactContext, view: TrueSheetView) {
     val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
-    dispatcher?.let {
-      view.eventDispatcher = it
-    }
+    view.eventDispatcher = dispatcher
   }
 
-  override fun onAfterUpdateTransaction(view: TrueSheetView) {
-    super.onAfterUpdateTransaction(view)
-    view.configureIfShowing()
-  }
+  override fun getDelegate(): ViewManagerDelegate<TrueSheetView> = delegate
 
+  /**
+   * Export custom direct event types for Fabric
+   * Uses Kotlin native collections with decoupled event classes
+   */
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> =
     mutableMapOf(
-      TrueSheetEvent.MOUNT to MapBuilder.of("registrationName", "onMount"),
-      TrueSheetEvent.PRESENT to MapBuilder.of("registrationName", "onPresent"),
-      TrueSheetEvent.DISMISS to MapBuilder.of("registrationName", "onDismiss"),
-      TrueSheetEvent.SIZE_CHANGE to MapBuilder.of("registrationName", "onSizeChange"),
-      TrueSheetEvent.DRAG_BEGIN to MapBuilder.of("registrationName", "onDragBegin"),
-      TrueSheetEvent.DRAG_CHANGE to MapBuilder.of("registrationName", "onDragChange"),
-      TrueSheetEvent.DRAG_END to MapBuilder.of("registrationName", "onDragEnd"),
-      TrueSheetEvent.CONTAINER_SIZE_CHANGE to MapBuilder.of("registrationName", "onContainerSizeChange")
+      MountEvent.EVENT_NAME to hashMapOf("registrationName" to MountEvent.REGISTRATION_NAME),
+      WillPresentEvent.EVENT_NAME to hashMapOf("registrationName" to WillPresentEvent.REGISTRATION_NAME),
+      DidPresentEvent.EVENT_NAME to hashMapOf("registrationName" to DidPresentEvent.REGISTRATION_NAME),
+      WillDismissEvent.EVENT_NAME to hashMapOf("registrationName" to WillDismissEvent.REGISTRATION_NAME),
+      DidDismissEvent.EVENT_NAME to hashMapOf("registrationName" to DidDismissEvent.REGISTRATION_NAME),
+      DetentChangeEvent.EVENT_NAME to hashMapOf("registrationName" to DetentChangeEvent.REGISTRATION_NAME),
+      DragBeginEvent.EVENT_NAME to hashMapOf("registrationName" to DragBeginEvent.REGISTRATION_NAME),
+      DragChangeEvent.EVENT_NAME to hashMapOf("registrationName" to DragChangeEvent.REGISTRATION_NAME),
+      DragEndEvent.EVENT_NAME to hashMapOf("registrationName" to DragEndEvent.REGISTRATION_NAME),
+      PositionChangeEvent.EVENT_NAME to hashMapOf("registrationName" to PositionChangeEvent.REGISTRATION_NAME),
+      SizeChangeEvent.EVENT_NAME to hashMapOf("registrationName" to SizeChangeEvent.REGISTRATION_NAME)
     )
 
-  @ReactProp(name = "edgeToEdge")
-  fun setEdgeToEdge(view: TrueSheetView, edgeToEdge: Boolean) {
-    view.setEdgeToEdge(edgeToEdge)
-  }
+  // ==================== Props ====================
 
-  @ReactProp(name = "maxHeight")
-  fun setMaxHeight(view: TrueSheetView, height: Double) {
-    view.setMaxHeight(Utils.toPixel(height).toInt())
-  }
+  @ReactProp(name = "detents")
+  override fun setDetents(view: TrueSheetView, value: ReadableArray?) {
+    if (value == null || value.size() == 0) {
+      view.setDetents(mutableListOf(0.5, 1.0))
+      return
+    }
 
-  @ReactProp(name = "dismissible")
-  fun setDismissible(view: TrueSheetView, dismissible: Boolean) {
-    view.setDismissible(dismissible)
-  }
+    val detents = mutableListOf<Double>()
 
-  @ReactProp(name = "dimmed")
-  fun setDimmed(view: TrueSheetView, dimmed: Boolean) {
-    view.setDimmed(dimmed)
-  }
+    IntProgression
+      .fromClosedRange(0, value.size() - 1, 1)
+      .asSequence()
+      .map { idx -> value.getDouble(idx) }
+      .toCollection(detents)
 
-  @ReactProp(name = "initialIndex")
-  fun setInitialIndex(view: TrueSheetView, index: Int) {
-    view.initialIndex = index
+    view.setDetents(detents)
   }
 
-  @ReactProp(name = "initialIndexAnimated")
-  fun setInitialIndexAnimated(view: TrueSheetView, animate: Boolean) {
-    view.initialIndexAnimated = animate
+  @ReactProp(name = "background", defaultInt = Color.WHITE)
+  override fun setBackground(view: TrueSheetView, color: Int) {
+    view.setSheetBackgroundColor(color)
   }
 
-  @ReactProp(name = "keyboardMode")
-  fun setKeyboardMode(view: TrueSheetView, mode: String) {
-    val softInputMode = when (mode) {
-      "pan" -> WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN
-      else -> WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+  @ReactProp(name = "cornerRadius", defaultDouble = -1.0)
+  override fun setCornerRadius(view: TrueSheetView, radius: Double) {
+    if (radius >= 0) {
+      view.setCornerRadius(radius.dpToPx())
     }
-
-    view.setSoftInputMode(softInputMode)
   }
 
-  @ReactProp(name = "dimmedIndex")
-  fun setDimmedIndex(view: TrueSheetView, index: Int) {
-    view.setDimmedIndex(index)
+  @ReactProp(name = "grabber", defaultBoolean = true)
+  override fun setGrabber(view: TrueSheetView, grabber: Boolean) {
+    view.setGrabber(grabber)
   }
 
-  @ReactProp(name = "contentHeight")
-  fun setContentHeight(view: TrueSheetView, height: Double) {
-    view.setContentHeight(Utils.toPixel(height).toInt())
+  @ReactProp(name = "dismissible", defaultBoolean = true)
+  override fun setDismissible(view: TrueSheetView, dismissible: Boolean) {
+    view.setDismissible(dismissible)
   }
 
-  @ReactProp(name = "footerHeight")
-  fun setFooterHeight(view: TrueSheetView, height: Double) {
-    view.setFooterHeight(Utils.toPixel(height).toInt())
+  @ReactProp(name = "dimmed", defaultBoolean = true)
+  override fun setDimmed(view: TrueSheetView, dimmed: Boolean) {
+    view.setDimmed(dimmed)
   }
 
-  @ReactProp(name = "cornerRadius")
-  fun setCornerRadius(view: TrueSheetView, radius: Double) {
-    view.setCornerRadius(Utils.toPixel(radius))
+  @ReactProp(name = "dimmedIndex", defaultInt = 0)
+  override fun setDimmedIndex(view: TrueSheetView, index: Int) {
+    view.setDimmedIndex(index)
   }
 
-  @ReactProp(name = "background")
-  fun setBackground(view: TrueSheetView, colorName: Double) {
-    val color = runCatching { ColorPropConverter.getColor(colorName, view.context) }.getOrNull() ?: Color.WHITE
-    view.setBackground(color)
+  @ReactProp(name = "initialDetentIndex", defaultInt = -1)
+  override fun setInitialDetentIndex(view: TrueSheetView, index: Int) {
+    view.initialDetentIndex = index
   }
 
-  @ReactProp(name = "sizes")
-  fun setSizes(view: TrueSheetView, sizes: ReadableArray) {
-    val result = ArrayList<Any>()
-    for (i in 0 until minOf(sizes.size(), 3)) {
-      when (sizes.getType(i)) {
-        ReadableType.Number -> result.add(sizes.getDouble(i))
+  @ReactProp(name = "initialDetentAnimated", defaultBoolean = true)
+  override fun setInitialDetentAnimated(view: TrueSheetView, animate: Boolean) {
+    view.initialDetentAnimated = animate
+  }
 
-        // React Native < 0.77 used String for getString, but 0.77
-        // changed it to String?. Suppress the error for older APIs.
-        @Suppress("UNNECESSARY_SAFE_CALL")
-        ReadableType.String
-        -> sizes.getString(i)?.let { result.add(it) }
+  @ReactProp(name = "maxHeight", defaultDouble = 0.0)
+  override fun setMaxHeight(view: TrueSheetView, height: Double) {
+    if (height > 0) {
+      view.setMaxHeight(height.dpToPx().toInt())
+    }
+  }
 
-        else -> Log.d(TAG, "Invalid type")
-      }
+  @ReactProp(name = "keyboardMode")
+  override fun setKeyboardMode(view: TrueSheetView, mode: String?) {
+    val softInputMode = when (mode) {
+      "pan" -> WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN
+      else -> WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
     }
+    view.setSoftInputMode(softInputMode)
+  }
+
+  @ReactProp(name = "blurTint")
+  override fun setBlurTint(view: TrueSheetView, tint: String?) {
+    // iOS-specific prop - no-op on Android
+    view.setBlurTint(tint)
+  }
 
-    view.setSizes(result.toArray())
+  @ReactProp(name = "edgeToEdgeFullScreen", defaultBoolean = false)
+  override fun setEdgeToEdgeFullScreen(view: TrueSheetView, edgeToEdgeFullScreen: Boolean) {
+    view.setEdgeToEdgeFullScreen(edgeToEdgeFullScreen)
   }
 
   companion object {
-    const val TAG = "TrueSheetView"
+    const val REACT_CLASS = "TrueSheetView"
+    const val TAG_NAME = "TrueSheet"
   }
 }

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired when the active detent changes
+ * Payload: { index: number, position: number }
+ */
+class DetentChangeEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<DetentChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDetentChange"
+    const val REGISTRATION_NAME = "onDetentChange"
+  }
+}

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

@@ -0,0 +1,20 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired after the sheet dismissal is complete
+ */
+class DidDismissEvent(surfaceId: Int, viewId: Int) : Event<DidDismissEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDidDismiss"
+    const val REGISTRATION_NAME = "onDidDismiss"
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired after the sheet presentation is complete
+ * Payload: { index: number, position: number }
+ */
+class DidPresentEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<DidPresentEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDidPresent"
+    const val REGISTRATION_NAME = "onDidPresent"
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired when user starts dragging the sheet
+ * Payload: { index: number, position: number }
+ */
+class DragBeginEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<DragBeginEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragBegin"
+    const val REGISTRATION_NAME = "onDragBegin"
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired continuously while user is dragging the sheet
+ * Payload: { index: number, position: number }
+ */
+class DragChangeEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<DragChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragChange"
+    const val REGISTRATION_NAME = "onDragChange"
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired when user stops dragging the sheet
+ * Payload: { index: number, position: number }
+ */
+class DragEndEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<DragEndEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragEnd"
+    const val REGISTRATION_NAME = "onDragEnd"
+  }
+}

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

@@ -0,0 +1,20 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired when the sheet component is mounted and ready
+ */
+class MountEvent(surfaceId: Int, viewId: Int) : Event<MountEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topMount"
+    const val REGISTRATION_NAME = "onMount"
+  }
+}

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

@@ -0,0 +1,32 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired continuously for position updates during drag and animation
+ * Payload: { index: number, position: number, transitioning: boolean }
+ */
+class PositionChangeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val index: Int,
+  private val position: Float,
+  private val transitioning: Boolean = false
+) : Event<PositionChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+      putBoolean("transitioning", transitioning)
+    }
+
+  companion object {
+    const val EVENT_NAME = "topPositionChange"
+    const val REGISTRATION_NAME = "onPositionChange"
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired when the root view's size changes
+ * Payload: { width: number, height: number }
+ */
+class SizeChangeEvent(surfaceId: Int, viewId: Int, private val width: Int, private val height: Int) :
+  Event<SizeChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putDouble("width", PixelUtil.toDIPFromPixel(width.toFloat()).toDouble())
+      putDouble("height", PixelUtil.toDIPFromPixel(height.toFloat()).toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topSizeChange"
+    const val REGISTRATION_NAME = "onSizeChange"
+  }
+}

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

@@ -0,0 +1,20 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired before the sheet is dismissed
+ */
+class WillDismissEvent(surfaceId: Int, viewId: Int) : Event<WillDismissEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topWillDismiss"
+    const val REGISTRATION_NAME = "onWillDismiss"
+  }
+}

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

@@ -0,0 +1,26 @@
+package com.lodev09.truesheet.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Fired before the sheet is presented
+ * Payload: { index: number, position: number }
+ */
+class WillPresentEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float) :
+  Event<WillPresentEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putInt("index", index)
+      putDouble("position", position.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topWillPresent"
+    const val REGISTRATION_NAME = "onWillPresent"
+  }
+}

package/android/src/main/java/com/lodev09/truesheet/{core/Utils.kt → utils/ScreenUtils.kt}

@@ -1,24 +1,54 @@
-package com.lodev09.truesheet.core
+package com.lodev09.truesheet.utils
 
 import android.annotation.SuppressLint
 import android.content.Context
 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.Promise
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.uimanager.PixelUtil
 
-object Utils {
+/**
+ * Utility object for screen dimension calculations
+ */
+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
 
+  /**
+   * Get the status bar height
+   *
+   * @param context React context
+   * @return Status bar height in pixels
+   */
+  fun getStatusBarHeight(context: ReactContext): Int {
+    // Modern approach using WindowInsets (API 30+)
+    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
+      }
+    }
+
+    // Fallback to legacy approach for older APIs
+    return getIdentifierHeight(context, "status_bar_height")
+  }
+
+  /**
+   * Calculate the screen height
+   *
+   * @param context React context
+   * @param edgeToEdge Whether edge-to-edge mode is enabled
+   * @return Screen height in pixels
+   */
   @SuppressLint("InternalInsetResource", "DiscouragedApi")
-  fun screenHeight(context: ReactContext, edgeToEdge: Boolean): Int {
+  fun getScreenHeight(context: ReactContext, edgeToEdge: Boolean): Int {
     val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
     val displayMetrics = DisplayMetrics()
 
@@ -29,7 +59,8 @@ object Utils {
     }
 
     val screenHeight = displayMetrics.heightPixels
-    val statusBarHeight = getIdentifierHeight(context, "status_bar_height")
+    val statusBarHeight = getStatusBarHeight(context)
+
     val hasNavigationBar = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
       context.getSystemService(WindowManager::class.java)
         ?.currentWindowMetrics
@@ -57,16 +88,15 @@ object Utils {
     }
   }
 
-  fun toDIP(value: Float): Float = PixelUtil.toDIPFromPixel(value)
-  fun toPixel(value: Double): Float = PixelUtil.toPixelFromDIP(value)
-
-  fun withPromise(promise: Promise, closure: () -> Any?) {
-    try {
-      val result = closure()
-      promise.resolve(result)
-    } catch (e: Throwable) {
-      e.printStackTrace()
-      promise.reject("Error", e.message, e.cause)
-    }
+  /**
+   * Get the Y coordinate of a view in screen coordinates
+   *
+   * @param view The view to get screen Y coordinate for
+   * @return Y coordinate in screen space
+   */
+  fun getScreenY(view: View): Int {
+    val location = IntArray(2)
+    view.getLocationOnScreen(location)
+    return location[1]
   }
 }

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Custom BottomSheetDialog style with edge-to-edge enabled -->
+    <style name="TrueSheetEdgeToEdgeEnabledDialog" parent="Theme.Design.Light.BottomSheetDialog">
+        <item name="android:windowIsFloating">false</item>
+        <item name="enableEdgeToEdge">true</item>
+    </style>
+</resources>

package/ios/TrueSheetComponentDescriptor.h

@@ -0,0 +1,24 @@
+//
+//  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.
+//
+
+#pragma once
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#include <react/renderer/components/TrueSheetSpec/ComponentDescriptors.h>
+
+namespace facebook::react {
+
+class TrueSheetComponentDescriptor final : public ConcreteComponentDescriptor<TrueSheetViewComponentDescriptor> {
+ public:
+  using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
+};
+
+}  // namespace facebook::react
+
+#endif  // RCT_NEW_ARCH_ENABLED