react-native-tvos 0.76.2-0 → 0.77.0-0rc1

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

@@ -0,0 +1,153 @@
+/*
+ * 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.swiperefresh
+
+import android.graphics.Color
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.facebook.react.bridge.ColorPropConverter
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.ViewProps
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.AndroidSwipeRefreshLayoutManagerDelegate
+import com.facebook.react.viewmanagers.AndroidSwipeRefreshLayoutManagerInterface
+import java.util.HashMap
+
+/**
+ * ViewManager for [ReactSwipeRefreshLayout] which allows the user to "pull to refresh" a child
+ * view. Emits an `onRefresh` event when this happens.
+ */
+@ReactModule(name = SwipeRefreshLayoutManager.REACT_CLASS)
+internal open class SwipeRefreshLayoutManager :
+    ViewGroupManager<ReactSwipeRefreshLayout>(),
+    AndroidSwipeRefreshLayoutManagerInterface<ReactSwipeRefreshLayout> {
+
+  private val delegate: ViewManagerDelegate<ReactSwipeRefreshLayout> =
+      AndroidSwipeRefreshLayoutManagerDelegate(this)
+
+  override fun createViewInstance(reactContext: ThemedReactContext): ReactSwipeRefreshLayout =
+      ReactSwipeRefreshLayout(reactContext)
+
+  override fun getName(): String = REACT_CLASS
+
+  @ReactProp(name = ViewProps.ENABLED, defaultBoolean = true)
+  override fun setEnabled(view: ReactSwipeRefreshLayout, enabled: Boolean) {
+    view.isEnabled = enabled
+  }
+
+  @ReactProp(name = "colors", customType = "ColorArray")
+  override fun setColors(view: ReactSwipeRefreshLayout, colors: ReadableArray?) {
+    if (colors != null) {
+      val colorValues = IntArray(colors.size())
+      for (i in 0..<colors.size()) {
+        if (colors.getType(i) == ReadableType.Map) {
+          colorValues[i] = ColorPropConverter.getColor(colors.getMap(i), view.context)
+        } else {
+          colorValues[i] = colors.getInt(i)
+        }
+      }
+      view.setColorSchemeColors(*colorValues)
+    } else {
+      view.setColorSchemeColors()
+    }
+  }
+
+  @ReactProp(name = "progressBackgroundColor", customType = "Color")
+  override fun setProgressBackgroundColor(view: ReactSwipeRefreshLayout, color: Int?) {
+    view.setProgressBackgroundColorSchemeColor(color ?: Color.TRANSPARENT)
+  }
+
+  // TODO(T46143833): Remove this method once the 'size' prop has been migrated to String in JS.
+  fun setSize(view: ReactSwipeRefreshLayout, value: Int): Unit {
+    view.setSize(value)
+  }
+
+  override fun setSize(view: ReactSwipeRefreshLayout, size: String?) {
+    if (size == null || size.equals("default")) {
+      view.setSize(SwipeRefreshLayout.DEFAULT)
+    } else if (size.equals("large")) {
+      view.setSize(SwipeRefreshLayout.LARGE)
+    } else {
+      throw IllegalArgumentException("Size must be 'default' or 'large', received: $size")
+    }
+  }
+
+  // This prop temporarily takes both 0 and 1 as well as 'default' and 'large'.
+  // 0 and 1 are deprecated and will be removed in a future release.
+  // See T46143833
+  @ReactProp(name = "size")
+  fun setSize(view: ReactSwipeRefreshLayout, size: Dynamic): Unit {
+    when {
+      size.isNull -> view.setSize(SwipeRefreshLayout.DEFAULT)
+      size.type == ReadableType.Number -> view.setSize(size.asInt())
+      size.type == ReadableType.String -> this.setSize(view, size.asString())
+      else -> throw IllegalArgumentException("Size must be 'default' or 'large'")
+    }
+  }
+
+  @ReactProp(name = "refreshing")
+  override fun setRefreshing(view: ReactSwipeRefreshLayout, refreshing: Boolean) {
+    view.isRefreshing = refreshing
+  }
+
+  @ReactProp(name = "progressViewOffset", defaultFloat = 0f)
+  override fun setProgressViewOffset(view: ReactSwipeRefreshLayout, offset: Float) {
+    view.setProgressViewOffset(offset)
+  }
+
+  override fun setNativeRefreshing(view: ReactSwipeRefreshLayout, value: Boolean) {
+    setRefreshing(view, value)
+  }
+
+  override fun addEventEmitters(reactContext: ThemedReactContext, view: ReactSwipeRefreshLayout) {
+    view.setOnRefreshListener {
+      val eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, view.id)
+      eventDispatcher?.dispatchEvent(RefreshEvent(UIManagerHelper.getSurfaceId(view), view.id))
+    }
+  }
+
+  override fun receiveCommand(
+      root: ReactSwipeRefreshLayout,
+      commandId: String,
+      args: ReadableArray?
+  ) {
+    when (commandId) {
+      "setNativeRefreshing" ->
+          if (args != null) {
+            setRefreshing(root, args.getBoolean(0))
+          }
+      else -> {}
+    }
+  }
+
+  override fun getExportedViewConstants(): MutableMap<String, Any> =
+      mutableMapOf(
+          "SIZE" to
+              mutableMapOf(
+                  "DEFAULT" to SwipeRefreshLayout.DEFAULT, "LARGE" to SwipeRefreshLayout.LARGE))
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
+    val baseEventTypeConstants = super.getExportedCustomDirectEventTypeConstants()
+    val eventTypeConstants: MutableMap<String, Any> = baseEventTypeConstants ?: HashMap()
+    eventTypeConstants.putAll(
+        mutableMapOf("topRefresh" to mutableMapOf("registrationName" to "onRefresh")))
+    return eventTypeConstants
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<ReactSwipeRefreshLayout> = delegate
+
+  companion object {
+    const val REACT_CLASS: String = "AndroidSwipeRefreshLayout"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/ReactSwitchManager.java

@@ -11,6 +11,7 @@ package com.facebook.react.views.switchview;
 import android.content.Context;
 import android.view.View;
 import android.widget.CompoundButton;
+import androidx.annotation.ColorInt;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.react.bridge.ReactContext;
@@ -117,6 +118,11 @@ public class ReactSwitchManager extends SimpleViewManager<ReactSwitch>
     return view;
   }
 
