basalt-core 0.0.0-rc5 → 0.2.0

package/native/core/Filters.h

@@ -0,0 +1,336 @@
+// CSS filter functions, resolved to one colour matrix, one blur and one opacity.
+//
+// `filter: 'grayscale(1) brightness(1.2)'` on a view reaches both hosts as a
+// list of `FilterFunction`s and was dropped by both. Each toolkit has the
+// primitives: GSK has a colour-matrix node, a blur node and an opacity node, and
+// CALayer takes Core Image filters on macOS. What neither has is the arithmetic,
+// which the Filter Effects spec gives exactly -- so it lives here, once, with the
+// spec's own numbers.
+//
+// ## Why one matrix rather than a chain
+//
+// Seven of the nine functions are affine transformations of colour:
+// `brightness`, `contrast`, `grayscale`, `hueRotate`, `invert`, `saturate` and
+// `sepia`. Composing two of those is multiplying their matrices, so a list of
+// them is one matrix and one node rather than a stack -- and since each is a
+// per-pixel affine map, it does not matter whether the blur happens before or
+// after: a blur is a weighted average whose weights sum to one, and an affine
+// map commutes with that. The same goes for `opacity`, which scales alpha
+// linearly.
+//
+// `dropShadow` is the exception and does not commute with anything: it depends on
+// the alpha silhouette at its point in the chain. So it is kept as a list in the
+// order it was written, and each host draws it with its own shadow mechanism.
+//
+// What that loses is the interleaving: `drop-shadow(...) grayscale(1)` greys the
+// shadow too and `grayscale(1) drop-shadow(...)` does not, and with the matrix
+// collapsed into one node there is one order rather than two. The shadows go on
+// last, which is the second of those, and backlog/correctness.md records it.
+//
+// Two blurs in one list compose in quadrature -- the sigmas, not the radii --
+// because convolving two gaussians gives a gaussian of the combined variance.
+//
+// Header-only, like core/Gradients.h, and included by the mounting managers,
+// which already know React Native.
+
+#pragma once
+
+// For kPi, which is here rather than M_PI for the reason that header gives: MSVC
+// defines the POSIX math constants only behind a flag this project does not set.
+#include "Gradients.h"
+
+#include <react/renderer/graphics/Filter.h>
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+namespace basalt {
+
+// An affine map of colour: `out = matrix * in + offset`, both in R, G, B, A
+// order, with the matrix stored row by row. That is GSK's own shape, and Core
+// Image's CIColorMatrix wants the same numbers as four vectors and a bias.
+struct ColorMatrix {
+  float m[16]{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
+  float offset[4]{0, 0, 0, 0};
+
+  // Row `row`, column `column`.
+  float at(int row, int column) const { return m[row * 4 + column]; }
+
+  bool isIdentity() const {
+    for (int row = 0; row < 4; row++) {
+      for (int column = 0; column < 4; column++) {
+        const float wanted = row == column ? 1.0F : 0.0F;
+        if (std::fabs(at(row, column) - wanted) > 1e-6F) {
+          return false;
+        }
+      }
+      if (std::fabs(offset[row]) > 1e-6F) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // The colour this matrix makes of `in`, which is what the tests assert on and
+  // what a host can use to check itself against a rendered pixel.
+  void apply(const float in[4], float out[4]) const {
+    for (int row = 0; row < 4; row++) {
+      out[row] = offset[row];
+      for (int column = 0; column < 4; column++) {
+        out[row] += at(row, column) * in[column];
+      }
+    }
+  }
+};
+
+// `second` after `first`: out = M2 (M1 c + o1) + o2.
+inline ColorMatrix composeColorMatrix(const ColorMatrix &first, const ColorMatrix &second) {
+  ColorMatrix result;
+  for (int row = 0; row < 4; row++) {
+    for (int column = 0; column < 4; column++) {
+      float sum = 0.0F;
+      for (int k = 0; k < 4; k++) {
+        sum += second.at(row, k) * first.at(k, column);
+      }
+      result.m[row * 4 + column] = sum;
+    }
+    float offset = second.offset[row];
+    for (int k = 0; k < 4; k++) {
+      offset += second.at(row, k) * first.offset[k];
+    }
+    result.offset[row] = offset;
+  }
+  return result;
+}
+
+namespace detail {
+
+// The luminance weights every one of these matrices is built from, which are
+// Rec. 709's and are what the spec names.
+constexpr float kLumaRed = 0.2126F;
+constexpr float kLumaGreen = 0.7152F;
+constexpr float kLumaBlue = 0.0722F;
+
+inline ColorMatrix scaleRgb(float factor) {
+  ColorMatrix matrix;
+  matrix.m[0] = factor;
+  matrix.m[5] = factor;
+  matrix.m[10] = factor;
+  return matrix;
+}
+
+// The spec's saturate matrix, which `grayscale` is the inverse end of: saturate
+// at 0 and grayscale at 1 are the same transformation.
+inline ColorMatrix saturate(float amount) {
+  // Clamped at zero only. Over-saturating past 1 is allowed and useful.
+  const float s = std::max(amount, 0.0F);
+  ColorMatrix matrix;
+  const float r = kLumaRed;
+  const float g = kLumaGreen;
+  const float b = kLumaBlue;
+  const float row0[4] = {r + (1 - r) * s, g - g * s, b - b * s, 0};
+  const float row1[4] = {r - r * s, g + (1 - g) * s, b - b * s, 0};
+  const float row2[4] = {r - r * s, g - g * s, b + (1 - b) * s, 0};
+  for (int column = 0; column < 4; column++) {
+    matrix.m[column] = row0[column];
+    matrix.m[4 + column] = row1[column];
+    matrix.m[8 + column] = row2[column];
+  }
+  return matrix;
+}
+
+inline ColorMatrix sepia(float amount) {
+  const float a = std::clamp(amount, 0.0F, 1.0F);
+  // The spec's sepia matrix, interpolated from the identity by `amount`.
+  const float full[9] = {0.393F, 0.769F, 0.189F, 0.349F, 0.686F, 0.168F, 0.272F, 0.534F, 0.131F};
+  ColorMatrix matrix;
+  for (int row = 0; row < 3; row++) {
+    for (int column = 0; column < 3; column++) {
+      const float identity = row == column ? 1.0F : 0.0F;
+      matrix.m[row * 4 + column] = identity + (full[row * 3 + column] - identity) * a;
+    }
+  }
+  return matrix;
+}
+
+inline ColorMatrix hueRotate(float degrees) {
+  const double radians = static_cast<double>(degrees) * kPi / 180.0;
+  const float cosine = static_cast<float>(std::cos(radians));
+  const float sine = static_cast<float>(std::sin(radians));
+  // The spec's hue-rotate matrix: the luminance-preserving rotation in the plane
+  // orthogonal to the grey axis.
+  const float rows[9] = {
+      0.213F + cosine * 0.787F - sine * 0.213F,
+      0.715F - cosine * 0.715F - sine * 0.715F,
+      0.072F - cosine * 0.072F + sine * 0.928F,
+
+      0.213F - cosine * 0.213F + sine * 0.143F,
+      0.715F + cosine * 0.285F + sine * 0.140F,
+      0.072F - cosine * 0.072F - sine * 0.283F,
+
+      0.213F - cosine * 0.213F - sine * 0.787F,
+      0.715F - cosine * 0.715F + sine * 0.715F,
+      0.072F + cosine * 0.928F + sine * 0.072F,
+  };
+  ColorMatrix matrix;
+  for (int row = 0; row < 3; row++) {
+    for (int column = 0; column < 3; column++) {
+      matrix.m[row * 4 + column] = rows[row * 3 + column];
+    }
+  }
+  return matrix;
+}
+
+} // namespace detail
+
+// One `dropShadow()`, resolved: the offset, the gaussian's standard deviation and
+// the colour, in straight sRGB.
+//
+// A standard deviation rather than a CSS blur radius, because that is what React
+// Native parses the third length into and hands over -- the field is named
+// `standardDeviation` -- and what its own iOS half passes straight to SwiftUI's
+// `.shadow(radius:)`. Each host converts to whatever its own shadow takes:
+// `CALayer.shadowRadius` is a standard deviation and takes it unchanged, GSK's
+// shadow radius is CSS's and takes twice it.
+//
+// The colour is opaque black when the stylesheet left it out, which CSS resolves
+// to `currentColor` and nothing here has: black is what an unstyled view's text
+// would be, and dropping the shadow instead would silently ignore a declaration
+// that is perfectly legal.
+struct FilterShadow {
+  float dx;
+  float dy;
+  float standardDeviation;
+  float red;
+  float green;
+  float blue;
+  float alpha;
+};
+
+// What a list of filters comes to, once the arithmetic is done.
+struct ResolvedFilters {
+  // The seven colour functions, multiplied together. Identity when the list has
+  // none of them.
+  ColorMatrix matrix;
+  bool hasMatrix{false};
+  // The CSS blur radius of every `blur()` in the list, composed: sigmas add in
+  // quadrature, and the radius is twice the sigma on both hosts.
+  float blurRadius{0.0F};
+  // Every `opacity()` multiplied together; 1 when the list has none.
+  float opacity{1.0F};
+  // Every `dropShadow()` in the list, in the order it was written: the first is
+  // the one nearest the content.
+  std::vector<FilterShadow> dropShadows;
+  // Whether there was one at all, which is what the hosts asked before they
+  // could draw one.
+  bool hasDropShadow{false};
+
+  bool empty() const {
+    return !hasMatrix && blurRadius <= 0 && opacity >= 1.0F && dropShadows.empty();
+  }
+};
+
+inline ResolvedFilters resolveFilters(const std::vector<facebook::react::FilterFunction> &filters) {
+  using facebook::react::FilterType;
+
+  ResolvedFilters resolved;
+  double variance = 0.0;
+  for (const auto &filter : filters) {
+    if (filter.type == FilterType::DropShadow) {
+      resolved.hasDropShadow = true;
+      if (!std::holds_alternative<facebook::react::DropShadowParams>(filter.parameters)) {
+        continue;
+      }
+      const auto &params = std::get<facebook::react::DropShadowParams>(filter.parameters);
+      FilterShadow shadow{};
+      shadow.dx = static_cast<float>(params.offsetX);
+      shadow.dy = static_cast<float>(params.offsetY);
+      shadow.standardDeviation =
+          params.standardDeviation > 0 ? static_cast<float>(params.standardDeviation) : 0.0F;
+      if (params.color) {
+        const auto components = facebook::react::colorComponentsFromColor(params.color);
+        shadow.red = components.red;
+        shadow.green = components.green;
+        shadow.blue = components.blue;
+        shadow.alpha = components.alpha;
+      } else {
+        shadow.alpha = 1.0F;
+      }
+      resolved.dropShadows.push_back(shadow);
+      continue;
+    }
+    if (!std::holds_alternative<facebook::react::Float>(filter.parameters)) {
+      continue;
+    }
+    const auto amount = static_cast<float>(std::get<facebook::react::Float>(filter.parameters));
+
+    switch (filter.type) {
+      case FilterType::Blur: {
+        if (amount > 0) {
+          // Sigma is half the radius, as it is for an <Image>'s blurRadius and
+          // for a box shadow; two blurs compose by their variances.
+          const double sigma = static_cast<double>(amount) / 2.0;
+          variance += sigma * sigma;
+        }
+        break;
+      }
+      case FilterType::Opacity:
+        resolved.opacity *= std::clamp(amount, 0.0F, 1.0F);
+        break;
+      case FilterType::Brightness:
+        resolved.matrix = composeColorMatrix(resolved.matrix, detail::scaleRgb(std::max(amount, 0.0F)));
+        resolved.hasMatrix = true;
+        break;
+      case FilterType::Contrast: {
+        const float k = std::max(amount, 0.0F);
+        ColorMatrix contrast = detail::scaleRgb(k);
+        // The intercept that keeps grey in the middle: 0.5 - 0.5k.
+        const float intercept = 0.5F - 0.5F * k;
+        contrast.offset[0] = intercept;
+        contrast.offset[1] = intercept;
+        contrast.offset[2] = intercept;
+        resolved.matrix = composeColorMatrix(resolved.matrix, contrast);
+        resolved.hasMatrix = true;
+        break;
+      }
+      case FilterType::Grayscale:
+        // Grayscale is saturate from the other end: 1 is fully grey.
+        resolved.matrix = composeColorMatrix(
+            resolved.matrix, detail::saturate(1.0F - std::clamp(amount, 0.0F, 1.0F)));
+        resolved.hasMatrix = true;
+        break;
+      case FilterType::Saturate:
+        resolved.matrix = composeColorMatrix(resolved.matrix, detail::saturate(amount));
+        resolved.hasMatrix = true;
+        break;
+      case FilterType::HueRotate:
+        resolved.matrix = composeColorMatrix(resolved.matrix, detail::hueRotate(amount));
+        resolved.hasMatrix = true;
+        break;
+      case FilterType::Invert: {
+        const float a = std::clamp(amount, 0.0F, 1.0F);
+        // out = a(1 - c) + (1 - a)c = (1 - 2a)c + a.
+        ColorMatrix invert = detail::scaleRgb(1.0F - 2.0F * a);
+        invert.offset[0] = a;
+        invert.offset[1] = a;
+        invert.offset[2] = a;
+        resolved.matrix = composeColorMatrix(resolved.matrix, invert);
+        resolved.hasMatrix = true;
+        break;
+      }
+      case FilterType::Sepia:
+        resolved.matrix = composeColorMatrix(resolved.matrix, detail::sepia(amount));
+        resolved.hasMatrix = true;
+        break;
+      case FilterType::DropShadow:
+        break;
+    }
+  }
+  if (variance > 0) {
+    resolved.blurRadius = static_cast<float>(std::sqrt(variance) * 2.0);
+  }
+  return resolved;
+}
+
+} // namespace basalt

package/native/core/FontFitting.h

@@ -0,0 +1,183 @@
+// `adjustsFontSizeToFit`, and the two props that bound it.
+//
+// A label that says "Delete all messages" in a button sized for "Delete" has
+// two ways to go wrong: it can overflow, or it can be cut off. React Native's
+// third way is to shrink the text until it fits, which is what this prop asks
+// for, and the two beside it -- `minimumFontSize` and `maximumFontSize` -- say
+// how far that is allowed to go.
+//
+// ## Why it is here rather than in three hosts
+//
+// Finding the ratio is a search, and the search is the same on every platform:
+// measure, compare, halve the interval. What differs is the measuring, which is
+// the one thing each toolkit knows and this does not -- so the search takes the
+// measurement as a callable and nothing in this file knows what a glyph is.
+//
+// The alternative was three bisections, which is how the three scroll ranges
+// and the three snapping rules started before `core/ScrollBounds.h` and
+// `core/ScrollSnap.h`.
+//
+// ## The algorithm is upstream's, deliberately
+//
+// `NSTextStorage+FontScaling.m` is a bisection between a ratio of 1/128 and
+// one of 128, with three rules worth naming because each one is a decision:
+//
+//   - **Text that already fits is not touched.** Upstream returns before the
+//     search, which is why the prop never *grows* text although the interval
+//     reaches 128: a paragraph that fits is done.
+//   - **A fit within one per cent of the box's width is good enough**, and the
+//     search stops there rather than finding the largest ratio that fits.
+//     Without it the search runs its full depth on every paragraph.
+//   - **The last ratio that fitted wins** when the interval closes, which is
+//     not the same as the last ratio tried: the final probe is as likely to be
+//     one that did not fit.
+//
+// Each font size is multiplied by the ratio and then clamped to the two props,
+// so a paragraph of mixed sizes keeps its proportions until the clamp bites.
+
+#pragma once
+
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+
+#include <algorithm>
+#include <cmath>
+
+namespace basalt {
+
+// A size, in the logical points everything here measures in.
+struct FontFitBox {
+  double width{0.0};
+  double height{0.0};
+};
+
+// How to scale a paragraph's fonts, and how far.
+//
+// A ratio of exactly 1 means "leave every size alone", which is both the
+// default and what a paragraph that already fits resolves to -- and it skips
+// the clamp as well, because `minimumFontSize` and `maximumFontSize` bound the
+// *fitting* rather than the text. A 200pt heading in an app that set a maximum
+// of 96 is still 200pt when it fits.
+struct FontFit {
+  double ratio{1.0};
+  double minimum{4.0};
+  double maximum{96.0};
+  // `minimumFontScale`: the same floor as `minimumFontSize`, said as a ratio
+  // instead. Android's spelling of the prop, which iOS ignores -- and there is
+  // no reason to ignore it here, the search being a search over exactly this
+  // ratio. Zero means the app said nothing.
+  double minimumRatio{0.0};
+
+  bool scales() const { return ratio != 1.0; }
+
+  double apply(double size) const {
+    if (ratio == 1.0) {
+      return size;
+    }
+    return std::clamp(size * ratio, minimum, maximum);
+  }
+};
+
+// iOS's own defaults for the two bounds, which React Native documents nowhere
+// else: 4 and 96 points, from `RCTTextLayoutManager`.
+inline constexpr double kFontFitMinimumSize = 4.0;
+inline constexpr double kFontFitMaximumSize = 96.0;
+
+// The bounds a paragraph asked for, with those defaults for the props it left
+// unset -- which arrive as NaN, React Native's "nothing here".
+inline FontFit fontFitLimits(const facebook::react::ParagraphAttributes &paragraphAttributes) {
+  FontFit fit;
+  if (!std::isnan(paragraphAttributes.minimumFontSize)) {
+    fit.minimum = static_cast<double>(paragraphAttributes.minimumFontSize);
+  }
+  if (!std::isnan(paragraphAttributes.maximumFontSize)) {
+    fit.maximum = static_cast<double>(paragraphAttributes.maximumFontSize);
+  }
+  // A minimum above the maximum is an app contradicting itself; the minimum
+  // wins, so the text is readable rather than invisible.
+  fit.maximum = std::max(fit.maximum, fit.minimum);
+  // `minimumFontScale`, clamped to the range React Native's own comment gives
+  // for it: 0.01 to 1. A scale of 1 is a paragraph that may not shrink at all,
+  // which is a legal thing to ask for and worth not treating as "unset".
+  if (!std::isnan(paragraphAttributes.minimumFontScale)) {
+    fit.minimumRatio = std::clamp(static_cast<double>(paragraphAttributes.minimumFontScale),
+                                  0.01,
+                                  1.0);
+  }
+  return fit;
+}
+
+// Whether a box is one a paragraph can be fitted to at all.
+//
+// An infinite dimension is Yoga saying "as much as you need", and there is
+// nothing to shrink to fit: a paragraph measured unconstrained always fits.
+inline bool fontFitBoxIsFinite(const FontFitBox &box) {
+  return std::isfinite(box.width) && std::isfinite(box.height) && box.width > 0.0
+      && box.height > 0.0;
+}
+
+// The ratio that makes `measure` fit inside `box`.
+//
+// `measure` is called with a ratio and answers the size the paragraph takes
+// with every font size scaled by it -- which is the host's job, and the only
+// part of this that knows what text is.
+template <typename Measure>
+FontFit fontFitToBox(FontFit limits, const Measure &measure, const FontFitBox &box) {
+  if (!fontFitBoxIsFinite(box)) {
+    return limits;
+  }
+
+  const auto fits = [&box](const FontFitBox &size) {
+    return size.width <= box.width && size.height <= box.height;
+  };
+
+  // Text that already fits is not touched, which is upstream's first move and
+  // the reason this never grows anything.
+  const FontFitBox unscaled = measure(1.0);
+  if (fits(unscaled)) {
+    return limits;
+  }
+
+  // `minimumFontScale` is the floor when an app named one, and upstream's
+  // 1/128 otherwise. Searching below the floor would be searching for an
+  // answer the app has refused.
+  double bottom = std::max(1.0 / 128.0, limits.minimumRatio);
+  double top = 1.0;
+  // Upstream's floor for "nothing fitted", so a paragraph that cannot fit at
+  // all comes out tiny rather than unscaled -- and no smaller than the ratio
+  // the app allowed.
+  double lastThatFits = std::max(0.02, limits.minimumRatio);
+  double ratio = (top + bottom) / 2.0;
+
+  // A fit within this much of the box's width is good enough. Without it the
+  // search runs its full depth on every paragraph that needs shrinking.
+  constexpr double kCloseEnough = 0.01;
+  // And this is when the interval has closed, which bounds the loop at about
+  // eight probes.
+  constexpr double kSettled = 0.005;
+
+  while (true) {
+    FontFit candidate = limits;
+    candidate.ratio = ratio;
+    const FontFitBox size = measure(ratio);
+    if (fits(size)) {
+      if (box.width - size.width < box.width * kCloseEnough) {
+        return candidate;
+      }
+      bottom = ratio;
+      lastThatFits = ratio;
+    } else {
+      top = ratio;
+    }
+
+    const double next = (top + bottom) / 2.0;
+    if (std::abs(top - bottom) < kSettled || std::abs(top - next) < kSettled
+        || std::abs(bottom - next) < kSettled) {
+      FontFit settled = limits;
+      settled.ratio = lastThatFits;
+      return settled;
+    }
+    ratio = next;
+  }
+}
+
+} // namespace basalt

package/native/core/FontScaling.h

@@ -0,0 +1,153 @@
+// `allowFontScaling`, `maxFontSizeMultiplier` and the system's text scale.
+//
+// Three props and one platform setting that together decide what size a
+// fragment is actually drawn at. Both hosts had the same four lines of it,
+// multiplying by `fontSizeMultiplier` when it was set, and neither read the two
+// props that are there to control that multiplication: an app that says
+// `allowFontScaling={false}` means "do not grow this text when the system is
+// set to large text", which is the usual thing to say about a label whose box
+// cannot grow.
+//
+// ## Where the multiplier comes from, which differs from iOS
+//
+// `fontSizeMultiplier` is a prop, and React Native's JavaScript never sets it:
+// it stays NaN. iOS gets its scaling from `dynamicTypeRamp` and `UIFontMetrics`
+// instead, and Android gets it from the device configuration's `fontScale`,
+// which is a scalar the platform owns. A desktop is the Android shape of the
+// problem: GTK publishes a text scale through `GtkSettings:gtk-xft-dpi`, and
+// Windows through `UISettings.TextScaleFactor`, so the host passes what its
+// platform says and nothing has to invent one. macOS publishes no scalar at
+// all, which is why its scale is 1 and why that is recorded rather than faked.
+//
+// So the two multiply, which is Android's arrangement: the system's scale times
+// whatever the prop says. Not "the prop when it is set, the scale otherwise",
+// which was the first version of this and was wrong in a way worth recording:
+// `TextAttributes::defaultTextAttributes()` sets `fontSizeMultiplier` to **1**
+// rather than to NaN, so every fragment arrives with one set and a prop-first
+// rule cancels the platform's scale on every paragraph in the app. The probe
+// that found it printed `size=16 scale=1.6`.
+//
+// The clamping is upstream's, copied from
+// `RCTEffectiveFontSizeMultiplierFromTextAttributes`: `maxFontSizeMultiplier`
+// applies only when it is at least 1, because 0 and NaN are both how React
+// Native spells "no limit", and a limit below 1 would shrink text that nothing
+// asked to shrink. It applies to the product, so it caps total growth, which is
+// what an app asking for "no more than a quarter larger" means.
+//
+// `dynamicTypeRamp` is not here. It names a `UIFontMetrics` text style, which
+// is an iOS API with no desktop equivalent; backlog/text.md records it.
+
+#pragma once
+
+#include <react/renderer/attributedstring/TextAttributes.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstdlib>
+
+namespace basalt {
+
+namespace detail {
+
+inline std::atomic<float> &systemFontScaleStorage() {
+  static std::atomic<float> scale{1.0F};
+  return scale;
+}
+
+} // namespace detail
+
+// What a test asked for, or nothing.
+//
+// `BASALT_TEST_FONT_SCALE` is here because two of the three platforms publish
+// no text scale at all, so a scenario on them could otherwise never see the
+// difference `allowFontScaling` makes, and a feature with no test that fails
+// when it is removed is not finished.
+//
+// Not in core/TestSettle.h's list of scripted input, deliberately: that list is
+// what a host schedules on its timer, and this schedules nothing. It is a
+// setting read once, the way `BASALT_TEST_DIALOG` answers rather than acts.
+inline float testFontScale() {
+  static const float requested = []() -> float {
+    const char *const value = std::getenv("BASALT_TEST_FONT_SCALE");
+    if (value == nullptr || *value == '\0') {
+      return 0.0F;
+    }
+    char *end = nullptr;
+    const double parsed = std::strtod(value, &end);
+    if (end == value || !(parsed > 0.0)) {
+      return 0.0F;
+    }
+    return static_cast<float>(parsed);
+  }();
+  return requested;
+}
+
+// The scale the platform reports, which a host reads once at startup.
+//
+// Read once, and on the main thread, because that is where a platform's
+// settings object may be touched: GTK measures text off the main thread, so
+// asking `GtkSettings` from inside the text builder would be asking it from the
+// wrong thread. The cost is that a scale changed while the app is running does
+// not reflow text that is already laid out; backlog/text.md records the signal
+// that would.
+inline void setSystemFontScale(float scale) {
+  detail::systemFontScaleStorage().store(scale > 0.0F ? scale : 1.0F,
+                                         std::memory_order_relaxed);
+}
+
+// What the text builders multiply by. A test's scale wins over the platform's,
+// which is the only way a platform that has none can be tested at all.
+inline float systemFontScale() {
+  const float requested = testFontScale();
+  return requested > 0.0F
+      ? requested
+      : detail::systemFontScaleStorage().load(std::memory_order_relaxed);
+}
+
+// What `fontSize` is multiplied by, given what the platform reports.
+//
+// `systemScale` is the platform's text scale: 1 where there is none, and
+// whatever the setting says where there is. A scale that is not a positive
+// number is 1, because a zero or negative one would make text disappear and a
+// setting is not worth trusting that far.
+inline float effectiveFontSizeMultiplier(
+    const facebook::react::TextAttributes &textAttributes,
+    float systemScale) {
+  if (!textAttributes.allowFontScaling.value_or(true)) {
+    return 1.0F;
+  }
+
+  if (!(systemScale > 0.0F)) {
+    systemScale = 1.0F;
+  }
+  // A multiplier that is not a positive number is 1 rather than nothing: NaN is
+  // "unset" and zero would multiply the text away.
+  const float requested = (!std::isnan(textAttributes.fontSizeMultiplier) &&
+                           textAttributes.fontSizeMultiplier > 0.0)
+      ? static_cast<float>(textAttributes.fontSizeMultiplier)
+      : 1.0F;
+  const float multiplier = requested * systemScale;
+
+  const float limit = std::isnan(textAttributes.maxFontSizeMultiplier)
+      ? 0.0F
+      : static_cast<float>(textAttributes.maxFontSizeMultiplier);
+  return limit >= 1.0F ? std::min(limit, multiplier) : multiplier;
+}
+
+// The size a fragment is drawn at, in density-independent pixels.
+//
+// `defaultFontSize` is the host's own default, which differs between them
+// because the platforms' system fonts do; `fontSize` being unset is NaN rather
+// than zero.
+inline float effectiveFontSize(
+    const facebook::react::TextAttributes &textAttributes,
+    float defaultFontSize,
+    float systemScale) {
+  const float size = std::isnan(textAttributes.fontSize)
+      ? defaultFontSize
+      : static_cast<float>(textAttributes.fontSize);
+  return size * effectiveFontSizeMultiplier(textAttributes, systemScale);
+}
+
+} // namespace basalt