@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.kt

@@ -82,7 +82,7 @@ constructor(private val fpsListener: FpsListener? = null) :
 
   @ReactProp(name = "scrollEnabled", defaultBoolean = true)
   public fun setScrollEnabled(view: ReactScrollView, value: Boolean) {
-    view.setScrollEnabled(value)
+    view.scrollEnabled = value
 
     // Set focusable to match whether scroll is enabled. This improves keyboarding
     // experience by not making scrollview a tab stop when you cannot interact with it.
@@ -335,8 +335,8 @@ constructor(private val fpsListener: FpsListener? = null) :
   public fun setFadingEdgeLength(view: ReactScrollView, value: Dynamic) {
     when (value.type) {
       ReadableType.Number -> {
-        view.setFadingEdgeLengthStart(value.asInt())
-        view.setFadingEdgeLengthEnd(value.asInt())
+        view.fadingEdgeLengthStart = value.asInt()
+        view.fadingEdgeLengthEnd = value.asInt()
       }
       ReadableType.Map -> {
         value.asMap()?.let { map ->
@@ -348,8 +348,8 @@ constructor(private val fpsListener: FpsListener? = null) :
           if (map.hasKey("end") && map.getInt("end") > 0) {
             end = map.getInt("end")
           }
-          view.setFadingEdgeLengthStart(start)
-          view.setFadingEdgeLengthEnd(end)
+          view.fadingEdgeLengthStart = start
+          view.fadingEdgeLengthEnd = end
         }
       }
       else -> {
@@ -388,7 +388,7 @@ constructor(private val fpsListener: FpsListener? = null) :
       props: ReactStylesDiffMap,
       stateWrapper: StateWrapper,
   ): Any? {
-    view.setStateWrapper(stateWrapper)
+    view.stateWrapper = stateWrapper
     if (
         ReactNativeFeatureFlags.enableViewCulling() ||
             ReactNativeFeatureFlags.useTraitHiddenOnAndroid()
@@ -430,7 +430,7 @@ constructor(private val fpsListener: FpsListener? = null) :
     // be on the wrong side. Thus we are moving it to the other side, when the list
     // is inverted.
     // See also:
-    //  - https://github.com/react/react-native/issues/35350
+    //  - https://github.com/facebook/react-native/issues/35350
     //  - https://issuetracker.google.com/issues/287304310
     if (applyFix) {
       view.verticalScrollbarPosition = View.SCROLLBAR_POSITION_LEFT

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/VirtualViewContainer.kt

@@ -9,14 +9,12 @@ package com.facebook.react.views.scroll
 
 import android.graphics.Rect
 import android.view.ViewGroup
-import com.facebook.common.logging.FLog
-import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.views.virtual.VirtualViewMode
 import java.util.*
 
 internal interface VirtualViewContainer {
-  public val virtualViewContainerState: VirtualViewContainerState
+  val virtualViewContainerState: VirtualViewContainerState
 }
 
 public interface VirtualView {
@@ -45,7 +43,17 @@ internal fun rectsOverlap(rect1: Rect, rect2: Rect): Boolean {
   return true
 }
 
-internal abstract class VirtualViewContainerState {
+/**
+ * Manages the state and visibility tracking of virtual views within a scroll container.
+ *
+ * Virtual views are lightweight representations of off-screen content that can transition between
+ * rendering modes (e.g., visible, prerendered, hidden) based on their position relative to the
+ * scroll viewport. Subclasses implement the specific strategy for tracking and updating these
+ * views.
+ *
+ * Use [create] to obtain an instance appropriate for the current feature flag configuration.
+ */
+public abstract class VirtualViewContainerState {
   protected val prerenderRatio: Double = ReactNativeFeatureFlags.virtualViewPrerenderRatio()
   protected abstract val virtualViews: MutableCollection<VirtualView>
   protected val emptyRect: Rect = Rect()
@@ -53,9 +61,9 @@ internal abstract class VirtualViewContainerState {
   protected val prerenderRect: Rect = Rect()
   protected val scrollView: ViewGroup
 
-  companion object {
+  public companion object {
     @JvmStatic
-    fun create(scrollView: ViewGroup): VirtualViewContainerState {
+    public fun create(scrollView: ViewGroup): VirtualViewContainerState {
       return if (ReactNativeFeatureFlags.enableVirtualViewContainerStateExperimental()) {
         VirtualViewContainerStateExperimental(scrollView)
       } else {
@@ -64,29 +72,23 @@ internal abstract class VirtualViewContainerState {
     }
   }
 
-  constructor(scrollView: ViewGroup) {
+  public constructor(scrollView: ViewGroup) {
     this.scrollView = scrollView
   }
 
-  open fun onChange(virtualView: VirtualView) {
-    if (virtualViews.add(virtualView)) {
-      debugLog("add", { "virtualViewID=${virtualView.virtualViewID}" })
-    } else {
-      debugLog("update", { "virtualViewID=${virtualView.virtualViewID}" })
-    }
+  public open fun onChange(virtualView: VirtualView) {
+    virtualViews.add(virtualView)
     updateModes(virtualView)
   }
 
-  open fun remove(virtualView: VirtualView) {
+  public open fun remove(virtualView: VirtualView) {
     assert(virtualViews.remove(virtualView)) {
       "Attempting to remove non-existent VirtualView: ${virtualView.virtualViewID}"
     }
-    debugLog("remove", { "virtualViewID=${virtualView.virtualViewID}" })
   }
 
   // Called on ScrollView onLayout or onScroll
-  fun updateState() {
-    debugLog("updateState")
+  public fun updateState() {
     updateModes()
   }
 
@@ -98,7 +100,6 @@ internal abstract class VirtualViewContainerState {
     // intentionally goes but curently ScrollView and v1 Fling use this check to determine if
     // "content ready"
     if (visibleRect.isEmpty()) {
-      debugLog("updateRects", { "scrollView visibleRect is empty" })
       // should set the other rects here in case scrollview is suddenly empty after the other rects
       // are non-empty
       prerenderRect.set(visibleRect)
@@ -110,22 +111,7 @@ internal abstract class VirtualViewContainerState {
         (-prerenderRect.width() * prerenderRatio).toInt(),
         (-prerenderRect.height() * prerenderRatio).toInt(),
     )
-
-    debugLog(
-        "updateRects",
-        { "visibleRect ${visibleRect.toString()} prerenderRect ${prerenderRect.toString()}" },
-    )
   }
 
   protected abstract fun updateModes(virtualView: VirtualView? = null)
 }
-
-private const val DEBUG_TAG: String = "VirtualViewContainerState"
-internal val IS_DEBUG_BUILD =
-    ReactBuildConfig.DEBUG || ReactBuildConfig.IS_INTERNAL_BUILD || ReactBuildConfig.ENABLE_PERFETTO
-
-private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
-  }
-}

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/VirtualViewContainerStateClassic.kt

@@ -9,7 +9,7 @@ package com.facebook.react.views.scroll
 
 import android.view.ViewGroup
 import com.facebook.common.logging.FLog
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.views.virtual.VirtualViewMode
 
 internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
@@ -58,12 +58,14 @@ internal class VirtualViewContainerStateClassic(scrollView: ViewGroup) :
       )
     }
   }
-}
 
-private const val DEBUG_TAG: String = "VirtualViewContainerStateClassic"
+  internal companion object {
+    private val ENABLE_DEBUG_LOGS = ReactBuildConfig.DEBUG && false
 
-private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
+    internal inline fun debugLog(subtag: String, block: () -> String = { "" }) {
+      if (ENABLE_DEBUG_LOGS) {
+        FLog.d("VirtualViewContainerStateClassic:$subtag", block())
+      }
+    }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/VirtualViewContainerStateExperimental.kt

@@ -10,7 +10,7 @@ package com.facebook.react.views.scroll
 import android.graphics.Rect
 import android.view.ViewGroup
 import com.facebook.common.logging.FLog
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.views.virtual.VirtualViewMode
 
 internal class VirtualViewContainerStateExperimental(scrollView: ViewGroup) :
@@ -503,10 +503,10 @@ internal class IntervalTree(private val horizontal: Boolean) : MutableCollection
   }
 }
 
-private const val DEBUG_TAG: String = "VirtualViewContainerStateExperimental"
+private val ENABLE_DEBUG_LOGS = ReactBuildConfig.DEBUG && false
 
 private inline fun debugLog(subtag: String, block: () -> String = { "" }) {
-  if (IS_DEBUG_BUILD && ReactNativeFeatureFlags.enableVirtualViewDebugFeatures()) {
-    FLog.d("$DEBUG_TAG:$subtag", block())
+  if (ENABLE_DEBUG_LOGS) {
+    FLog.d("VirtualViewContainerStateExperimental:$subtag", block())
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/generate-nested-scroll-view.js

@@ -11,8 +11,8 @@
  */
 
 /**
- * Generates ReactNestedScrollView.java and ReactNestedScrollViewManager.kt from
- * ReactScrollView.java and ReactScrollViewManager.kt respectively.
+ * Generates ReactNestedScrollView.kt and ReactNestedScrollViewManager.kt from
+ * ReactScrollView.kt and ReactScrollViewManager.kt respectively.
  *
  * This script creates variants that use NestedScrollView instead of ScrollView
  * for experimentation purposes.
@@ -101,17 +101,17 @@ function replaceCopyrightHeader(content, sourceFile) {
 }
 
 /**
- * Transform ReactScrollView.java to ReactNestedScrollView.java
+ * Transform ReactScrollView.kt to ReactNestedScrollView.kt
  */
 function transformScrollView(content) {
-  // Replace import
+  // Replace import (Kotlin imports have no semicolons)
   content = content.replace(
-    'import android.widget.ScrollView;',
-    'import androidx.core.widget.NestedScrollView;',
+    'import android.widget.ScrollView',
+    'import androidx.core.widget.NestedScrollView',
   );
 
   // Replace standalone ScrollView with NestedScrollView (not when part of another word)
-  // This handles: "extends ScrollView", "ScrollView.class", etc.
+  // This handles: ": ScrollView(context)", "ScrollView::class.java", etc.
   // But NOT: ReactScrollView, NestedScrollView, ScrollViewHelper, etc.
   content = content.replace(
     /(?<![A-Za-z])ScrollView(?!Helper|Manager|CommandHelper|Interface|Accessible|Accessibility)/g,
@@ -121,21 +121,14 @@ function transformScrollView(content) {
   // Replace ReactScrollView with ReactNestedScrollView
   content = replaceClassNames(content);
 
-  // Fix visibility differences between ScrollView and NestedScrollView:
-  // NestedScrollView.onAttachedToWindow() is public, not protected
-  content = content.replace(
-    'protected void onAttachedToWindow()',
-    'public void onAttachedToWindow()',
-  );
-
-  // Make the class package-private (remove public) to keep it internal
+  // Make the class internal to keep it out of the public API
   content = content.replace(
-    'public class ReactNestedScrollView',
-    'class ReactNestedScrollView',
+    'public open class ReactNestedScrollView',
+    'internal open class ReactNestedScrollView',
   );
 
   // Remove original copyright header and add generated header
-  content = replaceCopyrightHeader(content, 'ReactScrollView.java');
+  content = replaceCopyrightHeader(content, 'ReactScrollView.kt');
 
   return content;
 }
@@ -246,8 +239,8 @@ function main() {
 
   const filesToGenerate = [
     {
-      source: path.join(sourceDir, 'ReactScrollView.java'),
-      output: path.join(sourceDir, 'ReactNestedScrollView.java'),
+      source: path.join(sourceDir, 'ReactScrollView.kt'),
+      output: path.join(sourceDir, 'ReactNestedScrollView.kt'),
       transform: transformScrollView,
     },
     {

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/ReactSwipeRefreshLayout.kt

@@ -12,13 +12,14 @@ import android.view.ViewConfiguration
 import android.view.ViewGroup
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.HasChildPressedStateDelay
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.events.NativeGestureUtil
 import kotlin.math.abs
 
 /** Basic extension of [SwipeRefreshLayout] with ReactNative-specific functionality. */
 public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
-    SwipeRefreshLayout(reactContext) {
+    SwipeRefreshLayout(reactContext), HasChildPressedStateDelay {
 
   private var didLayout: Boolean = false
   private var refreshing: Boolean = false
@@ -28,6 +29,8 @@ public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
   private var intercepted: Boolean = false
   private var nativeGestureStarted: Boolean = false
 
+  override var hasChildPressedStateDelay: Boolean? = null
+
   public override fun setRefreshing(refreshing: Boolean) {
     this.refreshing = refreshing
 
@@ -79,6 +82,9 @@ public open class ReactSwipeRefreshLayout(reactContext: ReactContext) :
     parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
   }
 
+  override fun shouldDelayChildPressedState(): Boolean =
+      hasChildPressedStateDelay ?: super.shouldDelayChildPressedState()
+
   public override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
     if (shouldInterceptTouchEvent(ev) && super.onInterceptTouchEvent(ev)) {
       NativeGestureUtil.notifyNativeGestureStarted(this, ev)

package/ReactAndroid/src/main/java/com/facebook/react/views/text/MutableSpannableLayout.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.views.text
+
+import android.text.Layout
+import android.text.SpannableString
+import android.text.Spanned
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.views.text.internal.span.StatefulSpan
+
+/**
+ * A delegating [Layout] subclass that clones the spannable text from [delegate] and replaces all
+ * [StatefulSpan] instances with fresh clones. This gives each [PreparedLayoutTextView] independent
+ * mutable span state (e.g. particle animation, dismiss state) even when the underlying [Layout] is
+ * shared from a cache.
+ *
+ * The mutable [Spannable] can be useful for spans which affect display, but do not alter existing
+ * layout calculations.
+ *
+ * Line metrics are delegated to [delegate] so no expensive [StaticLayout] rebuild is needed.
+ * [Layout.getText] is final and returns `mText` set by the protected constructor, so the cloned
+ * [SpannableString] is passed there directly.
+ */
+internal class MutableSpannableLayout
+private constructor(
+    private val delegate: Layout,
+    clonedText: SpannableString,
+) :
+    Layout(
+        clonedText,
+        delegate.paint,
+        delegate.width,
+        delegate.alignment,
+        delegate.spacingMultiplier,
+        delegate.spacingAdd,
+    ) {
+
+  companion object {
+    /** Returns a [MutableSpannableLayout] if [layout] contains stateful spans, else null. */
+    @OptIn(UnstableReactNativeAPI::class)
+    fun createIfNeeded(layout: Layout): MutableSpannableLayout? {
+      val spanned = layout.text as? Spanned ?: return null
+      val statefulSpans = spanned.getSpans(0, spanned.length, StatefulSpan::class.java)
+      if (statefulSpans.isEmpty()) {
+        return null
+      }
+
+      val cloned = SpannableString(spanned)
+      for (oldSpan in statefulSpans) {
+        val start = cloned.getSpanStart(oldSpan)
+        val end = cloned.getSpanEnd(oldSpan)
+        val flags = cloned.getSpanFlags(oldSpan)
+        cloned.removeSpan(oldSpan)
+        cloned.setSpan(oldSpan.clone(), start, end, flags)
+      }
+      return MutableSpannableLayout(layout, cloned)
+    }
+  }
+
+  // --- 10 abstract methods — delegate to original ---
+
+  override fun getLineCount(): Int = delegate.lineCount
+
+  override fun getLineTop(line: Int): Int = delegate.getLineTop(line)
+
+  override fun getLineDescent(line: Int): Int = delegate.getLineDescent(line)
+
+  override fun getLineStart(line: Int): Int = delegate.getLineStart(line)
+
+  override fun getLineContainsTab(line: Int): Boolean = delegate.getLineContainsTab(line)
+
+  override fun getLineDirections(line: Int): Directions = delegate.getLineDirections(line)
+
+  override fun getTopPadding(): Int = delegate.topPadding
+
+  override fun getBottomPadding(): Int = delegate.bottomPadding
+
+  override fun getEllipsisStart(line: Int): Int = delegate.getEllipsisStart(line)
+
+  override fun getEllipsisCount(line: Int): Int = delegate.getEllipsisCount(line)
+
+  override fun getParagraphDirection(line: Int): Int = delegate.getParagraphDirection(line)
+
+  // --- Non-abstract overrides for performance/correctness ---
+  // StaticLayout overrides these with optimized implementations. Delegating
+  // ensures we get the original's fast paths rather than Layout's base
+  // implementations that recompute from scratch.
+
+  override fun getEllipsizedWidth(): Int = delegate.ellipsizedWidth
+
+  override fun getLineMax(line: Int): Float = delegate.getLineMax(line)
+
+  override fun getLineWidth(line: Int): Float = delegate.getLineWidth(line)
+
+  override fun getLineLeft(line: Int): Float = delegate.getLineLeft(line)
+
+  override fun getLineRight(line: Int): Float = delegate.getLineRight(line)
+
+  // Only called by the framework on API 33+
+  @android.annotation.SuppressLint("NewApi")
+  override fun isFallbackLineSpacingEnabled(): Boolean = delegate.isFallbackLineSpacingEnabled
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/text/PreparedLayoutTextView.kt

@@ -18,18 +18,24 @@ import android.text.Spanned
 import android.text.style.ClickableSpan
 import android.view.KeyEvent
 import android.view.MotionEvent
+import android.view.View
 import android.view.ViewGroup
+import android.view.ViewParent
 import androidx.annotation.ColorInt
 import androidx.annotation.DoNotInline
 import androidx.annotation.RequiresApi
 import androidx.core.view.ViewCompat
 import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.ReactCompoundView
+import com.facebook.react.uimanager.RootView
 import com.facebook.react.uimanager.style.Overflow
-import com.facebook.react.views.text.internal.span.DrawCommandSpan
+import com.facebook.react.views.text.internal.span.AnimatedEffectSpan
+import com.facebook.react.views.text.internal.span.CanvasEffectSpan
 import com.facebook.react.views.text.internal.span.ReactFragmentIndexSpan
 import com.facebook.react.views.text.internal.span.ReactLinkSpan
+import com.facebook.react.views.text.internal.span.TouchableSpan
 import kotlin.collections.ArrayList
 import kotlin.math.roundToInt
 
@@ -44,14 +50,19 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
 
   private var clickableSpans: List<ClickableSpan> = emptyList()
   private var selection: TextSelection? = null
+  private var lastFrameTimeNanos: Long = 0L
 
   var preparedLayout: PreparedLayout? = null
     set(value) {
       if (field != value) {
+        val effectiveValue = value?.maybeProxyStatefulSpans()
         val lastSelection = selection
         if (lastSelection != null) {
-          if (value != null && field?.layout?.text.toString() == value.layout.text.toString()) {
-            value.layout.getSelectionPath(
+          if (
+              effectiveValue != null &&
+                  field?.layout?.text.toString() == effectiveValue.layout.text.toString()
+          ) {
+            effectiveValue.layout.getSelectionPath(
                 lastSelection.start,
                 lastSelection.end,
                 lastSelection.path,
@@ -61,9 +72,10 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
           }
         }
 
-        clickableSpans = value?.layout?.text?.let { filterClickableSpans(it) } ?: emptyList()
+        clickableSpans =
+            effectiveValue?.layout?.text?.let { filterClickableSpans(it) } ?: emptyList()
 
-        field = value
+        field = effectiveValue
         invalidate()
       }
     }
@@ -94,9 +106,18 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     clickableSpans = emptyList()
     selection = null
     selectionColor = null
+    lastFrameTimeNanos = 0L
     preparedLayout = null
   }
 
+  override fun onVisibilityChanged(changedView: View, visibility: Int) {
+    super.onVisibilityChanged(changedView, visibility)
+    if (visibility != VISIBLE) {
+      lastFrameTimeNanos = 0L
+    }
+  }
+
+  @OptIn(UnstableReactNativeAPI::class)
   override fun onDraw(canvas: Canvas) {
     if (overflow != Overflow.VISIBLE) {
       BackgroundStyleApplicator.clipToPaddingBox(this, canvas)
@@ -116,11 +137,11 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
       }
 
       val spanned = text as? Spanned
-      val drawCommandSpans =
-          spanned?.getSpans(0, spanned.length, DrawCommandSpan::class.java) ?: emptyArray()
+      val canvasEffectSpans =
+          spanned?.getSpans(0, spanned.length, CanvasEffectSpan::class.java) ?: emptyArray()
 
       if (spanned != null) {
-        for (span in drawCommandSpans) {
+        for (span in canvasEffectSpans) {
           span.onPreDraw(
               spanned.getSpanStart(span),
               spanned.getSpanEnd(span),
@@ -137,7 +158,7 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
       }
 
       if (spanned != null) {
-        for (span in drawCommandSpans) {
+        for (span in canvasEffectSpans) {
           span.onDraw(
               spanned.getSpanStart(span),
               spanned.getSpanEnd(span),
@@ -146,6 +167,38 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
           )
         }
       }
+
+      if (spanned != null) {
+        val animatedEffectSpans =
+            spanned.getSpans(0, spanned.length, AnimatedEffectSpan::class.java)
+
+        if (animatedEffectSpans.isNotEmpty()) {
+          val now = System.nanoTime()
+          val deltaNanos = if (lastFrameTimeNanos == 0L) 0L else now - lastFrameTimeNanos
+          lastFrameTimeNanos = now
+
+          var needsNextFrame = false
+          for (span in animatedEffectSpans) {
+            if (
+                span.onDraw(
+                    spanned.getSpanStart(span),
+                    spanned.getSpanEnd(span),
+                    canvas,
+                    layout,
+                    deltaNanos,
+                )
+            ) {
+              needsNextFrame = true
+            }
+          }
+
+          if (needsNextFrame) {
+            postInvalidateOnAnimation()
+          } else {
+            lastFrameTimeNanos = 0L
+          }
+        }
+      }
     }
   }
 
@@ -180,13 +233,19 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     invalidate()
   }
 
+  @OptIn(UnstableReactNativeAPI::class)
   override fun onTouchEvent(event: MotionEvent): Boolean {
-    if (!isEnabled || clickableSpans.isEmpty()) {
+    if (!isEnabled) {
       return super.onTouchEvent(event)
     }
 
     val action = event.actionMasked
     if (action == MotionEvent.ACTION_CANCEL) {
+      // Forward ACTION_CANCEL to all TouchableSpans so they can reset pressed/animation state
+      val spanned = text as? Spanned
+      for (span in spanned?.getSpans(0, spanned.length, TouchableSpan::class.java).orEmpty()) {
+        span.onTouchEvent(action, 0f, 0f)
+      }
       clearSelection()
       return false
     }
@@ -194,6 +253,32 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     val x = event.x.toInt()
     val y = event.y.toInt()
 
+    // Handle TouchableSpan (e.g., spoiler text) — independent of ClickableSpan.
+    // Only consume the event if the span actually handled it (e.g., spoiler not yet
+    // dismissed). If it returns false, fall through to ClickableSpan handling so that
+    // links under dismissed spoiler text remain tappable.
+    val touchableSpan = getSpanInCoords(x, y, TouchableSpan::class.java)
+    if (touchableSpan != null) {
+      val layoutX = event.x - paddingLeft
+      val layoutY = event.y - paddingTop - (preparedLayout?.verticalOffset ?: 0f)
+      if (touchableSpan.onTouchEvent(action, layoutX, layoutY)) {
+        if (action == MotionEvent.ACTION_DOWN) {
+          // Returning true from onTouchEvent stops Android's onClickListener path on parents,
+          // but RN's gesture responder runs at the JS layer and would still let an ancestor
+          // <Pressable> fire onPress on this gesture. Tell the React root we're taking over so
+          // it cancels in-flight JS responder tracking — same hook ScrollView uses on intercept.
+          findRootView()?.onChildStartedNativeGesture(this, event)
+        }
+        invalidate()
+        return true
+      }
+    }
+
+    // Existing ClickableSpan handling
+    if (clickableSpans.isEmpty()) {
+      return super.onTouchEvent(event)
+    }
+
     val clickableSpan = getSpanInCoords(x, y, ClickableSpan::class.java)
 
     if (clickableSpan == null) {
@@ -214,6 +299,15 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     return true
   }
 
+  private fun findRootView(): RootView? {
+    var p: ViewParent? = parent
+    while (p != null) {
+      if (p is RootView) return p
+      p = p.parent
+    }
+    return null
+  }
+
   private fun <T> getSpanInCoords(x: Int, y: Int, clazz: Class<T>): T? {
     val offset = getTextOffsetAt(x, y)
     if (offset < 0) {
@@ -308,6 +402,8 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
     }
   }
 
+  override fun shouldDelayChildPressedState(): Boolean = false
+
   public override fun dispatchHoverEvent(event: MotionEvent): Boolean =
       super.dispatchHoverEvent(event)
 
@@ -393,5 +489,21 @@ internal class PreparedLayoutTextView(context: Context) : ViewGroup(context), Re
 
       return spans
     }
+
+    /**
+     * If the layout contains [StatefulSpan]s, returns a new [PreparedLayout] whose spannable has
+     * independent clones of those spans. Otherwise returns the receiver unchanged.
+     */
+    private fun PreparedLayout.maybeProxyStatefulSpans(): PreparedLayout {
+      val proxyLayout = MutableSpannableLayout.createIfNeeded(layout) ?: return this
+      return PreparedLayout(
+          proxyLayout,
+          maximumNumberOfLines,
+          verticalOffset,
+          reactTags,
+          textBreakStrategy,
+          justificationMode,
+      )
+    }
   }
 }