react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -10,10 +10,10 @@ package com.facebook.react.views.text;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Rect;
-import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.text.Layout;
 import android.text.Spannable;
+import android.text.SpannableString;
 import android.text.Spanned;
 import android.text.TextUtils;
 import android.text.method.LinkMovementMethod;
@@ -30,6 +30,7 @@ import androidx.appcompat.widget.TintContextWrapper;
 import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.customview.widget.ExploreByTouchHelper;
+import com.facebook.react.views.common.UiModeUtils;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.infer.annotation.Nullsafe;
@@ -37,6 +38,7 @@ import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
 import com.facebook.react.common.build.ReactBuildConfig;
 import com.facebook.react.internal.SystraceSection;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
@@ -52,8 +54,8 @@ 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.ReactFragmentIndexSpan;
 import com.facebook.react.views.text.internal.span.ReactTagSpan;
-import com.facebook.react.views.text.internal.span.TextInlineImageSpan;
 import com.facebook.react.views.text.internal.span.TextInlineViewPlaceholderSpan;
 import com.facebook.yoga.YogaMeasureMode;
 
@@ -66,7 +68,6 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
   // https://github.com/aosp-mirror/platform_frameworks_base/blob/master/core/java/android/widget/TextView.java#L854
   private static final int DEFAULT_GRAVITY = Gravity.TOP | Gravity.START;
 
-  private boolean mContainsImages;
   private int mNumberOfLines;
   private @Nullable TextUtils.TruncateAt mEllipsizeLocation;
   private boolean mAdjustsFontSizeToFit;
@@ -79,6 +80,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
   private Overflow mOverflow = Overflow.VISIBLE;
 
   private @Nullable Spannable mSpanned;
+  private @Nullable PreparedLayout mPreparedLayout;
 
   public ReactTextView(Context context) {
     super(context);
@@ -102,6 +104,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     mLetterSpacing = 0.f;
     mOverflow = Overflow.VISIBLE;
     mSpanned = null;
+    mPreparedLayout = null;
   }
 
   /* package */ void recycleView() {
@@ -151,14 +154,38 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     //         mViewFlags = SOUND_EFFECTS_ENABLED | HAPTIC_FEEDBACK_ENABLED |
     // LAYOUT_DIRECTION_INHERIT;
     setEnabled(true);
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      setFocusable(View.FOCUSABLE_AUTO);
-    }
+    // Changed from FOCUSABLE_AUTO to NOT_FOCUSABLE to prevent Android TV's
+    // focus engine from landing on text views when no other views are available
+    setFocusable(View.NOT_FOCUSABLE);
 
     setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     updateView(); // call after changing ellipsizeLocation in particular
   }
 
