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

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

@@ -0,0 +1,220 @@
+package com.lodev09.truesheet.core
+
+import android.view.View
+import android.view.ViewGroup
+import com.lodev09.truesheet.TrueSheetView
+
+/**
+ * Manages TrueSheet stacking behavior.
+ * Tracks presented sheets and handles visibility when sheets stack on top of each other.
+ */
+object TrueSheetStackManager {
+
+  private val presentedSheetStack = mutableListOf<TrueSheetView>()
+
+  /**
+   * Gets the parent sheet at the given index, if any.
+   * Only returns a parent if it's in the same container.
+   * Must be called within synchronized block.
+   */
+  private fun getParentSheetAt(index: Int, rootContainer: ViewGroup?): TrueSheetView? {
+    if (index <= 0) return null
+    return presentedSheetStack[index - 1].takeIf { it.rootContainerView == rootContainer }
+  }
+
+  /**
+   * Returns the topmost presented and visible sheet.
+   * Must be called within synchronized block.
+   */
+  private fun findTopmostSheet(): TrueSheetView? =
+    presentedSheetStack.lastOrNull {
+      it.viewController.isPresented && it.viewController.isSheetVisible
+    }
+
+  /**
+   * Registers a sheet in the stack and returns its parent sheet if any.
+   * Only returns a parent if it's in the same container (e.g., same Screen).
+   */
+  @JvmStatic
+  fun registerSheet(sheetView: TrueSheetView): TrueSheetView? {
+    synchronized(presentedSheetStack) {
+      val parentSheet = findTopmostSheet()?.takeIf { it.rootContainerView == sheetView.rootContainerView }
+
+      if (!presentedSheetStack.contains(sheetView)) {
+        presentedSheetStack.add(sheetView)
+      }
+
+      return parentSheet
+    }
+  }
+
+  /**
+   * Unregisters a sheet from the stack.
+   */
+  @JvmStatic
+  fun unregisterSheet(sheetView: TrueSheetView) {
+    synchronized(presentedSheetStack) {
+      presentedSheetStack.remove(sheetView)
+    }
+  }
+
+  /**
+   * Updates parent sheet translation based on the child sheet's position.
+   * Only affects parent sheets in the same container.
+   */
+  @JvmStatic
+  fun updateParentTranslation(sheetView: TrueSheetView) {
+    synchronized(presentedSheetStack) {
+      val index = presentedSheetStack.indexOf(sheetView)
+      val parentSheet = getParentSheetAt(index, sheetView.rootContainerView) ?: return
+
+      // Post to ensure layout is complete before reading position
+      sheetView.viewController.post {
+        val childMinSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(0)
+        val childCurrentSheetTop = sheetView.viewController.detentCalculator.getSheetTopForDetentIndex(
+          sheetView.viewController.currentDetentIndex
+        )
+        // Cap to minimum detent position
+        val childSheetTop = maxOf(childMinSheetTop, childCurrentSheetTop)
+        parentSheet.updateTranslationForChild(childSheetTop)
+      }
+    }
+  }
+
+  /**
+   * Returns all sheets presented on top of the given sheet (children/descendants)
+   * that are in the same container. Returns them in reverse order (top-most first) for proper dismissal.
+   */
+  @JvmStatic
+  fun getSheetsAbove(sheetView: TrueSheetView): List<TrueSheetView> {
+    synchronized(presentedSheetStack) {
+      val index = presentedSheetStack.indexOf(sheetView)
+      if (index < 0 || index >= presentedSheetStack.size - 1) return emptyList()
+      val rootContainer = sheetView.rootContainerView
+      return presentedSheetStack.subList(index + 1, presentedSheetStack.size)
+        .filter { it.rootContainerView == rootContainer }
+        .reversed()
+    }
+  }
+
+  @JvmStatic
+  fun removeSheet(sheetView: TrueSheetView) {
+    synchronized(presentedSheetStack) {
+      presentedSheetStack.remove(sheetView)
+    }
+  }
+
+  @JvmStatic
+  fun clear() {
+    synchronized(presentedSheetStack) {
+      presentedSheetStack.clear()
+    }
+  }
+
+  /**
+   * Gets the parent sheet of the given sheet, if any.
+   * Only returns a parent if it's in the same container.
+   */
+  @JvmStatic
+  fun getParentSheet(sheetView: TrueSheetView): TrueSheetView? {
+    synchronized(presentedSheetStack) {
+      val index = presentedSheetStack.indexOf(sheetView)
+      return getParentSheetAt(index, sheetView.rootContainerView)
+    }
+  }
+
+  /**
+   * Returns true if the given sheet is the topmost presented sheet in its container.
+   */
+  @JvmStatic
+  fun isTopmostSheet(sheetView: TrueSheetView): Boolean {
+    synchronized(presentedSheetStack) {
+      val rootContainer = sheetView.rootContainerView
+      return presentedSheetStack.lastOrNull { it.rootContainerView == rootContainer } == sheetView
+    }
+  }
+
+  /**
+   * Returns the topmost presented sheet, or null if none.
+   */
+  @JvmStatic
+  fun getTopmostSheet(): TrueSheetView? {
+    synchronized(presentedSheetStack) {
+      return findTopmostSheet()
+    }
+  }
+
+  private val savedBackgroundImportance = HashMap<View, Int>()
+
+  /**
+   * Hides views behind the topmost dimmed (modal) sheet from accessibility,
+   * mirroring BottomSheetDialog behavior. Sheets live in the same window as
+   * the app content, so without this TalkBack can traverse behind the sheet.
+   *
+   * Derived from the current stack state and idempotent — call whenever a
+   * sheet presents, dismisses, settles, or changes its dim state.
+   */
+  @JvmStatic
+  fun updateBackgroundAccessibility() {
+    synchronized(presentedSheetStack) {
+      val topDimmedIndex = presentedSheetStack.indexOfLast {
+        it.viewController.run { isPresented && isSheetVisible && !isBeingDismissed && isDimmedAtCurrentDetent }
+      }
+      val topDimmed = presentedSheetStack.getOrNull(topDimmedIndex)
+      val root = topDimmed?.viewController?.coordinatorLayout?.parent as? ViewGroup
+
+      if (root == null) {
+        restoreBackgroundAccessibility()
+        return
+      }
+
+      // The dimmed sheet and any sheets above it stay accessible
+      val accessibleCoordinators = presentedSheetStack
+        .subList(topDimmedIndex, presentedSheetStack.size)
+        .mapNotNull { it.viewController.coordinatorLayout }
+        .toSet()
+
+      for (i in 0 until root.childCount) {
+        val child = root.getChildAt(i)
+        if (child in accessibleCoordinators) {
+          savedBackgroundImportance.remove(child)?.let { child.importantForAccessibility = it }
+          continue
+        }
+        if (!savedBackgroundImportance.containsKey(child)) {
+          savedBackgroundImportance[child] = child.importantForAccessibility
+        }
+        child.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+      }
+    }
+  }
+
+  private fun restoreBackgroundAccessibility() {
+    savedBackgroundImportance.forEach { (view, importance) ->
+      view.importantForAccessibility = importance
+    }
+    savedBackgroundImportance.clear()
+  }
+
+  /**
+   * Returns the root presented sheet for dismissAll.
+   * Starts from the topmost sheet and walks up to find the root of its stack.
+   * Stops at modal boundary (parent hidden by modal) or when there's no parent.
+   */
+  @JvmStatic
+  fun getRootSheet(): TrueSheetView? {
+    synchronized(presentedSheetStack) {
+      val topmost = presentedSheetStack.lastOrNull { it.viewController.isPresented } ?: return null
+
+      var current: TrueSheetView = topmost
+      while (true) {
+        val parent = current.viewController.parentSheetView ?: return current
+
+        if (parent.viewController.wasHiddenByScreen) {
+          return current
+        }
+
+        current = parent
+      }
+    }
+  }
+}

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

