react-native-tvos 0.86.2-0 → 0.87.0-0

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,
+      )
+    }
   }
 }

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

@@ -47,6 +47,7 @@ import com.facebook.react.uimanager.style.BorderRadiusProp;
 import com.facebook.react.uimanager.style.BorderStyle;
 import com.facebook.react.uimanager.style.LogicalEdge;
 import com.facebook.react.uimanager.style.Overflow;
+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.ReactTagSpan;
 import com.facebook.yoga.YogaMeasureMode;
@@ -237,8 +238,97 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
         BackgroundStyleApplicator.clipToPaddingBox(this, canvas);
       }
 
-      super.onDraw(canvas);
+      if (spanned != null) {
+        Layout layout = getLayout();
+        if (layout != null) {
+          CanvasEffectSpan[] drawSpans =
+              spanned.getSpans(0, spanned.length(), CanvasEffectSpan.class);
+          if (shouldDrawLayoutWithoutTextViewClip()) {
+            drawLayoutWithoutTextViewClip(canvas, spanned, layout, drawSpans);
+          } else {
+            if (drawSpans.length > 0) {
+              drawTextEffects(canvas, spanned, layout, drawSpans, true, false);
+              super.onDraw(canvas);
+              drawTextEffects(canvas, spanned, layout, drawSpans, false, false);
+            } else {
+              super.onDraw(canvas);
+            }
+          }
+        } else {
+          super.onDraw(canvas);
+        }
+      } else {
+        super.onDraw(canvas);
+      }
+    }
+  }
+
+  private boolean shouldDrawLayoutWithoutTextViewClip() {
+    return mOverflow == Overflow.VISIBLE && !mTextIsSelectable && getMovementMethod() == null;
+  }
+
+  private void drawLayoutWithoutTextViewClip(
+      Canvas canvas, Spannable spanned, Layout layout, CanvasEffectSpan[] drawSpans) {
+    getPaint().setColor(getCurrentTextColor());
+    getPaint().drawableState = getDrawableState();
+
+    drawTextEffects(canvas, spanned, layout, drawSpans, true, true);
+
+    canvas.save();
+    canvas.translate(
+        getCompoundPaddingLeft(), getExtendedPaddingTop() + getVerticalGravityOffset(layout));
+    layout.draw(canvas);
+    canvas.restore();
+
+    drawTextEffects(canvas, spanned, layout, drawSpans, false, true);
+  }
+
+  private void drawTextEffects(
+      Canvas canvas,
+      Spannable spanned,
+      Layout layout,
+      CanvasEffectSpan[] drawSpans,
+      boolean beforeText,
+      boolean includeVerticalGravityOffset) {
+    if (drawSpans.length == 0) {
+      return;
+    }
+
+    canvas.save();
+    canvas.translate(
+        getCompoundPaddingLeft(),
+        getExtendedPaddingTop()
+            + (includeVerticalGravityOffset ? getVerticalGravityOffset(layout) : 0));
+    for (CanvasEffectSpan span : drawSpans) {
+      int start = spanned.getSpanStart(span);
+      int end = spanned.getSpanEnd(span);
+      if (beforeText) {
+        span.onPreDraw(start, end, canvas, layout);
+      } else {
+        span.onDraw(start, end, canvas, layout);
+      }
+    }
+    canvas.restore();
+  }
+
+  private int getVerticalGravityOffset(Layout layout) {
+    int availableVerticalSpace = getAvailableVerticalSpace();
+    if (layout.getHeight() >= availableVerticalSpace) {
+      return 0;
+    }
+
+    int verticalGravity = getGravity() & Gravity.VERTICAL_GRAVITY_MASK;
+    if (verticalGravity == Gravity.BOTTOM) {
+      return availableVerticalSpace - layout.getHeight();
+    } else if (verticalGravity == Gravity.CENTER_VERTICAL) {
+      return (availableVerticalSpace - layout.getHeight()) / 2;
     }
+
+    return 0;
+  }
+
+  private int getAvailableVerticalSpace() {
+    return getHeight() - getExtendedPaddingTop() - getExtendedPaddingBottom();
   }
 
   @Override
