react-native 0.0.0-17be3a003 → 0.0.0-18697adec

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

@@ -12,9 +12,10 @@ import android.graphics.Paint;
 import android.graphics.Typeface;
 import android.text.TextPaint;
 import android.text.style.MetricAffectingSpan;
-import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import com.facebook.infer.annotation.Nullsafe;
 
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class CustomStyleSpan extends MetricAffectingSpan implements ReactSpan {
 
   /**
@@ -40,7 +41,7 @@ public class CustomStyleSpan extends MetricAffectingSpan implements ReactSpan {
       int fontWeight,
       @Nullable String fontFeatureSettings,
       @Nullable String fontFamily,
-      @NonNull AssetManager assetManager) {
+      AssetManager assetManager) {
     mStyle = fontStyle;
     mWeight = fontWeight;
     mFeatureSettings = fontFeatureSettings;
@@ -54,21 +55,18 @@ public class CustomStyleSpan extends MetricAffectingSpan implements ReactSpan {
   }
 
   @Override
-  public void updateMeasureState(@NonNull TextPaint paint) {
+  public void updateMeasureState(TextPaint paint) {
     apply(paint, mStyle, mWeight, mFeatureSettings, mFontFamily, mAssetManager);
   }
 
-  /** Returns {@link Typeface#NORMAL} or {@link Typeface#ITALIC}. */
   public int getStyle() {
-    return (mStyle == ReactTextShadowNode.UNSET ? 0 : mStyle);
+    return mStyle == ReactBaseTextShadowNode.UNSET ? Typeface.NORMAL : mStyle;
   }
 
-  /** Returns {@link Typeface#NORMAL} or {@link Typeface#BOLD}. */
   public int getWeight() {
-    return (mWeight == ReactTextShadowNode.UNSET ? 0 : mWeight);
+    return mWeight == ReactBaseTextShadowNode.UNSET ? TypefaceStyle.NORMAL : mWeight;
   }
 
-  /** Returns the font family set for this StyleSpan. */
   public @Nullable String getFontFamily() {
     return mFontFamily;
   }

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

@@ -10,31 +10,39 @@ package com.facebook.react.views.text;
 import android.content.Context;
 import android.content.res.AssetManager;
 import android.graphics.Typeface;
-import android.os.Build;
 import android.util.SparseArray;
-import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.content.res.ResourcesCompat;
+import com.facebook.infer.annotation.Nullsafe;
 import java.util.HashMap;
 import java.util.Map;
 
 /**
- * Class responsible to load and cache Typeface objects. It will first try to load typefaces inside
- * the assets/fonts folder and if it doesn't find the right Typeface in that folder will fall back
- * on the best matching system Typeface The supported custom fonts extensions are .ttf and .otf. For
- * each font family the bold, italic and bold_italic variants are supported. Given a "family" font
- * family the files in the assets/fonts folder need to be family.ttf(.otf) family_bold.ttf(.otf)
- * family_italic.ttf(.otf) and family_bold_italic.ttf(.otf)
+ * Responsible for loading and caching Typeface objects.
+ *
+ * <p>This will first try to load a typeface from the assets/fonts folder. If one is not found in
+ * that folder, this will fallback to the best matching system typeface.
+ *
+ * <p>Custom fonts support the extensions `.ttf` and `.otf` and the variants `bold`, `italic`, and
+ * `bold_italic`. For example, given a font named "ExampleFontFamily", the following are supported:
+ *
+ * <ul>
+ *   <li>ExampleFontFamily.ttf (or .otf)
+ *   <li>ExampleFontFamily_bold.ttf (or .otf)
+ *   <li>ExampleFontFamily_italic.ttf (or .otf)
+ *   <li>ExampleFontFamily_bold_italic.ttf (or .otf)
  */
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class ReactFontManager {
 
+  // NOTE: Indices in `EXTENSIONS` correspond to the `TypeFace` style constants.
   private static final String[] EXTENSIONS = {"", "_bold", "_italic", "_bold_italic"};
   private static final String[] FILE_EXTENSIONS = {".ttf", ".otf"};
   private static final String FONTS_ASSET_PATH = "fonts/";
 
   private static ReactFontManager sReactFontManagerInstance;
 
-  private final Map<String, FontFamily> mFontCache;
+  private final Map<String, AssetFontFamily> mFontCache;
   private final Map<String, Typeface> mCustomTypefaceCache;
 
   private ReactFontManager() {
@@ -49,36 +57,43 @@ public class ReactFontManager {
     return sReactFontManagerInstance;
   }
 
-  public @Nullable Typeface getTypeface(
-      String fontFamilyName, int style, AssetManager assetManager) {
-    return getTypeface(fontFamilyName, style, 0, assetManager);
+  public Typeface getTypeface(String fontFamilyName, int style, AssetManager assetManager) {
+    return getTypeface(fontFamilyName, new TypefaceStyle(style), assetManager);
   }
 
-  public @Nullable Typeface getTypeface(
+  public Typeface getTypeface(
+      String fontFamilyName, int weight, boolean italic, AssetManager assetManager) {
+    return getTypeface(fontFamilyName, new TypefaceStyle(weight, italic), assetManager);
+  }
+
+  public Typeface getTypeface(
       String fontFamilyName, int style, int weight, AssetManager assetManager) {
+    return getTypeface(fontFamilyName, new TypefaceStyle(style, weight), assetManager);
+  }
+
+  public Typeface getTypeface(
+      String fontFamilyName, TypefaceStyle typefaceStyle, AssetManager assetManager) {
     if (mCustomTypefaceCache.containsKey(fontFamilyName)) {
-      Typeface typeface = mCustomTypefaceCache.get(fontFamilyName);
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && weight >= 100 && weight <= 1000) {
-        return Typeface.create(typeface, weight, (style & Typeface.ITALIC) != 0);
-      }
-      return Typeface.create(typeface, style);
+      // Apply `typefaceStyle` because custom fonts configure variants using `app:fontStyle` and
+      // `app:fontWeight` in their resource XML configuration file.
+      return typefaceStyle.apply(mCustomTypefaceCache.get(fontFamilyName));
     }
 
-    FontFamily fontFamily = mFontCache.get(fontFamilyName);
-    if (fontFamily == null) {
-      fontFamily = new FontFamily();
-      mFontCache.put(fontFamilyName, fontFamily);
+    AssetFontFamily assetFontFamily = mFontCache.get(fontFamilyName);
+    if (assetFontFamily == null) {
+      assetFontFamily = new AssetFontFamily();
+      mFontCache.put(fontFamilyName, assetFontFamily);
     }
 
-    Typeface typeface = fontFamily.getTypeface(style);
-    if (typeface == null) {
-      typeface = createTypeface(fontFamilyName, style, assetManager);
-      if (typeface != null) {
-        fontFamily.setTypeface(style, typeface);
-      }
-    }
+    int style = typefaceStyle.getNearestStyle();
 
-    return typeface;
+    Typeface assetTypeface = assetFontFamily.getTypefaceForStyle(style);
+    if (assetTypeface == null) {
+      assetTypeface = createAssetTypeface(fontFamilyName, style, assetManager);
+      assetFontFamily.setTypefaceForStyle(style, assetTypeface);
+    }
+    // Do not apply `typefaceStyle` because asset font files already incorporate the style.
+    return assetTypeface;
   }
 
   /*
@@ -88,7 +103,7 @@ public class ReactFontManager {
    *
    * ReactFontManager.getInstance().addCustomFont(this, "Srisakdi", R.font.srisakdi);
    */
-  public void addCustomFont(@NonNull Context context, @NonNull String fontFamily, int fontId) {
+  public void addCustomFont(Context context, String fontFamily, int fontId) {
     Typeface font = ResourcesCompat.getFont(context, fontId);
     if (font != null) {
       mCustomTypefaceCache.put(fontFamily, font);
@@ -106,16 +121,16 @@ public class ReactFontManager {
    */
   public void setTypeface(String fontFamilyName, int style, Typeface typeface) {
     if (typeface != null) {
-      FontFamily fontFamily = mFontCache.get(fontFamilyName);
-      if (fontFamily == null) {
-        fontFamily = new FontFamily();
-        mFontCache.put(fontFamilyName, fontFamily);
+      AssetFontFamily assetFontFamily = mFontCache.get(fontFamilyName);
+      if (assetFontFamily == null) {
+        assetFontFamily = new AssetFontFamily();
+        mFontCache.put(fontFamilyName, assetFontFamily);
       }
-      fontFamily.setTypeface(style, typeface);
+      assetFontFamily.setTypefaceForStyle(style, typeface);
     }
   }
 
-  private static @Nullable Typeface createTypeface(
+  private static Typeface createAssetTypeface(
       String fontFamilyName, int style, AssetManager assetManager) {
     String extension = EXTENSIONS[style];
     for (String fileExtension : FILE_EXTENSIONS) {
@@ -129,27 +144,27 @@ public class ReactFontManager {
       try {
         return Typeface.createFromAsset(assetManager, fileName);
       } catch (RuntimeException e) {
-        // unfortunately Typeface.createFromAsset throws an exception instead of returning null
-        // if the typeface doesn't exist
+        // If the typeface asset does not exist, try another extension.
+        continue;
       }
     }
-
     return Typeface.create(fontFamilyName, style);
   }
 
-  private static class FontFamily {
+  /** Responsible for caching typefaces for each custom font family. */
+  private static class AssetFontFamily {
 
     private SparseArray<Typeface> mTypefaceSparseArray;
 
-    private FontFamily() {
+    private AssetFontFamily() {
       mTypefaceSparseArray = new SparseArray<>(4);
     }
 
-    public Typeface getTypeface(int style) {
+    public @Nullable Typeface getTypefaceForStyle(int style) {
       return mTypefaceSparseArray.get(style);
     }
 
-    public void setTypeface(int style, Typeface typeface) {
+    public void setTypefaceForStyle(int style, Typeface typeface) {
       mTypefaceSparseArray.put(style, typeface);
     }
   }

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

@@ -110,10 +110,6 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     } else if (frequency.equals("full")) {
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_FULL);
-    } else if (frequency.equals("balanced")) {
-      view.setHyphenationFrequency(Layout.BREAK_STRATEGY_BALANCED);
-    } else if (frequency.equals("high")) {
-      view.setHyphenationFrequency(Layout.BREAK_STRATEGY_HIGH_QUALITY);
     } else if (frequency.equals("normal")) {
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NORMAL);
     } else {

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

@@ -21,7 +21,7 @@ import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.NativeViewHierarchyOptimizer;
@@ -32,6 +32,7 @@ import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.UIViewOperationQueue;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.events.RCTEventEmitter;
+import com.facebook.yoga.YogaBaselineFunction;
 import com.facebook.yoga.YogaConstants;
 import com.facebook.yoga.YogaDirection;
 import com.facebook.yoga.YogaMeasureFunction;
@@ -116,7 +117,7 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
                   .getJSModule(RCTEventEmitter.class)
                   .receiveEvent(getReactTag(), "topTextLayout", event);
             } else {
-              ReactSoftException.logSoftException(
+              ReactSoftExceptionLogger.logSoftException(
                   "ReactTextShadowNode",
                   new ReactNoCrashSoftException("Cannot get RCTEventEmitter, no CatalystInstance"));
             }
@@ -159,6 +160,20 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
         }
       };
 
+  private final YogaBaselineFunction mTextBaselineFunction =
+      new YogaBaselineFunction() {
+        @Override
+        public float baseline(YogaNode node, float width, float height) {
+          Spannable text =
+              Assertions.assertNotNull(
+                  mPreparedSpannableText,
+                  "Spannable element has not been prepared in onBeforeLayout");
+
+          Layout layout = measureSpannedText(text, width, YogaMeasureMode.EXACTLY);
+          return layout.getLineBaseline(layout.getLineCount() - 1);
+        }
+      };
+
   public ReactTextShadowNode() {
     this(null);
   }
@@ -171,6 +186,7 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
   private void initMeasureFunction() {
     if (!isVirtual()) {
       setMeasureFunction(mTextMeasureFunction);
+      setBaselineFunction(mTextBaselineFunction);
     }
   }
 
@@ -231,7 +247,14 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
       // than the width of the text.
       layout =
           BoringLayout.make(
-              text, textPaint, boring.width, alignment, 1.f, 0.f, boring, mIncludeFontPadding);
+              text,
+              textPaint,
+              Math.max(boring.width, 0),
+              alignment,
+              1.f,
+              0.f,
+              boring,
+              mIncludeFontPadding);
     } else {
       // Is used for multiline, boring text and the width is known.
 
@@ -320,6 +343,11 @@ public class ReactTextShadowNode extends ReactBaseTextShadowNode {
               mJustificationMode);
       uiViewOperationQueue.enqueueUpdateExtraData(getReactTag(), reactTextUpdate);
     }
+
+    if (mAdjustsFontSizeToFit) {
+      // Nodes with `adjustsFontSizeToFit` enabled need to be remeasured on every relayout.
+      markUpdated();
+    }
   }
 
   @ReactProp(name = "onTextLayout")

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

@@ -56,6 +56,7 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
   private boolean mAdjustsFontSizeToFit = false;
   private int mLinkifyMaskType = 0;
   private boolean mNotifyOnInlineViewLayout;
+  private boolean mTextIsSelectable = false;
 
   private ReactViewBackgroundManager mReactBackgroundManager;
   private Spannable mSpanned;
@@ -124,6 +125,17 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
 
     Spanned text = (Spanned) getText();
     Layout layout = getLayout();
+    if (layout == null) {
+      // Text layout is calculated during pre-draw phase, so in some cases it can be empty during
+      // layout phase, which usually happens before drawing.
+      // The text layout is created by private {@link assumeLayout} method, which we can try to
+      // invoke directly through reflection or indirectly through some methods that compute it
+      // (e.g. {@link getExtendedPaddingTop}).
+      // It is safer, however, to just early return here, as next measure/layout passes are way more
+      // likely to have the text layout computed.
+      return;
+    }
+
     TextInlineViewPlaceholderSpan[] placeholders =
         text.getSpans(0, text.length(), TextInlineViewPlaceholderSpan.class);
     ArrayList inlineViewInfoArray =
@@ -422,9 +434,16 @@ public class ReactTextView extends AppCompatTextView implements ReactCompoundVie
     }
   }
 
+  @Override
+  public void setTextIsSelectable(boolean selectable) {
+    mTextIsSelectable = selectable;
+    super.setTextIsSelectable(selectable);
+  }
+
   @Override
   public void onAttachedToWindow() {
     super.onAttachedToWindow();
+    setTextIsSelectable(mTextIsSelectable);
     if (mContainsImages && getText() instanceof Spanned) {
       Spanned text = (Spanned) getText();
       TextInlineImageSpan[] spans = text.getSpans(0, text.length(), TextInlineImageSpan.class);

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

@@ -95,7 +95,7 @@ public class ReactTextViewManager
       return null;
     }
 
-    if (ReactFeatureFlags.mapBufferSerializationEnabled) {
+    if (ReactFeatureFlags.isMapBufferSerializationEnabled()) {
       ReadableMapBuffer stateMapBuffer = stateWrapper.getStatDataMapBuffer();
       if (stateMapBuffer != null) {
         return getReactTextUpdate(view, props, stateMapBuffer);

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

@@ -11,33 +11,52 @@ import android.content.res.AssetManager;
 import android.graphics.Typeface;
 import android.text.TextUtils;
 import androidx.annotation.Nullable;
+import com.facebook.infer.annotation.Nullsafe;
 import com.facebook.react.bridge.ReadableArray;
 import java.util.ArrayList;
 import java.util.List;
 
+@Nullsafe(Nullsafe.Mode.LOCAL)
 public class ReactTypefaceUtils {
-  public static final int UNSET = -1;
 
   public static int parseFontWeight(@Nullable String fontWeightString) {
-    int fontWeightNumeric =
-        fontWeightString != null ? parseNumericFontWeight(fontWeightString) : UNSET;
-    int fontWeight = fontWeightNumeric != UNSET ? fontWeightNumeric : Typeface.NORMAL;
-
-    if (fontWeight == 700 || "bold".equals(fontWeightString)) fontWeight = Typeface.BOLD;
-    else if (fontWeight == 400 || "normal".equals(fontWeightString)) fontWeight = Typeface.NORMAL;
-
-    return fontWeight;
+    if (fontWeightString != null) {
+      switch (fontWeightString) {
+        case "100":
+          return 100;
+        case "200":
+          return 200;
+        case "300":
+          return 300;
+        case "normal":
+        case "400":
+          return 400;
+        case "500":
+          return 500;
+        case "600":
+          return 600;
+        case "bold":
+        case "700":
+          return 700;
+        case "800":
+          return 800;
+        case "900":
+          return 900;
+      }
+    }
+    return ReactBaseTextShadowNode.UNSET;
   }
 
   public static int parseFontStyle(@Nullable String fontStyleString) {
-    int fontStyle = UNSET;
-    if ("italic".equals(fontStyleString)) {
-      fontStyle = Typeface.ITALIC;
-    } else if ("normal".equals(fontStyleString)) {
-      fontStyle = Typeface.NORMAL;
+    if (fontStyleString != null) {
+      if ("italic".equals(fontStyleString)) {
+        return Typeface.ITALIC;
+      }
+      if ("normal".equals(fontStyleString)) {
+        return Typeface.NORMAL;
+      }
     }
-
-    return fontStyle;
+    return ReactBaseTextShadowNode.UNSET;
   }
 
   public static @Nullable String parseFontVariant(@Nullable ReadableArray fontVariantArray) {
@@ -77,51 +96,14 @@ public class ReactTypefaceUtils {
       @Nullable Typeface typeface,
       int style,
       int weight,
-      @Nullable String family,
+      @Nullable String fontFamilyName,
       AssetManager assetManager) {
-    int oldStyle;
-    if (typeface == null) {
-      oldStyle = 0;
-    } else {
-      oldStyle = typeface.getStyle();
-    }
-
-    int want = 0;
-    if ((weight == Typeface.BOLD)
-        || ((oldStyle & Typeface.BOLD) != 0 && weight == ReactTextShadowNode.UNSET)) {
-      want |= Typeface.BOLD;
-    }
-
-    if ((style == Typeface.ITALIC)
-        || ((oldStyle & Typeface.ITALIC) != 0 && style == ReactTextShadowNode.UNSET)) {
-      want |= Typeface.ITALIC;
-    }
-
-    if (family != null) {
-      typeface = ReactFontManager.getInstance().getTypeface(family, want, weight, assetManager);
-    } else if (typeface != null) {
-      // TODO(t9055065): Fix custom fonts getting applied to text children with different style
-      typeface = Typeface.create(typeface, want);
-    }
-
-    if (typeface != null) {
-      return typeface;
+    TypefaceStyle typefaceStyle = new TypefaceStyle(style, weight);
+    if (fontFamilyName == null) {
+      return typefaceStyle.apply(typeface == null ? Typeface.DEFAULT : typeface);
     } else {
-      return Typeface.defaultFromStyle(want);
+      return ReactFontManager.getInstance()
+          .getTypeface(fontFamilyName, typefaceStyle, assetManager);
     }
   }
-
-  /**
-   * Return -1 if the input string is not a valid numeric fontWeight (100, 200, ..., 900), otherwise
-   * return the weight.
-   */
-  private static int parseNumericFontWeight(String fontWeightString) {
-    // This should be much faster than using regex to verify input and Integer.parseInt
-    return fontWeightString.length() == 3
-            && fontWeightString.endsWith("00")
-            && fontWeightString.charAt(0) <= '9'
-            && fontWeightString.charAt(0) >= '1'
-        ? 100 * (fontWeightString.charAt(0) - '0')
-        : UNSET;
-  }
 }

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

@@ -7,7 +7,6 @@
 
 package com.facebook.react.views.text;
 
-import android.graphics.Typeface;
 import android.os.Build;
 import android.text.Layout;
 import android.text.TextUtils;
@@ -69,9 +68,10 @@ public class TextAttributeProps {
   private static final int DEFAULT_TEXT_SHADOW_COLOR = 0x55000000;
   private static final int DEFAULT_JUSTIFICATION_MODE =
       (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) ? 0 : Layout.JUSTIFICATION_MODE_NONE;
-
   private static final int DEFAULT_BREAK_STRATEGY =
       (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? 0 : Layout.BREAK_STRATEGY_HIGH_QUALITY;
+  private static final int DEFAULT_HYPHENATION_FREQUENCY =
+      (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) ? 0 : Layout.HYPHENATION_FREQUENCY_NONE;
 
   protected float mLineHeight = Float.NaN;
   protected boolean mIsColorSet = false;
@@ -104,12 +104,7 @@ public class TextAttributeProps {
   protected @Nullable ReactAccessibilityDelegate.AccessibilityRole mAccessibilityRole = null;
   protected boolean mIsAccessibilityRoleSet = false;
 
-  /**
-   * mFontStyle can be {@link Typeface#NORMAL} or {@link Typeface#ITALIC}. mFontWeight can be {@link
-   * Typeface#NORMAL} or {@link Typeface#BOLD}.
-   */
   protected int mFontStyle = UNSET;
-
   protected int mFontWeight = UNSET;
   /**
    * NB: If a font family is used that does not have a style in a certain Android version (ie.
@@ -460,39 +455,12 @@ public class TextAttributeProps {
     mFontFeatureSettings = TextUtils.join(", ", features);
   }
 
-  /**
-   * /* This code is duplicated in ReactTextInputManager /* TODO: Factor into a common place they
-   * can both use
-   */
   private void setFontWeight(@Nullable String fontWeightString) {
-    int fontWeightNumeric =
-        fontWeightString != null ? parseNumericFontWeight(fontWeightString) : -1;
-    int fontWeight = UNSET;
-    if (fontWeightNumeric >= 500 || "bold".equals(fontWeightString)) {
-      fontWeight = Typeface.BOLD;
-    } else if ("normal".equals(fontWeightString)
-        || (fontWeightNumeric != -1 && fontWeightNumeric < 500)) {
-      fontWeight = Typeface.NORMAL;
-    }
-    if (fontWeight != mFontWeight) {
-      mFontWeight = fontWeight;
-    }
+    mFontWeight = ReactTypefaceUtils.parseFontWeight(fontWeightString);
   }
 
-  /**
-   * /* This code is duplicated in ReactTextInputManager /* TODO: Factor into a common place they
-   * can both use
-   */
   private void setFontStyle(@Nullable String fontStyleString) {
-    int fontStyle = UNSET;
-    if ("italic".equals(fontStyleString)) {
-      fontStyle = Typeface.ITALIC;
-    } else if ("normal".equals(fontStyleString)) {
-      fontStyle = Typeface.NORMAL;
-    }
-    if (fontStyle != mFontStyle) {
-      mFontStyle = fontStyle;
-    }
+    mFontStyle = ReactTypefaceUtils.parseFontStyle(fontStyleString);
   }
 
   private void setIncludeFontPadding(boolean includepad) {
@@ -602,20 +570,21 @@ public class TextAttributeProps {
     return androidTextBreakStrategy;
   }
 
-  /**
-   * Return -1 if the input string is not a valid numeric fontWeight (100, 200, ..., 900), otherwise
-   * return the weight.
-   *
-   * <p>This code is duplicated in ReactTextInputManager TODO: Factor into a common place they can
-   * both use
-   */
-  private static int parseNumericFontWeight(String fontWeightString) {
-    // This should be much faster than using regex to verify input and Integer.parseInt
-    return fontWeightString.length() == 3
-            && fontWeightString.endsWith("00")
-            && fontWeightString.charAt(0) <= '9'
-            && fontWeightString.charAt(0) >= '1'
-        ? 100 * (fontWeightString.charAt(0) - '0')
-        : -1;
+  public static int getHyphenationFrequency(@Nullable String hyphenationFrequency) {
+    int androidHyphenationFrequency = DEFAULT_HYPHENATION_FREQUENCY;
+    if (hyphenationFrequency != null) {
+      switch (hyphenationFrequency) {
+        case "none":
+          androidHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NONE;
+          break;
+        case "normal":
+          androidHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_NORMAL;
+          break;
+        default:
+          androidHyphenationFrequency = Layout.HYPHENATION_FREQUENCY_FULL;
+          break;
+      }
+    }
+    return androidHyphenationFrequency;
   }
 }