+  @Override
+  public void setBackgroundColor(ReactSwitch view, @ColorInt int backgroundColor) {
+    view.setBackgroundColor(backgroundColor);
+  }
+
   @Override
   @ReactProp(name = "disabled", defaultBoolean = false)
   public void setDisabled(ReactSwitch view, boolean disabled) {

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

@@ -0,0 +1,72 @@
+/*
+ * 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.content.Context
+import android.graphics.Rect
+import android.text.Layout
+import android.text.TextPaint
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+
+public object FontMetricsUtil {
+
+  private const val CAP_HEIGHT_MEASUREMENT_TEXT = "T"
+  private const val X_HEIGHT_MEASUREMENT_TEXT = "x"
+  private const val AMPLIFICATION_FACTOR = 100f
+
+  @JvmStatic
+  public fun getFontMetrics(
+      text: CharSequence,
+      layout: Layout,
+      paint: TextPaint,
+      context: Context
+  ): WritableArray {
+    val dm = context.resources.displayMetrics
+    val lines = Arguments.createArray()
+
+    // To calculate xHeight and capHeight we have to render an "x" and "T" and manually measure
+    // their height. In order to get more precision than Android offers, we blow up the text size by
+    // 100 and
+    // measure it. Luckily, text size affects rendering linearly, so we can do this trick.
+    val paintCopy = TextPaint(paint).apply { textSize *= AMPLIFICATION_FACTOR }
+
+    val capHeightBounds = Rect()
+    paintCopy.getTextBounds(
+        CAP_HEIGHT_MEASUREMENT_TEXT, 0, CAP_HEIGHT_MEASUREMENT_TEXT.length, capHeightBounds)
+    val capHeight = capHeightBounds.height() / AMPLIFICATION_FACTOR / dm.density
+
+    val xHeightBounds = Rect()
+    paintCopy.getTextBounds(
+        X_HEIGHT_MEASUREMENT_TEXT, 0, X_HEIGHT_MEASUREMENT_TEXT.length, xHeightBounds)
+    val xHeight = xHeightBounds.height() / AMPLIFICATION_FACTOR / dm.density
+
+    for (i in 0 until layout.lineCount) {
+      val endsWithNewLine = text.isNotEmpty() && text[layout.getLineEnd(i) - 1] == '\n'
+      val lineWidth = if (endsWithNewLine) layout.getLineMax(i) else layout.getLineWidth(i)
+      val bounds = Rect()
+      layout.getLineBounds(i, bounds)
+      val line =
+          Arguments.createMap().apply {
+            putDouble("x", (layout.getLineLeft(i) / dm.density).toDouble())
+            putDouble("y", (bounds.top / dm.density).toDouble())
+            putDouble("width", (lineWidth / dm.density).toDouble())
+            putDouble("height", (bounds.height() / dm.density).toDouble())
+            putDouble("descender", (layout.getLineDescent(i) / dm.density).toDouble())
+            putDouble("ascender", (-layout.getLineAscent(i) / dm.density).toDouble())
+            putDouble("baseline", (layout.getLineBaseline(i) / dm.density).toDouble())
+            putDouble("capHeight", capHeight.toDouble())
+            putDouble("xHeight", xHeight.toDouble())
+            putString(
+                "text", text.subSequence(layout.getLineStart(i), layout.getLineEnd(i)).toString())
+          }
+      lines.pushMap(line)
+    }
+    return lines
+  }
+}

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

@@ -21,6 +21,7 @@ import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.LayoutShadowNode;
 import com.facebook.react.uimanager.NativeViewHierarchyOptimizer;
@@ -34,6 +35,7 @@ import com.facebook.react.views.text.internal.ReactTextInlineImageShadowNode;
 import com.facebook.react.views.text.internal.span.CustomLetterSpacingSpan;
 import com.facebook.react.views.text.internal.span.CustomLineHeightSpan;
 import com.facebook.react.views.text.internal.span.CustomStyleSpan;
+import com.facebook.react.views.text.internal.span.LegacyLineHeightSpan;
 import com.facebook.react.views.text.internal.span.ReactAbsoluteSizeSpan;
 import com.facebook.react.views.text.internal.span.ReactBackgroundColorSpan;
 import com.facebook.react.views.text.internal.span.ReactClickableSpan;
@@ -229,7 +231,11 @@ public abstract class ReactBaseTextShadowNode extends LayoutShadowNode {
       if (!Float.isNaN(effectiveLineHeight)
           && (parentTextAttributes == null
               || parentTextAttributes.getEffectiveLineHeight() != effectiveLineHeight)) {
-        ops.add(new SetSpanOperation(start, end, new CustomLineHeightSpan(effectiveLineHeight)));
+        if (ReactNativeFeatureFlags.enableAndroidLineHeightCentering()) {
+          ops.add(new SetSpanOperation(start, end, new CustomLineHeightSpan(effectiveLineHeight)));
+        } else {
+          ops.add(new SetSpanOperation(start, end, new LegacyLineHeightSpan(effectiveLineHeight)));
+        }
       }
       ops.add(new SetSpanOperation(start, end, new ReactTagSpan(textShadowNode.getReactTag())));
     }

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

@@ -0,0 +1,60 @@
+/*
+ * 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.content.Context
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import com.facebook.react.common.assets.ReactFontManager as ReactFontAssetManager
+
+/** Responsible for loading and caching Typeface objects. */
+@Deprecated(
+    message =
+        "This class is deprecated and will be deleted in the near future. Please use [com.facebook.react.common.assets.ReactFontManager] instead.")
+@Suppress("DEPRECATION")
+public class ReactFontManager private constructor(private val delegate: ReactFontAssetManager) {
+
+  public fun getTypeface(fontFamilyName: String, style: Int, assetManager: AssetManager): Typeface =
+      delegate.getTypeface(fontFamilyName, style, assetManager)
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      weight: Int,
+      italic: Boolean,
+      assetManager: AssetManager
+  ): Typeface = delegate.getTypeface(fontFamilyName, weight, italic, assetManager)
+
+  public fun getTypeface(
+      fontFamilyName: String,
+      style: Int,
+      weight: Int,
+      assetManager: AssetManager
+  ): Typeface = delegate.getTypeface(fontFamilyName, style, weight, assetManager)
+
+  public fun addCustomFont(context: Context, fontFamily: String, fontId: Int) {
+    delegate.addCustomFont(context, fontFamily, fontId)
+  }
+
+  public fun addCustomFont(fontFamily: String, font: Typeface?) {
+    delegate.addCustomFont(fontFamily, font)
+  }
+
+  public fun setTypeface(fontFamilyName: String, style: Int, typeface: Typeface) {
+    delegate.setTypeface(fontFamilyName, style, typeface)
+  }
+
+  public companion object {
+    private var instance: ReactFontManager? = null
+
+    @JvmStatic
+    public fun getInstance(): ReactFontManager {
+      return instance
+          ?: ReactFontManager(ReactFontAssetManager.getInstance()).also { instance = it }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * 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.view.View
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * Manages raw text nodes (aka `textContent` in terms of DOM). Since they are used only as a virtual
+ * nodes, any type of native view operation will throw an [IllegalStateException].
+ */
+@ReactModule(name = ReactRawTextManager.REACT_CLASS)
+public class ReactRawTextManager : ViewManager<View, ReactRawTextShadowNode>() {
+
+  override public fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override public fun createViewInstance(context: ThemedReactContext): ReactTextView =
+      throw IllegalStateException("Attempt to create a native view for RCTRawText")
+
+  override protected fun prepareToRecycleView(reactContext: ThemedReactContext, view: View): View? =
+      throw IllegalStateException("Attempt to recycle a native view for RCTRawText")
+
+  override public fun updateExtraData(view: View, extraData: Any): Unit = Unit
+
+  override public fun getShadowNodeClass(): Class<ReactRawTextShadowNode> {
+    return ReactRawTextShadowNode::class.java
+  }
+
+  override public fun createShadowNodeInstance(): ReactRawTextShadowNode {
+    return ReactRawTextShadowNode()
+  }
+
+  internal companion object {
+    public const val REACT_CLASS: String = "RCTRawText"
+  }
+}

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

@@ -13,17 +13,13 @@ import android.text.TextUtils;
 import android.text.util.Linkify;
 import android.view.Gravity;
 import android.view.View;
-import androidx.annotation.ColorInt;
 import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
-import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.common.ReactConstants;
-import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.uimanager.BackgroundStyleApplicator;
 import com.facebook.react.uimanager.BaseViewManager;
 import com.facebook.react.uimanager.LengthPercentage;
 import com.facebook.react.uimanager.LengthPercentageType;
-import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.Spacing;
 import com.facebook.react.uimanager.ViewDefaults;
 import com.facebook.react.uimanager.ViewProps;
@@ -153,36 +149,20 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
       },
       defaultFloat = Float.NaN)
   public void setBorderRadius(ReactTextView view, int index, float borderRadius) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      LengthPercentage radius =
-          Float.isNaN(borderRadius)
-              ? null
-              : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
-      BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
-    } else {
-      if (!Float.isNaN(borderRadius)) {
-        borderRadius = PixelUtil.toPixelFromDIP(borderRadius);
-      }
-
-      if (index == 0) {
-        view.setBorderRadius(borderRadius);
-      } else {
-        view.setBorderRadius(borderRadius, index - 1);
-      }
-    }
+    @Nullable
+    LengthPercentage radius =
+        Float.isNaN(borderRadius)
+            ? null
+            : new LengthPercentage(borderRadius, LengthPercentageType.POINT);
+    BackgroundStyleApplicator.setBorderRadius(view, BorderRadiusProp.values()[index], radius);
   }
 
   @ReactProp(name = "borderStyle")
   public void setBorderStyle(ReactTextView view, @Nullable String borderStyle) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      @Nullable