+  // On Android TV, prevent text views from becoming focusable.
+  // ReactTextAnchorViewManager.setAccessible() ties isFocusable to the
+  // "accessible" prop, which causes Android TV's D-pad focus engine to land
+  // on text views inside recycled list items (FlashList), triggering
+  // requestChildFocus -> scrollToChild scroll jumps.
+  // On non-TV devices, focusability is left unchanged for accessibility.
+  @Override
+  public void setFocusable(boolean focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(false);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
+  @Override
+  public void setFocusable(int focusable) {
+    if (UiModeUtils.isTVDevice(getContext())) {
+      super.setFocusable(View.NOT_FOCUSABLE);
+    } else {
+      super.setFocusable(focusable);
+    }
+  }
+
   private static WritableMap inlineViewJson(
       int visibility, int index, int left, int top, int right, int bottom) {
     WritableMap json = Arguments.createMap();
@@ -235,6 +262,10 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     for (TextInlineViewPlaceholderSpan placeholder : placeholders) {
       View child = uiManager.resolveView(placeholder.getReactTag());
 
+      if (child == null) {
+        continue;
+      }
+
       int start = text.getSpanStart(placeholder);
       int line = layout.getLineForOffset(start);
       boolean isLineTruncated = layout.getEllipsisCount(line) > 0;
@@ -377,38 +408,21 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
 
   public void setText(ReactTextUpdate update) {
     try (SystraceSection s = new SystraceSection("ReactTextView.setText(ReactTextUpdate)")) {
-      mContainsImages = update.containsImages();
       // 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/facebook/react-native/pull/7011
       if (getLayoutParams() == null) {
         setLayoutParams(EMPTY_LAYOUT_PARAMS);
       }
-      Spannable spannable = update.getText();
+      Spanned spanned = update.getText();
       if (mLinkifyMaskType > 0) {
-        Linkify.addLinks(spannable, mLinkifyMaskType);
+        if (!(spanned instanceof Spannable)) {
+          spanned = new SpannableString(spanned);
+        }
+        Linkify.addLinks((Spannable) spanned, mLinkifyMaskType);
         setMovementMethod(LinkMovementMethod.getInstance());
       }
-      setText(spannable);
-      float paddingLeft = update.getPaddingLeft();
-      float paddingTop = update.getPaddingTop();
-      float paddingRight = update.getPaddingRight();
-      float paddingBottom = update.getPaddingBottom();
-
-      // In Fabric padding is set by the update of Layout Metrics and not as part of the "setText"
-      // operation
-      // TODO T56559197: remove this condition when we migrate 100% to Fabric
-      if (paddingLeft != ReactConstants.UNSET
-          && paddingTop != ReactConstants.UNSET
-          && paddingRight != ReactConstants.UNSET
-          && paddingBottom != ReactConstants.UNSET) {
-
-        setPadding(
-            (int) Math.floor(paddingLeft),
-            (int) Math.floor(paddingTop),
-            (int) Math.floor(paddingRight),
-            (int) Math.floor(paddingBottom));
-      }
+      setText(spanned);
 
       int nextTextAlign = update.getTextAlign();
       if (nextTextAlign != getGravityHorizontal()) {
@@ -463,74 +477,39 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
       // if no such span can be found we will send the textview's react id as a touch handler
       // In case when there are more than one spans with same length we choose the last one
       // from the spans[] array, since it correspond to the most inner react element
-      ReactTagSpan[] spans = spannedText.getSpans(index, index, ReactTagSpan.class);
-
-      if (spans != null) {
-        int targetSpanTextLength = text.length();
-        for (int i = 0; i < spans.length; i++) {
-          int spanStart = spannedText.getSpanStart(spans[i]);
-          int spanEnd = spannedText.getSpanEnd(spans[i]);
-          if (spanEnd >= index && (spanEnd - spanStart) <= targetSpanTextLength) {
-            target = spans[i].getReactTag();
-            targetSpanTextLength = (spanEnd - spanStart);
+      if (mPreparedLayout != null) {
+        ReactFragmentIndexSpan[] fragmentSpans =
+            spannedText.getSpans(index, index, ReactFragmentIndexSpan.class);
+
+        if (fragmentSpans != null) {
+          int targetSpanTextLength = text.length();
+          for (int i = 0; i < fragmentSpans.length; i++) {
+            int spanStart = spannedText.getSpanStart(fragmentSpans[i]);
+            int spanEnd = spannedText.getSpanEnd(fragmentSpans[i]);
+            if (spanEnd >= index && (spanEnd - spanStart) <= targetSpanTextLength) {
+              target = mPreparedLayout.getReactTags()[fragmentSpans[i].getFragmentIndex()];
+              targetSpanTextLength = (spanEnd - spanStart);
+            }
           }
         }
-      }
-    }
-
-    return target;
-  }
-
-  @Override
-  protected boolean verifyDrawable(Drawable drawable) {
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        if (span.getDrawable() == drawable) {
-          return true;
-        }
-      }
-    }
-    return super.verifyDrawable(drawable);
-  }
-
-  @Override
-  public void invalidateDrawable(Drawable drawable) {
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        if (span.getDrawable() == drawable) {
-          invalidate();
+      } else {
+        ReactTagSpan[] spans = spannedText.getSpans(index, index, ReactTagSpan.class);
+
+        if (spans != null) {
+          int targetSpanTextLength = text.length();
+          for (int i = 0; i < spans.length; i++) {
+            int spanStart = spannedText.getSpanStart(spans[i]);
+            int spanEnd = spannedText.getSpanEnd(spans[i]);
+            if (spanEnd >= index && (spanEnd - spanStart) <= targetSpanTextLength) {
+              target = spans[i].getReactTag();
+              targetSpanTextLength = (spanEnd - spanStart);
+            }
+          }
         }
       }
     }
-    super.invalidateDrawable(drawable);
-  }
-
-  @Override
-  public void onDetachedFromWindow() {
-    super.onDetachedFromWindow();
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        span.onDetachedFromWindow();
-      }
-    }
-  }
 
-  @Override
-  public void onStartTemporaryDetach() {
-    super.onStartTemporaryDetach();
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        span.onStartTemporaryDetach();
-      }
-    }
+    return target;
   }
 
   @Override