@@ -0,0 +1,71 @@
+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 dragging begins
+ * Payload: { index: number, position: number, detent: number }
+ */
+class DragBeginEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragBegin"
+    const val REGISTRATION_NAME = "onDragBegin"
+  }
+}
+
+/**
+ * Fired continuously during dragging
+ * Payload: { index: number, position: number, detent: number }
+ */
+class DragChangeEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragChange"
+    const val REGISTRATION_NAME = "onDragChange"
+  }
+}
+
+/**
+ * Fired when dragging ends
+ * Payload: { index: number, position: number, detent: number }
+ */
+class DragEndEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDragEnd"
+    const val REGISTRATION_NAME = "onDragEnd"
+  }
+}

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

@@ -0,0 +1,65 @@
+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 is about to regain focus because a sheet on top of it is being dismissed
+ */
+class WillFocusEvent(surfaceId: Int, viewId: Int) : Event<WillFocusEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topWillFocus"
+    const val REGISTRATION_NAME = "onWillFocus"
+  }
+}
+
+/**
+ * Fired when the sheet regains focus after a sheet on top of it is dismissed
+ */
+class FocusEvent(surfaceId: Int, viewId: Int) : Event<FocusEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDidFocus"
+    const val REGISTRATION_NAME = "onDidFocus"
+  }
+}
+
+/**
+ * Fired when the sheet is about to lose focus because another sheet is being presented on top of it
+ */
+class WillBlurEvent(surfaceId: Int, viewId: Int) : Event<WillBlurEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topWillBlur"
+    const val REGISTRATION_NAME = "onWillBlur"
+  }
+}
+
+/**
+ * Fired when the sheet loses focus because another sheet is presented on top of it
+ */
+class BlurEvent(surfaceId: Int, viewId: Int) : Event<BlurEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDidBlur"
+    const val REGISTRATION_NAME = "onDidBlur"
+  }
+}

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