-      BorderStyle parsedBorderStyle =
-          borderStyle == null ? null : BorderStyle.fromString(borderStyle);
-      BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
-    } else {
-      view.setBorderStyle(borderStyle);
-    }
+    @Nullable
+    BorderStyle parsedBorderStyle =
+        borderStyle == null ? null : BorderStyle.fromString(borderStyle);
+    BackgroundStyleApplicator.setBorderStyle(view, parsedBorderStyle);
   }
 
   @ReactPropGroup(
@@ -197,14 +177,7 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
       },
       defaultFloat = Float.NaN)
   public void setBorderWidth(ReactTextView view, int index, float width) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
-    } else {
-      if (!Float.isNaN(width)) {
-        width = PixelUtil.toPixelFromDIP(width);
-      }
-      view.setBorderWidth(SPACING_TYPES[index], width);
-    }
+    BackgroundStyleApplicator.setBorderWidth(view, LogicalEdge.values()[index], width);
   }
 
   @ReactPropGroup(
@@ -217,11 +190,7 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
       },
       customType = "Color")
   public void setBorderColor(ReactTextView view, int index, @Nullable Integer color) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
-    } else {
-      view.setBorderColor(SPACING_TYPES[index], color);
-    }
+    BackgroundStyleApplicator.setBorderColor(view, LogicalEdge.ALL, color);
   }
 
   @ReactProp(name = ViewProps.INCLUDE_FONT_PADDING, defaultBoolean = true)