@@ -551,26 +530,6 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     } else {
       setTextIsSelectable(false);
     }
-
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        span.onAttachedToWindow();
-      }
-    }
-  }
-
-  @Override
-  public void onFinishTemporaryDetach() {
-    super.onFinishTemporaryDetach();
-    if (mContainsImages && getText() instanceof Spanned) {
-      Spanned text = (Spanned) getText();
-      TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);
-      for (TextInlineImageSpan span : spans) {
-        span.onFinishTemporaryDetach();
-      }
-    }
   }
 
   @Override
@@ -714,6 +673,22 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     return mSpanned;
   }
 
+  /**
+   * Get the PreparedLayout originally generated by the Fabric renderer, if using {@code
+   * enablePreparedTextLayout()}
+   *
+   * <p>TODO: Should be made internal when ReactTextView is converted to Kotlin
+   */
+  @UnstableReactNativeAPI
+  @Nullable
+  public PreparedLayout getPreparedLayout() {
+    return mPreparedLayout;
+  }
+
+  /* package */ void setPreparedLayout(@Nullable PreparedLayout preparedLayout) {
+    mPreparedLayout = preparedLayout;
+  }
+
   public void setLinkifyMask(int mask) {
     mLinkifyMaskType = mask;
   }

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

@@ -18,9 +18,11 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
 import androidx.core.view.accessibility.AccessibilityNodeProviderCompat
 import com.facebook.react.R
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.uimanager.ReactAccessibilityDelegate
 import com.facebook.react.views.text.internal.span.ReactClickableSpan
 