@@ -0,0 +1,112 @@
+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"
+  }
+}
+
+/**
+ * Fired before the sheet is presented
+ * Payload: { index: number, position: number, detent: number }
+ */
+class WillPresentEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topWillPresent"
+    const val REGISTRATION_NAME = "onWillPresent"
+  }
+}
+
+/**
+ * Fired after the sheet is presented
+ * Payload: { index: number, position: number, detent: number }
+ */
+class DidPresentEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDidPresent"
+    const val REGISTRATION_NAME = "onDidPresent"
+  }
+}
+
+/**
+ * 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"
+  }
+}
+
+/**
+ * Fired after the sheet is dismissed
+ */
+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"
+  }
+}
+
+/**
+ * Fired when the sheet visibility changes due to screen transitions
+ */
+class VisibilityChangeEvent(surfaceId: Int, viewId: Int, private val visible: Boolean) : Event<VisibilityChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putBoolean("visible", visible)
+    }
+
+  companion object {
+    const val EVENT_NAME = "topVisibilityChange"
+    const val REGISTRATION_NAME = "onVisibilityChange"
+  }
+}

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

@@ -0,0 +1,56 @@
+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 detent changes
+ * Payload: { index: number, position: number, detent: number }
+ */
+class DetentChangeEvent(surfaceId: Int, viewId: Int, private val index: Int, private val position: Float, private val detent: 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())
+      putDouble("detent", detent.toDouble())
+    }
+
+  companion object {
+    const val EVENT_NAME = "topDetentChange"
+    const val REGISTRATION_NAME = "onDetentChange"
+  }
+}
+
+/**
+ * Fired continuously for position updates during drag and animation
+ * Payload: { index: number, position: number, detent: number, realtime: boolean }
+ */
+class PositionChangeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val index: Float,
+  private val position: Float,
+  private val detent: Float,
+  private val realtime: Boolean = false
+) : Event<PositionChangeEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap =
+    Arguments.createMap().apply {
+      putDouble("index", index.toDouble())
+      putDouble("position", position.toDouble())
+      putDouble("detent", detent.toDouble())
+      putBoolean("realtime", realtime)
+    }
+
+  companion object {
+    const val EVENT_NAME = "topPositionChange"
+    const val REGISTRATION_NAME = "onPositionChange"
+  }
+}

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

@@ -0,0 +1,84 @@
+package com.lodev09.truesheet.utils
+
+import android.content.Context
+import android.os.Build
+import android.view.View
+import android.view.inputmethod.InputMethodManager
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.uimanager.ThemedReactContext
+
+object KeyboardUtils {
+
+  /**
+   * Checks if the soft keyboard is currently visible.
+   */
+  fun isKeyboardVisible(reactContext: ThemedReactContext): Boolean {
+    val rootView = reactContext.currentActivity?.window?.decorView?.rootView ?: return false
+    return isKeyboardVisible(rootView)
+  }
+
+  private fun isKeyboardVisible(view: View): Boolean {
+    val insets = ViewCompat.getRootWindowInsets(view) ?: return false
+    return insets.isVisible(WindowInsetsCompat.Type.ime())
+  }
+
+  /**
+   * Dismisses the soft keyboard if currently shown.
+   */
+  fun dismiss(reactContext: ThemedReactContext) {
+    val rootView = reactContext.currentActivity?.window?.decorView?.rootView ?: return
+    dismiss(rootView, null)
+  }
+
+  /**
+   * Dismisses the soft keyboard with an optional callback when the animation completes.
+   */
+  fun dismiss(view: View, onComplete: (() -> Unit)?) {
+    val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+    val focusedView = view.rootView.findFocus()
+
+    if (focusedView == null || !isKeyboardVisible(view)) {
+      onComplete?.invoke()
+      return
+    }
+
+    if (onComplete != null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        ViewCompat.setWindowInsetsAnimationCallback(
+          view,
+          object : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {
+            override fun onProgress(insets: WindowInsetsCompat, runningAnimations: List<WindowInsetsAnimationCompat>): WindowInsetsCompat =
+              insets
+
+            override fun onEnd(animation: WindowInsetsAnimationCompat) {
+              ViewCompat.setWindowInsetsAnimationCallback(view, null)
+              onComplete()
+            }
+          }
+        )
+      } else {
+        view.postDelayed({ onComplete() }, 120)
+      }
+    }
+
+    imm?.hideSoftInputFromWindow(focusedView.windowToken, 0)
+  }
+
+  /**
+   * Shows the soft keyboard for the given view.
+   */
+  fun show(view: View) {
+    val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
+  }
+
+  /**
+   * Gets the current keyboard height from window insets.
+   */
+  fun getKeyboardHeight(view: View): Int {
+    val insets = ViewCompat.getRootWindowInsets(view)
+    return insets?.getInsets(WindowInsetsCompat.Type.ime())?.bottom ?: 0
+  }
+}