react-native-advanced-text 0.2.6 → 0.2.8

package/android/src/main/java/com/advancedtext/AdvancedTextView.kt

@@ -25,7 +25,6 @@ import com.facebook.react.uimanager.events.RCTEventEmitter
 import android.text.Selection
 import android.graphics.Typeface
 import androidx.core.text.getSpans
-import com.facebook.react.common.assets.ReactFontManager
 import kotlin.math.ceil
 
 class AdvancedTextView : TextView {
@@ -165,25 +164,9 @@ class AdvancedTextView : TextView {
     fun setAdvancedFontFamily(family: String) {
         if (fontFamily == family) return
         fontFamily = family
-        typeface = resolveTypeface(family, Typeface.NORMAL)
+        typeface = Typeface.create(family, Typeface.NORMAL)
     }
 
-    /**
-     * `Typeface.create(family, style)` only resolves OS-registered families; it
-     * silently substitutes a system font for anything bundled under
-     * `assets/fonts/` (the RN/Expo custom-font pipeline) instead of failing.
-     * The Fabric ShadowNode measures this component's text via
-     * `TextLayoutManager`, which resolves fonts through `ReactFontManager` -
-     * so a custom font here rendered with the substituted typeface has
-     * different glyph widths than what was measured, wrapping onto a
-     * different number of lines and producing extra height for some strings
-     * but not others. Going through `ReactFontManager` keeps the rendered
-     * typeface identical to the measured one (and is a no-op for system font
-     * names, which it falls back to `Typeface.create` for anyway).
-     */
-    private fun resolveTypeface(family: String, style: Int): Typeface =
-        ReactFontManager.getInstance().getTypeface(family, style, context.assets)
-
     fun setMenuOptions(menuOptions: List<String>) {
         if (this.menuOptions == menuOptions) return
         this.menuOptions = menuOptions
@@ -289,9 +272,9 @@ class AdvancedTextView : TextView {
         setTextSize(fontSize)
 
         typeface = when (fontWeight) {
-            "bold" -> resolveTypeface(fontFamily, Typeface.BOLD)
-            "italic" -> resolveTypeface(fontFamily, Typeface.ITALIC)
-            else -> resolveTypeface(fontFamily, Typeface.NORMAL)
+            "bold" -> Typeface.create(fontFamily, Typeface.BOLD)
+            "italic" -> Typeface.create(fontFamily, Typeface.ITALIC)
+            else -> Typeface.create(fontFamily, Typeface.NORMAL)
         }
 
 

package/android/src/main/java/com/advancedtext/CssLineHeightSpan.kt

@@ -21,6 +21,13 @@ import kotlin.math.floor
  * from the measured one by a per-line amount, which is why the discrepancy
  * grew with the number of wrapped lines.
  *
+ * `start`/`end` here are the offsets of the *current line*, not the span's
+ * own range, so the first/last checks below correctly fire only once each
+ * per paragraph. Mirrors React Native's own
+ * `com.facebook.react.views.text.internal.span.CustomLineHeightSpan`
+ * (used internally for `<Text lineHeight={}>`) verbatim, so it inherits that
+ * implementation's on-device track record instead of a new one.
+ *
  * See: https://www.w3.org/TR/css-inline-3/#inline-height
  */
 internal class CssLineHeightSpan(private val lineHeightPx: Int) : LineHeightSpan {

package/common/cpp/react/renderer/components/AdvancedTextViewSpec/ShadowNodes.cpp

@@ -11,7 +11,6 @@
 
 #include <algorithm>
 #include <cctype>
-#include <limits>
 #include <string>
 
 #include <react/renderer/attributedstring/AttributedStringBox.h>
@@ -33,10 +32,6 @@ std::string toLowerAscii(std::string value) {
   return value;
 }
 
-// Fallback only: an approximate ratio of a single line's natural height to
-// its font size, used if a real measurement (Android) isn't available/valid.
-constexpr Float kLineHeightFudgeFactor = 1.2;
-
 } // namespace
 
 AdvancedTextViewShadowNode::AdvancedTextViewShadowNode(
@@ -47,54 +42,7 @@ AdvancedTextViewShadowNode::AdvancedTextViewShadowNode(
           static_cast<const AdvancedTextViewShadowNode&>(sourceShadowNode)
               .textLayoutManager_) {}
 
-#if defined(ANDROID)
-Float AdvancedTextViewShadowNode::measureNaturalSingleLineHeight(
-    const LayoutContext& layoutContext,
-    const TextAttributes& baseTextAttributes) const {
-  // Same font/size/weight/style as the real fragment, but with `lineHeight`
-  // cleared so this reports the font's own, unscaled single-line height.
-  auto probeAttributes = baseTextAttributes;
-  probeAttributes.lineHeight = std::numeric_limits<Float>::quiet_NaN();
-
-  auto probe = AttributedString{};
-  probe.appendFragment(AttributedString::Fragment{
-      .string = "M",
-      .textAttributes = probeAttributes,
-      .parentShadowView = ShadowView(*this),
-  });
-
-  auto paragraphAttributes = ParagraphAttributes{};
-  // Measure the tight ascent+descent box (no extra top/bottom accent
-  // padding). This is the same "natural line height" basis
-  // CssLineHeightSpan.kt derives from `Paint.getFontMetricsInt()` on the
-  // view side (which is unaffected by `includeFontPadding`, a Layout-level
-  // setting) -- measuring with padding included here would double count it
-  // once per rendered line once the resulting value is multiplied and
-  // applied to the whole paragraph.
-  paragraphAttributes.includeFontPadding = false;
-
-  auto textLayoutContext = TextLayoutContext{};
-  textLayoutContext.pointScaleFactor = layoutContext.pointScaleFactor;
-  textLayoutContext.surfaceId = getSurfaceId();
-
-  // Unconstrained so a single glyph can never be forced to wrap.
-  auto unconstrainedLayoutConstraints = LayoutConstraints{
-      {0, 0},
-      {std::numeric_limits<Float>::infinity(),
-       std::numeric_limits<Float>::infinity()}};
-
-  auto measurement = textLayoutManager_->measure(
-      AttributedStringBox{probe},
-      paragraphAttributes,
-      textLayoutContext,
-      unconstrainedLayoutConstraints);
-
-  return measurement.size.height;
-}
-#endif
-
-AttributedString AdvancedTextViewShadowNode::getAttributedString(
-    const LayoutContext& layoutContext) const {
+TextAttributes AdvancedTextViewShadowNode::baseTextAttributes() const {
   const auto& props = getConcreteProps();
 
   auto textAttributes = TextAttributes::defaultTextAttributes();
@@ -120,14 +68,59 @@ AttributedString AdvancedTextViewShadowNode::getAttributedString(
     textAttributes.letterSpacing = props.letterSpacing;
   }
 
+  return textAttributes;
+}
+
+#if defined(ANDROID)
+Float AdvancedTextViewShadowNode::measureNaturalLineHeight(
+    const TextAttributes& baseTextAttributes,
+    const TextLayoutContext& textLayoutContext) const {
+  // `baseTextAttributes` deliberately has no `lineHeight` set, so this
+  // resolves to the font's own natural single-line height -- exactly what
+  // CssLineHeightSpan.kt multiplies on the view side.
+  auto probeString = AttributedString{};
+  probeString.appendFragment(AttributedString::Fragment{
+      .string = "M",
+      .textAttributes = baseTextAttributes,
+      .parentShadowView = ShadowView(*this),
+  });
+
+  auto probeParagraphAttributes = ParagraphAttributes{};
+  probeParagraphAttributes.maximumNumberOfLines = 1;
+  // Measure the tight ascent+descent box (no extra top/bottom accent
+  // padding). This is the same "natural line height" basis
+  // CssLineHeightSpan.kt derives from `Paint.getFontMetricsInt()` on the
+  // view side (which is unaffected by `includeFontPadding`, a Layout-level
+  // setting) -- measuring with padding included here would double count it
+  // once per rendered line once the resulting value is multiplied and
+  // applied to the whole paragraph.
+  probeParagraphAttributes.includeFontPadding = false;
+
+  auto measurement = textLayoutManager_->measure(
+      AttributedStringBox{probeString},
+      probeParagraphAttributes,
+      textLayoutContext,
+      LayoutConstraints{});
+
+  return measurement.size.height;
+}
+#endif
+
+AttributedString AdvancedTextViewShadowNode::getAttributedString(
+    const TextAttributes& baseTextAttributes,
+    const TextLayoutContext& textLayoutContext) const {
+  const auto& props = getConcreteProps();
+
+  auto textAttributes = baseTextAttributes;
+
   // The component treats `lineHeight` as a multiple of the font's own
   // natural line height (see CssLineHeightSpan.kt on Android / the
   // NSParagraphStyle-based spacing in AdvancedTextView.mm on iOS) -- NOT the
-  // absolute per-line value `TextAttributes.lineHeight` expects. A multiplier
-  // of 1 *is* the natural line height, so there is nothing to override in
-  // that case (overriding it with an approximation, as this used to do
-  // unconditionally, made even the "no lineHeight override" case measure
-  // taller or shorter than the real render).
+  // absolute per-line value `TextAttributes::lineHeight` expects. A
+  // multiplier of 1 *is* the natural line height, so there is nothing to
+  // override in that case (overriding it with an approximation, as this
+  // used to do unconditionally, made even the "no lineHeight override" case
+  // measure taller or shorter than the real render).
   if (props.lineHeight > 0 && props.lineHeight != 1.0) {
 #if defined(ANDROID)
     // Android's natural single-line height depends on the resolved
@@ -138,13 +131,13 @@ AttributedString AdvancedTextViewShadowNode::getAttributedString(
     // length. Measure the real natural height for these exact attributes
     // instead, the same way the view derives it.
     auto naturalLineHeight =
-        measureNaturalSingleLineHeight(layoutContext, textAttributes);
+        measureNaturalLineHeight(textAttributes, textLayoutContext);
     textAttributes.lineHeight = naturalLineHeight > 0
         ? props.lineHeight * naturalLineHeight
-        : props.lineHeight * textAttributes.fontSize * kLineHeightFudgeFactor;
+        : props.lineHeight * textAttributes.fontSize * 1.2;
 #else
     textAttributes.lineHeight =
-        props.lineHeight * textAttributes.fontSize * kLineHeightFudgeFactor;
+        props.lineHeight * textAttributes.fontSize * 1.2;
 #endif
   }
 
@@ -171,16 +164,17 @@ Size AdvancedTextViewShadowNode::measureContent(
         std::make_shared<const TextLayoutManager>(getContextContainer());
   }
 
-  auto paragraphAttributes = ParagraphAttributes{};
-  paragraphAttributes.maximumNumberOfLines = 0; // unlimited -> natural wrapping
-  paragraphAttributes.adjustsFontSizeToFit = false;
-
   auto textLayoutContext = TextLayoutContext{};
   textLayoutContext.pointScaleFactor = layoutContext.pointScaleFactor;
   textLayoutContext.surfaceId = getSurfaceId();
 
+  auto paragraphAttributes = ParagraphAttributes{};
+  paragraphAttributes.maximumNumberOfLines = 0; // unlimited -> natural wrapping
+  paragraphAttributes.adjustsFontSizeToFit = false;
+
   auto measurement = textLayoutManager_->measure(
-      AttributedStringBox{getAttributedString(layoutContext)},
+      AttributedStringBox{
+          getAttributedString(baseTextAttributes(), textLayoutContext)},
       paragraphAttributes,
       textLayoutContext,
       layoutConstraints);

package/common/cpp/react/renderer/components/AdvancedTextViewSpec/ShadowNodes.h

@@ -34,6 +34,7 @@
 
 #include <jsi/jsi.h>
 #include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/TextAttributes.h>
 #include <react/renderer/components/AdvancedTextViewSpec/EventEmitters.h>
 #include <react/renderer/components/AdvancedTextViewSpec/Props.h>
 #include <react/renderer/components/AdvancedTextViewSpec/States.h>
@@ -42,6 +43,7 @@
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
+#include <react/renderer/textlayoutmanager/TextLayoutContext.h>
 
 namespace facebook::react {
 
@@ -83,24 +85,42 @@ class AdvancedTextViewShadowNode final : public ConcreteViewShadowNode<
 
  private:
   /*
-   * Builds a single-fragment `AttributedString` from the component props
-   * (text + font attributes), mirroring how the native views render it.
+   * Builds the font-related `TextAttributes` from the component props
+   * (family/weight/style/size/letterSpacing), *excluding* `lineHeight`.
+   * Shared between the natural-line-height probe and the real measurement so
+   * both resolve to the exact same font.
    */
-  AttributedString getAttributedString(const LayoutContext& layoutContext) const;
+  TextAttributes baseTextAttributes() const;
 
-#if defined(ANDROID)
   /*
-   * Measures the natural (multiplier == 1) height of a single line set in
-   * `baseTextAttributes`, by measuring a single glyph with `lineHeight`
-   * cleared. Used to turn the component's `lineHeight` multiplier prop into
-   * the absolute value `TextAttributes.lineHeight` expects, using this
-   * font's *real* metrics instead of an approximation.
+   * `lineHeight` is exposed to JS as a multiple of the font's own natural
+   * line height (see CssLineHeightSpan.kt on Android), NOT the absolute
+   * per-line value `TextAttributes::lineHeight` expects. A hardcoded ratio
+   * (e.g. `fontSize * 1.2`) is only an approximation of a font's real
+   * natural single-line height, and native font tables (especially OEM
+   * ones) can deviate from it enough to make Yoga's measured block height
+   * visibly disagree with what the native view actually draws. To keep them
+   * in sync, measure a single line of the same resolved font (no
+   * `lineHeight` override) and use its height as the real multiplier base --
+   * with `includeFontPadding = false`, matching the tight ascent+descent
+   * basis `Paint.getFontMetricsInt()` gives `CssLineHeightSpan.kt` on the
+   * view side (Android only; iOS's own NSParagraphStyle-based spacing in
+   * AdvancedTextView.mm doesn't need this).
    */
-  Float measureNaturalSingleLineHeight(
-      const LayoutContext& layoutContext,
-      const TextAttributes& baseTextAttributes) const;
+#if defined(ANDROID)
+  Float measureNaturalLineHeight(
+      const TextAttributes& baseTextAttributes,
+      const TextLayoutContext& textLayoutContext) const;
 #endif
 
+  /*
+   * Builds a single-fragment `AttributedString` from the component props
+   * (text + font attributes), mirroring how the native views render it.
+   */
+  AttributedString getAttributedString(
+      const TextAttributes& baseTextAttributes,
+      const TextLayoutContext& textLayoutContext) const;
+
   // Lazily created on first measure, then reused / copied across clones.
   mutable std::shared_ptr<const TextLayoutManager> textLayoutManager_;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-advanced-text",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": " Advanced text component for React Native with custom select options.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",