+@OptIn(UnstableReactNativeAPI::class)
 internal class ReactTextViewAccessibilityDelegate(
     view: View,
     originalFocus: Boolean,
@@ -154,6 +156,8 @@ internal class ReactTextViewAccessibilityDelegate(
   private fun getLayoutFromHost(): Layout? {
     return if (hostView is PreparedLayoutTextView) {
       (hostView as PreparedLayoutTextView).preparedLayout?.layout
+    } else if (hostView is ReactTextView && (hostView as ReactTextView).preparedLayout != null) {
+      (hostView as ReactTextView).preparedLayout?.layout
     } else if (hostView is TextView) {
       (hostView as TextView).layout
     } else {
@@ -171,6 +175,8 @@ internal class ReactTextViewAccessibilityDelegate(
     val host = hostView
     return if (host is PreparedLayoutTextView) {
       host.preparedLayout?.layout?.text as? Spanned
+    } else if (host is ReactTextView && host.preparedLayout != null) {
+      host.preparedLayout?.layout?.text as? Spanned
     } else if (host is TextView) {
       host.text as? Spanned
     } else {

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

@@ -5,37 +5,55 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+@file:Suppress("DEPRECATION")
+
 package com.facebook.react.views.text
 
 import android.os.Build
+import android.text.Layout
 import android.text.Spannable
+import android.text.SpannableString
+import android.text.Spanned
+import android.text.TextUtils
+import android.text.util.Linkify
+import android.view.Gravity
+import com.facebook.common.logging.FLog
 import com.facebook.react.R
+import com.facebook.react.common.ReactConstants
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.common.mapbuffer.MapBuffer
 import com.facebook.react.internal.SystraceSection
 import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.BackgroundStyleApplicator
+import com.facebook.react.uimanager.BaseViewManager
 import com.facebook.react.uimanager.IViewManagerWithChildren
+import com.facebook.react.uimanager.LayoutShadowNode
+import com.facebook.react.uimanager.LengthPercentage
+import com.facebook.react.uimanager.LengthPercentageType
 import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.ReferenceStateWrapper
 import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewDefaults
+import com.facebook.react.uimanager.ViewProps
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.views.text.internal.span.TextInlineImageSpan
+import com.facebook.react.uimanager.annotations.ReactPropGroup
+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 java.util.HashMap
 
-/**
- * Concrete class for [ReactTextAnchorViewManager] which represents view managers of anchor `<Text>`
- * nodes.
- */
-@Suppress("DEPRECATION")
+/** View manager for `<Text>` nodes. */
 @ReactModule(name = ReactTextViewManager.REACT_CLASS)
 @OptIn(UnstableReactNativeAPI::class)
-public class ReactTextViewManager
+public open class ReactTextViewManager
 @JvmOverloads
 public constructor(
     protected var reactTextViewManagerCallback: ReactTextViewManagerCallback? = null
 ) :
-    ReactTextAnchorViewManager<ReactTextShadowNode>(),
+    BaseViewManager<ReactTextView, LayoutShadowNode>(),
     IViewManagerWithChildren,
     ReactTextViewManagerCallback {
   init {
@@ -53,7 +71,7 @@ public constructor(
     if (preparedView != null) {
       // Resets background and borders
       preparedView.recycleView()
-      // Defaults from ReactTextAnchorViewManager
+      // Reset selection color to default
       setSelectionColor(preparedView, null)
     }
     return preparedView
@@ -75,17 +93,13 @@ public constructor(
   override fun updateExtraData(view: ReactTextView, extraData: Any) {
     SystraceSection("ReactTextViewManager.updateExtraData").use { s ->
       val update = extraData as ReactTextUpdate
-      val spannable: Spannable = update.text
-      @Suppress("DEPRECATION")
-      if (update.containsImages()) {
-        TextInlineImageSpan.possiblyUpdateInlineImageSpans(spannable, view)
-      }
+      val spanned: Spanned = update.text
       view.setText(update)
 
       // If this text view contains any clickable spans, set a view tag and reset the accessibility
       // delegate so that these can be picked up by the accessibility system.
       val accessibilityLinks: ReactTextViewAccessibilityDelegate.AccessibilityLinks =
-          ReactTextViewAccessibilityDelegate.AccessibilityLinks(spannable)
+          ReactTextViewAccessibilityDelegate.AccessibilityLinks(spanned)
       view.setTag(
           R.id.accessibility_links,
           if (accessibilityLinks.size() > 0) accessibilityLinks else null,
@@ -98,14 +112,13 @@ public constructor(
     }
   }
 
-  override fun createShadowNodeInstance(): ReactTextShadowNode =
-      ReactTextShadowNode(reactTextViewManagerCallback)
+  override fun createShadowNodeInstance(): LayoutShadowNode = LayoutShadowNode()
 
   public fun createShadowNodeInstance(
       reactTextViewManagerCallback: ReactTextViewManagerCallback?
-  ): ReactTextShadowNode = ReactTextShadowNode(reactTextViewManagerCallback)
+  ): LayoutShadowNode = LayoutShadowNode()
 
-  override fun getShadowNodeClass(): Class<ReactTextShadowNode> = ReactTextShadowNode::class.java
+  override fun getShadowNodeClass(): Class<LayoutShadowNode> = LayoutShadowNode::class.java
 
   override fun onAfterUpdateTransaction(view: ReactTextView) {
     super.onAfterUpdateTransaction(view)
@@ -120,6 +133,11 @@ public constructor(
       stateWrapper: StateWrapper,
   ): Any? {
     SystraceSection("ReactTextViewManager.updateState").use { s ->
+      val refState = (stateWrapper as? ReferenceStateWrapper)?.stateDataReference
+      if (refState is PreparedLayout) {
+        return getReactTextUpdateFromPreparedLayout(view, refState)
+      }
+
       val stateMapBuffer = stateWrapper.stateDataMapBuffer
       return if (stateMapBuffer != null) {
         getReactTextUpdate(view, props, stateMapBuffer)
@@ -149,6 +167,9 @@ public constructor(
         paragraphAttributes.getDouble(TextLayoutManager.PA_KEY_MINIMUM_FONT_SIZE).toFloat()
     view.setMinimumFontSize(minimumFontSize)
 
+    // Clear any stale PreparedLayout from a previous update
+    view.setPreparedLayout(null)
+
     val textBreakStrategy =
         TextAttributeProps.getTextBreakStrategy(
             paragraphAttributes.getString(TextLayoutManager.PA_KEY_TEXT_BREAK_STRATEGY)
@@ -159,13 +180,41 @@ public constructor(
     return ReactTextUpdate(
         spanned,
         -1, // UNUSED FOR TEXT
-        false, // TODO add this into local Data
         TextLayoutManager.getTextGravity(attributedString, spanned),
         textBreakStrategy,
         TextAttributeProps.getJustificationMode(props, currentJustificationMode),
     )
   }
 
+  /**
+   * Constructs a [ReactTextUpdate] from a [PreparedLayout] received via [ReferenceStateWrapper].
+   */
+  private fun getReactTextUpdateFromPreparedLayout(
+      view: ReactTextView,
+      preparedLayout: PreparedLayout,
+  ): ReactTextUpdate {
+    val layout = preparedLayout.layout
+    val text = layout.text
+    val spanned = if (text is Spannable) text else SpannableString(text)
+    view.setSpanned(spanned)
+    view.setPreparedLayout(preparedLayout)
+
+    val textAlign =
+        when (layout.alignment) {
+          Layout.Alignment.ALIGN_CENTER -> Gravity.CENTER_HORIZONTAL
+          Layout.Alignment.ALIGN_OPPOSITE -> Gravity.END
+          else -> Gravity.START
+        }
+
+    return ReactTextUpdate(
+        spanned,
+        -1,
+        textAlign,
+        preparedLayout.textBreakStrategy,
+        preparedLayout.justificationMode,
+    )
+  }
+
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any>? {
     val baseEventTypeConstants = super.getExportedCustomDirectEventTypeConstants()
     val eventTypeConstants = baseEventTypeConstants ?: HashMap()
@@ -186,6 +235,180 @@ public constructor(
     view.setOverflow(overflow)
   }
 
+  @ReactProp(name = "accessible")
+  public fun setAccessible(view: ReactTextView, accessible: Boolean) {
+    view.isFocusable = accessible
+  }
+
+  // maxLines can only be set in master view (block), doesn't really make sense to set in a span
+  @ReactProp(name = ViewProps.NUMBER_OF_LINES, defaultInt = ViewDefaults.NUMBER_OF_LINES)
+  public fun setNumberOfLines(view: ReactTextView, numberOfLines: Int) {
+    view.setNumberOfLines(numberOfLines)
+  }
+
+  @ReactProp(name = ViewProps.ELLIPSIZE_MODE)
+  public fun setEllipsizeMode(view: ReactTextView, ellipsizeMode: String?) {
+    when (ellipsizeMode) {
+      null,
+      "tail" -> view.setEllipsizeLocation(TextUtils.TruncateAt.END)
+      "head" -> view.setEllipsizeLocation(TextUtils.TruncateAt.START)
+      "middle" -> view.setEllipsizeLocation(TextUtils.TruncateAt.MIDDLE)
+      "clip" -> view.setEllipsizeLocation(null)
+      else -> {
+        FLog.w(ReactConstants.TAG, "Invalid ellipsizeMode: $ellipsizeMode")
+        view.setEllipsizeLocation(TextUtils.TruncateAt.END)
+      }
+    }
+  }
+
+  @ReactProp(name = ViewProps.ADJUSTS_FONT_SIZE_TO_FIT)
+  public fun setAdjustFontSizeToFit(view: ReactTextView, adjustsFontSizeToFit: Boolean) {
+    view.setAdjustFontSizeToFit(adjustsFontSizeToFit)
+  }
+
+  @ReactProp(name = ViewProps.FONT_SIZE)
+  public fun setFontSize(view: ReactTextView, fontSize: Float) {
+    view.setFontSize(fontSize)
+  }
+
+  @ReactProp(name = ViewProps.LETTER_SPACING, defaultFloat = 0f)
+  public fun setLetterSpacing(view: ReactTextView, letterSpacing: Float) {
+    view.letterSpacing = letterSpacing
+  }
+
+  @ReactProp(name = ViewProps.TEXT_ALIGN_VERTICAL)
+  public fun setTextAlignVertical(view: ReactTextView, textAlignVertical: String?) {
+    when (textAlignVertical) {
+      null,
+      "auto" -> view.setGravityVertical(Gravity.NO_GRAVITY)
+      "top" -> view.setGravityVertical(Gravity.TOP)
+      "bottom" -> view.setGravityVertical(Gravity.BOTTOM)
+      "center" -> view.setGravityVertical(Gravity.CENTER_VERTICAL)
+      else -> {
+        FLog.w(ReactConstants.TAG, "Invalid textAlignVertical: $textAlignVertical")
+        view.setGravityVertical(Gravity.NO_GRAVITY)
+      }
+    }
+  }
+
+  @ReactProp(name = "selectable")
+  public fun setSelectable(view: ReactTextView, isSelectable: Boolean) {
+    view.setTextIsSelectable(isSelectable)
+  }
+
+  @ReactProp(name = "selectionColor", customType = "Color")
+  public fun setSelectionColor(view: ReactTextView, color: Int?) {
+    view.highlightColor = color ?: getDefaultTextColorHighlight(view.context)
+  }
+
+  @ReactProp(name = "android_hyphenationFrequency")
+  public fun setAndroidHyphenationFrequency(view: ReactTextView, frequency: String?) {
+    when (frequency) {
+      null,
+      "none" -> view.hyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE
+      "full" -> view.hyphenationFrequency = Layout.HYPHENATION_FREQUENCY_FULL
+      "normal" -> view.hyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NORMAL
+      else -> {
+        FLog.w(ReactConstants.TAG, "Invalid android_hyphenationFrequency: $frequency")
+        view.hyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE
+      }
+    }
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              ViewProps.BORDER_RADIUS,
+              ViewProps.BORDER_TOP_LEFT_RADIUS,
+              ViewProps.BORDER_TOP_RIGHT_RADIUS,
+              ViewProps.BORDER_BOTTOM_RIGHT_RADIUS,
+              ViewProps.BORDER_BOTTOM_LEFT_RADIUS,
+          ],
+      defaultFloat = Float.NaN,
+  )
+  public fun setBorderRadius(view: ReactTextView, index: Int, borderRadius: Float) {
+    val radius =
+        if (borderRadius.isNaN()) {
+          null
+        } else {
+          LengthPercentage(borderRadius, LengthPercentageType.POINT)
+        }
+    BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius)
+  }
+
+  @ReactProp(name = "borderStyle")
+  public fun setBorderStyle(view: ReactTextView, borderStyle: String?) {
+    val parsedBorderStyle = if (borderStyle == null) null else fromString(borderStyle)
+    BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle)
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              ViewProps.BORDER_WIDTH,
+              ViewProps.BORDER_LEFT_WIDTH,
+              ViewProps.BORDER_RIGHT_WIDTH,
+              ViewProps.BORDER_TOP_WIDTH,
+              ViewProps.BORDER_BOTTOM_WIDTH,
+              ViewProps.BORDER_START_WIDTH,
+              ViewProps.BORDER_END_WIDTH,
+          ],
+      defaultFloat = Float.NaN,
+  )
+  public fun setBorderWidth(view: ReactTextView, index: Int, width: Float) {
+    BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width)
+  }
+
+  @ReactPropGroup(
+      names =
+          [
+              "borderColor",
+              "borderLeftColor",
+              "borderRightColor",
+              "borderTopColor",
+              "borderBottomColor",
+          ],
+      customType = "Color",
+  )
+  public fun setBorderColor(view: ReactTextView, index: Int, color: Int?) {
+    BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.values()[index], color)
+  }
+
+  @ReactProp(name = ViewProps.INCLUDE_FONT_PADDING, defaultBoolean = true)
+  public fun setIncludeFontPadding(view: ReactTextView, includepad: Boolean) {
+    view.includeFontPadding = includepad
+  }
+
+  @ReactProp(name = "disabled", defaultBoolean = false)
+  public fun setDisabled(view: ReactTextView, disabled: Boolean) {
+    view.isEnabled = !disabled
+  }
+
+  @ReactProp(name = "dataDetectorType")
+  public fun setDataDetectorType(view: ReactTextView, type: String?) {
+    when (type) {
+      "phoneNumber" -> {
+        view.setLinkifyMask(Linkify.PHONE_NUMBERS)
+        return
+      }
+      "link" -> {
+        view.setLinkifyMask(Linkify.WEB_URLS)
+        return
+      }
+      "email" -> {
+        view.setLinkifyMask(Linkify.EMAIL_ADDRESSES)
+        return
+      }
+      "all" -> {
+        @Suppress("DEPRECATION") view.setLinkifyMask(Linkify.ALL)
+        return
+      }
+    }
+
+    // "none" case, default, and null type are equivalent.
+    view.setLinkifyMask(0)
+  }
+
   public companion object {
     private const val TX_STATE_KEY_ATTRIBUTED_STRING: Short = 0
     private const val TX_STATE_KEY_PARAGRAPH_ATTRIBUTES: Short = 1