react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSliderManager.java

@@ -16,7 +16,6 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.SeekBar;
 import androidx.annotation.Nullable;
-import androidx.core.view.AccessibilityDelegateCompat;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat.AccessibilityActionCompat;
 import com.facebook.react.bridge.ReactContext;
@@ -24,6 +23,7 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.LayoutShadowNode;
 import com.facebook.react.uimanager.PixelUtil;
+import com.facebook.react.uimanager.ReactAccessibilityDelegate;
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
@@ -149,7 +149,7 @@ public class ReactSliderManager extends SimpleViewManager<ReactSlider>
   @Override
   protected ReactSlider createViewInstance(ThemedReactContext context) {
     final ReactSlider slider = new ReactSlider(context, null, STYLE);
-    ViewCompat.setAccessibilityDelegate(slider, sAccessibilityDelegate);
+    ViewCompat.setAccessibilityDelegate(slider, new ReactSliderAccessibilityDelegate());
     return slider;
   }
 
@@ -278,8 +278,8 @@ public class ReactSliderManager extends SimpleViewManager<ReactSlider>
     return mDelegate;
   }
 
-  protected static class ReactSliderAccessibilityDelegate extends AccessibilityDelegateCompat {
-    private static boolean isSliderAction(int action) {
+  protected class ReactSliderAccessibilityDelegate extends ReactAccessibilityDelegate {
+    private boolean isSliderAction(int action) {
       return (action == AccessibilityActionCompat.ACTION_SCROLL_FORWARD.getId())
           || (action == AccessibilityActionCompat.ACTION_SCROLL_BACKWARD.getId())
           || (action == AccessibilityActionCompat.ACTION_SET_PROGRESS.getId());
@@ -297,7 +297,4 @@ public class ReactSliderManager extends SimpleViewManager<ReactSlider>
       return rv;
     }
   };
-
-  protected static ReactSliderAccessibilityDelegate sAccessibilityDelegate =
-      new ReactSliderAccessibilityDelegate();
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/slider/ReactSlidingCompleteEvent.java

@@ -47,11 +47,6 @@ public class ReactSlidingCompleteEvent extends Event<ReactSlidingCompleteEvent>
     return eventData;
   }
 
-  @Override
-  public short getCoalescingKey() {
-    return 0;
-  }
-
   @Override
   public boolean canCoalesce() {
     return false;

package/ReactAndroid/src/main/java/com/facebook/react/views/swiperefresh/BUCK

@@ -26,6 +26,6 @@ rn_android_library(
         react_native_target("java/com/facebook/react/views/scroll:scroll"),
     ],
     exported_deps = [
-        react_native_root_target("Libraries:generated_components_java-FBReactNativeComponentSpec"),
+        react_native_root_target(":generated_components_java-FBReactNativeComponentSpec"),
     ],
 )

package/ReactAndroid/src/main/java/com/facebook/react/views/switchview/BUCK

@@ -24,6 +24,6 @@ rn_android_library(
         react_native_target("java/com/facebook/react/common:common"),
         react_native_target("java/com/facebook/react/uimanager:uimanager"),
         react_native_target("java/com/facebook/react/uimanager/annotations:annotations"),
-        react_native_root_target("Libraries:generated_components_java-FBReactNativeComponentSpec"),
+        react_native_root_target(":generated_components_java-FBReactNativeComponentSpec"),
     ],
 )

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

@@ -46,10 +46,4 @@ import com.facebook.react.uimanager.events.Event;
     eventData.putBoolean("value", getIsChecked());
     return eventData;
   }
-
-  @Override
-  public short getCoalescingKey() {
-    // All switch events for a given view can be coalesced.
-    return 0;
-  }
 }

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);
     }
   }
 
@@ -327,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/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;
-  }
 }