@@ -261,20 +230,4 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
   public void setNotifyOnInlineViewLayout(ReactTextView view, boolean notifyOnInlineViewLayout) {
     view.setNotifyOnInlineViewLayout(notifyOnInlineViewLayout);
   }
-
-  @ReactProp(name = ViewProps.BOX_SHADOW, customType = "BoxShadow")
-  public void setBoxShadow(ReactTextView view, @Nullable ReadableArray shadows) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBoxShadow(view, shadows);
-    }
-  }
-
-  @Override
-  public void setBackgroundColor(T view, @ColorInt int backgroundColor) {
-    if (ReactNativeFeatureFlags.enableBackgroundStyleApplicator()) {
-      BackgroundStyleApplicator.setBackgroundColor(view, backgroundColor);
-    } else {
-      super.setBackgroundColor(view, backgroundColor);
-    }
-  }
 }

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

@@ -270,6 +270,10 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
               .setBreakStrategy(mTextBreakStrategy)
               .setHyphenationFrequency(mHyphenationFrequency);
 
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        builder.setJustificationMode(mJustificationMode);
+      }
+
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
         builder.setUseLineSpacingFromFallbacks(true);
       }

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

@@ -0,0 +1,92 @@
+/*
+ * 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.Spannable
+import com.facebook.react.common.ReactConstants
+
+/**
+ * Class that contains the data needed for a text update. Used by both <Text/> and <TextInput/>
+ * VisibleForTesting from [TextInputEventsTestCase].
+ */
+public class ReactTextUpdate(
+    public val text: Spannable,
+    public val jsEventCounter: Int,
+    public val containsImages: Boolean,
+    public val paddingLeft: Float,
+    public val paddingTop: Float,
+    public val paddingRight: Float,
+    public val paddingBottom: Float,
+    public val textAlign: Int,
+    public val textBreakStrategy: Int,
+    public val justificationMode: Int
+) {
+
+  /**
+   * @deprecated Use a non-deprecated constructor for ReactTextUpdate instead. This one remains
+   *   because it's being used by a unit test that isn't currently open source.
+   */
+  public constructor(
+      text: Spannable,
+      jsEventCounter: Int,
+      containsImages: Boolean,
+      paddingStart: Float,
+      paddingTop: Float,
+      paddingEnd: Float,
+      paddingBottom: Float,
+      textAlign: Int
+  ) : this(
+      text,
+      jsEventCounter,
+      containsImages,
+      paddingStart,
+      paddingTop,
+      paddingEnd,
+      paddingBottom,
+      textAlign,
+      Layout.BREAK_STRATEGY_HIGH_QUALITY,
+      Layout.JUSTIFICATION_MODE_NONE)
+
+  public constructor(
+      text: Spannable,
+      jsEventCounter: Int,
+      containsImages: Boolean,
+      textAlign: Int,
+      textBreakStrategy: Int,
+      justificationMode: Int
+  ) : this(
+      text,
+      jsEventCounter,
+      containsImages,
+      ReactConstants.UNSET.toFloat(),
+      ReactConstants.UNSET.toFloat(),
+      ReactConstants.UNSET.toFloat(),
+      ReactConstants.UNSET.toFloat(),
+      textAlign,
+      textBreakStrategy,
+      justificationMode)
+
+  @Deprecated(
+      "This is just for backwards compatibility and will be removed some time in the future",
+      ReplaceWith("containsImages"))
+  public fun containsImages(): Boolean = containsImages
+
+  public companion object {
+    @JvmStatic
+    public fun buildReactTextUpdateFromState(
+        text: Spannable,
+        jsEventCounter: Int,
+        textAlign: Int,
+        textBreakStrategy: Int,
+        justificationMode: Int
+    ): ReactTextUpdate =
+        ReactTextUpdate(
+            text, jsEventCounter, false, textAlign, textBreakStrategy, justificationMode)
+  }
+}