@@ -252,7 +342,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     try (SystraceSection s = new SystraceSection("ReactTextView.setText(ReactTextUpdate)")) {
       // Android's TextView crashes when it tries to relayout if LayoutParams are
       // null; explicitly set the LayoutParams to prevent this crash. See:
-      // https://github.com/react/react-native/pull/7011
+      // https://github.com/facebook/react-native/pull/7011
       if (getLayoutParams() == null) {
         setLayoutParams(EMPTY_LAYOUT_PARAMS);
       }

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

@@ -43,6 +43,7 @@ import com.facebook.react.uimanager.style.BorderRadiusProp
 import com.facebook.react.uimanager.style.BorderStyle.Companion.fromString
 import com.facebook.react.uimanager.style.LogicalEdge
 import com.facebook.react.views.text.DefaultStyleValuesUtil.getDefaultTextColorHighlight
+import com.facebook.react.views.text.ReactTypefaceUtils.getFontWeightAdjustment
 import java.util.HashMap
 
 /** View manager for `<Text>` nodes. */
@@ -158,8 +159,10 @@ public constructor(
     val spanned: Spannable =
         TextLayoutManager.getOrCreateSpannableForText(
             view.context.assets,
+            getFontWeightAdjustment(view.context),
             attributedString,
             reactTextViewManagerCallback,
+            TextEffectRegistry.current,
         )
     view.setSpanned(spanned)
 

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

@@ -7,14 +7,23 @@
 
 package com.facebook.react.views.text
 
+import android.content.Context
 import android.content.res.AssetManager
+import android.content.res.Configuration
 import android.graphics.Typeface
+import android.os.Build
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.common.assets.ReactFontManager
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import kotlin.math.max
+import kotlin.math.min
 
 public object ReactTypefaceUtils {
 
+  private const val FONT_WEIGHT_MIN = 1
+  private const val FONT_WEIGHT_MAX = 1000
+
   @JvmStatic
   public fun parseFontWeight(fontWeightString: String?): Int =
       when (fontWeightString) {
@@ -110,4 +119,36 @@ public object ReactTypefaceUtils {
       ReactFontManager.getInstance().getTypeface(fontFamilyName, typefaceStyle, assetManager)
     }
   }
+
+  @JvmStatic
+  public fun getFontWeightAdjustment(context: Context): Int =
+      if (
+          Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
+              ReactNativeFeatureFlags.enableAndroidFontWeightAdjustment()
+      ) {
+        context.resources.configuration.fontWeightAdjustment
+      } else {
+        0
+      }
+
+  @JvmStatic
+  public fun applyFontWeightAdjustment(
+      typeface: Typeface?,
+      fontWeightAdjustment: Int,
+  ): Typeface? {
+    if (
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S ||
+            fontWeightAdjustment == 0 ||
+            fontWeightAdjustment == Configuration.FONT_WEIGHT_ADJUSTMENT_UNDEFINED
+    ) {
+      return typeface
+    }
+
+    val baseTypeface = typeface ?: Typeface.DEFAULT
+    val adjustedWeight =
+        min(max(baseTypeface.weight + fontWeightAdjustment, FONT_WEIGHT_MIN), FONT_WEIGHT_MAX)
+    val italic = baseTypeface.style and Typeface.ITALIC != 0
+
+    return Typeface.create(baseTypeface, adjustedWeight, italic)
+  }
 }

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

@@ -92,6 +92,21 @@ public class TextAttributeProps private constructor() {
   public var isLineThroughTextDecorationSet: Boolean = false
     private set
 
+  /**
+   * Decoration color for underlines and strikethroughs. `Color.TRANSPARENT` (the default) means
+   * "fall back to the text color" so existing call sites that don't pass a value retain the prior
+   * behavior. Honored by `ReactUnderlineSpan` and `ReactStrikethroughSpan`.
+   */
+  internal var textDecorationColor: Int = android.graphics.Color.TRANSPARENT
+    private set
+
+  /**
+   * CSS `text-decoration-style`. Defaults to `SOLID` so existing call sites retain the prior visual
+   * behavior. Honored by `ReactUnderlineSpan` and `ReactStrikethroughSpan`.
+   */
+  internal var textDecorationStyle: TextDecorationStyle = TextDecorationStyle.SOLID
+    private set
+
   private var includeFontPadding: Boolean = true
 
   public var accessibilityRole: AccessibilityRole? = null
@@ -100,6 +115,11 @@ public class TextAttributeProps private constructor() {
   public var role: ReactAccessibilityDelegate.Role? = null
     private set
 
+  internal data class TextEffectEntry(val name: String, val props: String?)
+
+  internal var textEffects: List<TextEffectEntry> = emptyList()
+    private set
+
   public var fontStyle: Int = ReactConstants.UNSET
     private set
 
@@ -375,6 +395,9 @@ public class TextAttributeProps private constructor() {
     public const val TA_KEY_ROLE: Int = 26
     public const val TA_KEY_TEXT_TRANSFORM: Int = 27
     public const val TA_KEY_MAX_FONT_SIZE_MULTIPLIER: Int = 29
+    public const val TA_KEY_TEXT_EFFECTS: Int = 30
+    private const val TE_KEY_NAME: Int = 0
+    private const val TE_KEY_PROPS: Int = 1
 
     public const val UNSET: Int = -1
 
@@ -415,9 +438,10 @@ public class TextAttributeProps private constructor() {
           TA_KEY_LINE_HEIGHT -> result.lineHeight = entry.doubleValue.toFloat()
           TA_KEY_ALIGNMENT -> {}
           TA_KEY_BEST_WRITING_DIRECTION -> {}
-          TA_KEY_TEXT_DECORATION_COLOR -> {}
+          TA_KEY_TEXT_DECORATION_COLOR -> result.textDecorationColor = entry.intValue
           TA_KEY_TEXT_DECORATION_LINE -> result.setTextDecorationLine(entry.stringValue)
-          TA_KEY_TEXT_DECORATION_STYLE -> {}
+          TA_KEY_TEXT_DECORATION_STYLE ->
+              result.textDecorationStyle = TextDecorationStyle.fromString(entry.stringValue)
           TA_KEY_TEXT_SHADOW_RADIUS -> result.textShadowRadius = entry.doubleValue.toFloat()
           TA_KEY_TEXT_SHADOW_COLOR -> result.textShadowColor = entry.intValue
           TA_KEY_TEXT_SHADOW_OFFSET_DX -> result.textShadowOffsetDx = entry.doubleValue.toFloat()
@@ -429,6 +453,22 @@ public class TextAttributeProps private constructor() {
           TA_KEY_TEXT_TRANSFORM -> result.setTextTransform(entry.stringValue)
           TA_KEY_MAX_FONT_SIZE_MULTIPLIER ->
               result.maxFontSizeMultiplier = entry.doubleValue.toFloat()
+          TA_KEY_TEXT_EFFECTS -> {
+            val effectsMap = entry.mapBufferValue
+            val list = mutableListOf<TextEffectEntry>()
+            for (j in 0 until effectsMap.count) {
+              val effectMap = effectsMap.getMapBuffer(j)
+              list.add(
+                  TextEffectEntry(
+                      name = effectMap.getString(TE_KEY_NAME),
+                      props =
+                          if (effectMap.contains(TE_KEY_PROPS)) effectMap.getString(TE_KEY_PROPS)
+                          else null,
+                  )
+              )
+            }
+            result.textEffects = list
+          }
         }
       }
 
@@ -462,6 +502,10 @@ public class TextAttributeProps private constructor() {
       result.setFontVariant(getArrayProp(props, ViewProps.FONT_VARIANT))
       result.includeFontPadding = getBooleanProp(props, ViewProps.INCLUDE_FONT_PADDING, true)
       result.setTextDecorationLine(getStringProp(props, ViewProps.TEXT_DECORATION_LINE))
+      result.textDecorationColor =
+          getIntProp(props, "textDecorationColor", android.graphics.Color.TRANSPARENT)
+      result.textDecorationStyle =
+          TextDecorationStyle.fromString(getStringProp(props, "textDecorationStyle"))
       result.setTextShadowOffset(
           if (props.hasKey(PROP_SHADOW_OFFSET)) props.getMap(PROP_SHADOW_OFFSET) else null
       )
@@ -483,6 +527,8 @@ public class TextAttributeProps private constructor() {
         "justify" -> Gravity.LEFT
         null,
         "auto" -> Gravity.NO_GRAVITY
+        "start" -> if (isRTL) Gravity.RIGHT else Gravity.LEFT
+        "end" -> if (isRTL) Gravity.LEFT else Gravity.RIGHT
         "left" -> if (isRTL) Gravity.RIGHT else Gravity.LEFT
         "right" -> if (isRTL) Gravity.LEFT else Gravity.RIGHT
         "center" -> Gravity.CENTER_HORIZONTAL