one 2.10.0 → 2.11.1

package/linux/cpp/imagemanager/OneLinuxImageManager.cpp

@@ -0,0 +1,213 @@
+#include <react/renderer/imagemanager/ImageManager.h>
+#include <react/renderer/imagemanager/ImageResponse.h>
+#include <react/renderer/imagemanager/ImageTelemetry.h>
+
+#include <gdk/gdk.h>
+#include <libsoup/soup.h>
+
+#include <string>
+
+using namespace facebook::react;
+
+// The host's ImageManager: loads http(s), file and data URIs and hands the
+// decoded GdkTexture to the request's observers on the main thread. The cxx
+// stub that ships with react-native is left out of the core build.
+
+namespace {
+
+struct Load {
+  ImageSource source;
+  std::weak_ptr<const ImageResponseObserverCoordinator> coordinator;
+  GCancellable *cancellable{nullptr};
+
+  ~Load()
+  {
+    if (cancellable) {
+      g_cancellable_cancel(cancellable);
+      g_object_unref(cancellable);
+    }
+  }
+};
+
+using LoadPointer = std::shared_ptr<Load>;
+
+SoupSession *session()
+{
+  static SoupSession *shared = soup_session_new();
+  return shared;
+}
+
+void fail(const LoadPointer &load, const std::string &message)
+{
+  if (auto coordinator = load->coordinator.lock()) {
+    coordinator->nativeImageResponseFailed(ImageLoadError(std::make_shared<std::string>(message)));
+  }
+}
+
+void decodeInThread(GTask *task, gpointer, gpointer data, GCancellable *)
+{
+  GError *error = nullptr;
+  GdkTexture *texture = gdk_texture_new_from_bytes(static_cast<GBytes *>(data), &error);
+  if (texture) {
+    g_task_return_pointer(task, texture, g_object_unref);
+  } else {
+    g_task_return_error(task, error);
+  }
+}
+
+void decoded(GObject *, GAsyncResult *result, gpointer data)
+{
+  auto *load = static_cast<LoadPointer *>(data);
+  GError *error = nullptr;
+  auto *texture = static_cast<GdkTexture *>(g_task_propagate_pointer(G_TASK(result), &error));
+  if (texture) {
+    if (auto coordinator = (*load)->coordinator.lock()) {
+      std::shared_ptr<void> holder(texture, [](void *pointer) { g_object_unref(pointer); });
+      coordinator->nativeImageResponseComplete(ImageResponse(holder, nullptr));
+    } else {
+      g_object_unref(texture);
+    }
+  } else {
+    if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+      fail(*load, "image could not be decoded: " + std::string(error->message));
+    }
+    g_error_free(error);
+  }
+  delete load;
+}
+
+// takes the bytes; decoding runs off the main thread
+void decode(const LoadPointer &load, GBytes *bytes)
+{
+  GTask *task = g_task_new(nullptr, load->cancellable, decoded, new LoadPointer(load));
+  g_task_set_task_data(task, bytes, reinterpret_cast<GDestroyNotify>(g_bytes_unref));
+  g_task_run_in_thread(task, decodeInThread);
+  g_object_unref(task);
+}
+
+void loadedFile(GObject *source, GAsyncResult *result, gpointer data)
+{
+  auto *load = static_cast<LoadPointer *>(data);
+  GError *error = nullptr;
+  GBytes *bytes = g_file_load_bytes_finish(G_FILE(source), result, nullptr, &error);
+  if (bytes) {
+    decode(*load, bytes);
+  } else {
+    if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+      fail(*load, error->message);
+    }
+    g_error_free(error);
+  }
+  delete load;
+}
+
+void receivedBody(GObject *, GAsyncResult *result, gpointer data)
+{
+  auto *state = static_cast<std::pair<LoadPointer, SoupMessage *> *>(data);
+  GError *error = nullptr;
+  GBytes *bytes = soup_session_send_and_read_finish(session(), result, &error);
+  if (bytes && SOUP_STATUS_IS_SUCCESSFUL(soup_message_get_status(state->second))) {
+    decode(state->first, bytes);
+  } else if (bytes) {
+    g_bytes_unref(bytes);
+    fail(state->first, "HTTP " + std::to_string(soup_message_get_status(state->second)));
+  } else {
+    if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+      fail(state->first, error->message);
+    }
+    g_error_free(error);
+  }
+  g_object_unref(state->second);
+  delete state;
+}
+
+bool startsWith(const std::string &text, const char *prefix)
+{
+  return text.rfind(prefix, 0) == 0;
+}
+
+gboolean begin(gpointer data)
+{
+  auto *loadPointer = static_cast<LoadPointer *>(data);
+  const LoadPointer &load = *loadPointer;
+  const std::string &uri = load->source.uri;
+  // a request already running, or one that finished, has nothing to resume
+  if (!load->cancellable) {
+    load->cancellable = g_cancellable_new();
+    if (startsWith(uri, "http://") || startsWith(uri, "https://")) {
+      SoupMessage *message = soup_message_new(load->source.method.empty() ? SOUP_METHOD_GET : load->source.method.c_str(), uri.c_str());
+      if (!message) {
+        fail(load, "invalid image uri");
+      } else {
+        for (const auto &header : load->source.headers) {
+          soup_message_headers_replace(soup_message_get_request_headers(message), header.first.c_str(), header.second.c_str());
+        }
+        soup_session_send_and_read_async(
+            session(), message, G_PRIORITY_DEFAULT, load->cancellable, receivedBody, new std::pair<LoadPointer, SoupMessage *>(load, message));
+      }
+    } else if (startsWith(uri, "data:")) {
+      size_t comma = uri.find(',');
+      bool base64 = comma != std::string::npos && uri.substr(0, comma).find(";base64") != std::string::npos;
+      if (comma == std::string::npos) {
+        fail(load, "invalid data uri");
+      } else if (base64) {
+        gsize length = 0;
+        guchar *bytes = g_base64_decode(uri.c_str() + comma + 1, &length);
+        decode(load, g_bytes_new_take(bytes, length));
+      } else {
+        gchar *text = g_uri_unescape_string(uri.c_str() + comma + 1, nullptr);
+        decode(load, g_bytes_new_take(text, strlen(text)));
+      }
+    } else if (startsWith(uri, "file://") || startsWith(uri, "/")) {
+      GFile *file = startsWith(uri, "/") ? g_file_new_for_path(uri.c_str()) : g_file_new_for_uri(uri.c_str());
+      g_file_load_bytes_async(file, load->cancellable, loadedFile, new LoadPointer(load));
+      g_object_unref(file);
+    } else {
+      fail(load, "unsupported image uri " + uri);
+    }
+  }
+  delete loadPointer;
+  return G_SOURCE_REMOVE;
+}
+
+gboolean cancel(gpointer data)
+{
+  auto *loadPointer = static_cast<LoadPointer *>(data);
+  if ((*loadPointer)->cancellable) {
+    g_cancellable_cancel((*loadPointer)->cancellable);
+    g_object_unref((*loadPointer)->cancellable);
+    (*loadPointer)->cancellable = nullptr;
+  }
+  delete loadPointer;
+  return G_SOURCE_REMOVE;
+}
+
+// requests start from the layout thread; GLib sources attach to the main context
+void onMain(GSourceFunc function, const LoadPointer &load)
+{
+  g_main_context_invoke(nullptr, function, new LoadPointer(load));
+}
+
+} // namespace
+
+ImageManager::ImageManager(const std::shared_ptr<const ContextContainer> &) {}
+
+ImageManager::~ImageManager() {}
+
+ImageRequest ImageManager::requestImage(
+    const ImageSource &imageSource, SurfaceId surfaceId, const ImageRequestParams &, Tag) const
+{
+  auto telemetry = std::make_shared<ImageTelemetry>(surfaceId);
+  if (imageSource.type == ImageSource::Type::Invalid || imageSource.uri.empty()) {
+    return {imageSource, telemetry, {}};
+  }
+
+  auto load = std::make_shared<Load>();
+  load->source = imageSource;
+  SharedFunction<> resume([load] { onMain(begin, load); });
+  SharedFunction<> cancelRequest([load] { onMain(cancel, load); });
+  ImageRequest request(imageSource, telemetry, std::move(resume), std::move(cancelRequest));
+  load->coordinator = request.getSharedObserverCoordinator();
+  onMain(begin, load);
+  return request;
+}

package/linux/cpp/nitro/NitroLinuxPlatform.cpp

@@ -0,0 +1,67 @@
+// the Linux counterparts of Nitro's ios/platform sources: logging to stderr and
+// thread helpers with the GLib main thread as the UI thread
+
+#include "NitroDefines.hpp"
+#include "NitroLogger.hpp"
+#include "ThreadUtils.hpp"
+
+#include <glib.h>
+#include <pthread.h>
+
+#include <cstdio>
+#include <functional>
+
+namespace margelo::nitro {
+
+void Logger::nativeLog([[maybe_unused]] LogLevel level,
+                       [[maybe_unused]] const char* NON_NULL tag,
+                       [[maybe_unused]] const std::string& message) {
+#ifdef NITRO_DEBUG
+  std::fprintf(stderr, "[nitro] [%s] %s\n", tag, message.c_str());
+#endif
+}
+
+namespace {
+
+class MainContextDispatcher final : public Dispatcher {
+public:
+  void runSync(std::function<void()>&&) override {
+    throw std::runtime_error("MainContextDispatcher::runSync() is not implemented!");
+  }
+
+  void runAsync(std::function<void()>&& function) override {
+    auto* heap = new std::function<void()>(std::move(function));
+    g_idle_add_full(
+        G_PRIORITY_DEFAULT,
+        [](gpointer data) -> gboolean {
+          auto* call = static_cast<std::function<void()>*>(data);
+          (*call)();
+          return G_SOURCE_REMOVE;
+        },
+        heap, [](gpointer data) { delete static_cast<std::function<void()>*>(data); });
+  }
+};
+
+} // namespace
+
+std::string ThreadUtils::getThreadName() {
+  char threadName[64] = {};
+  if (pthread_getname_np(pthread_self(), threadName, sizeof(threadName)) == 0 && threadName[0] != '\0') {
+    return std::string(threadName);
+  }
+  return "unnamed thread";
+}
+
+void ThreadUtils::setThreadName(const std::string& name) {
+  pthread_setname_np(pthread_self(), name.substr(0, 15).c_str());
+}
+
+bool ThreadUtils::isUIThread() {
+  return g_main_context_is_owner(g_main_context_default());
+}
+
+std::shared_ptr<Dispatcher> ThreadUtils::createUIThreadDispatcher() {
+  return std::make_shared<MainContextDispatcher>();
+}
+
+} // namespace margelo::nitro

package/linux/cpp/textlayoutmanager/OneLinuxText.cpp

@@ -0,0 +1,258 @@
+#include "OneLinuxText.h"
+
+#include <pango/pangocairo.h>
+
+#include <react/renderer/graphics/Color.h>
+
+#include <cmath>
+#include <string>
+
+namespace facebook::react {
+
+namespace {
+
+// one context per thread: layout runs on the js thread and painting on the main
+// thread, and pango font maps are not shared across threads
+PangoContext *threadContext()
+{
+  thread_local PangoContext *context = [] {
+    PangoContext *created = pango_font_map_create_context(pango_cairo_font_map_get_default());
+    cairo_font_options_t *options = cairo_font_options_create();
+    cairo_font_options_set_hint_metrics(options, CAIRO_HINT_METRICS_OFF);
+    cairo_font_options_set_hint_style(options, CAIRO_HINT_STYLE_NONE);
+    pango_cairo_context_set_font_options(created, options);
+    cairo_font_options_destroy(options);
+    return created;
+  }();
+  return context;
+}
+
+std::string transformed(const std::string &text, std::optional<TextTransform> transform)
+{
+  if (!transform) {
+    return text;
+  }
+  switch (*transform) {
+    case TextTransform::Uppercase: {
+      gchar *converted = g_utf8_strup(text.c_str(), -1);
+      std::string result(converted);
+      g_free(converted);
+      return result;
+    }
+    case TextTransform::Lowercase: {
+      gchar *converted = g_utf8_strdown(text.c_str(), -1);
+      std::string result(converted);
+      g_free(converted);
+      return result;
+    }
+    case TextTransform::Capitalize: {
+      std::string result;
+      bool wordStart = true;
+      for (const gchar *p = text.c_str(); *p; p = g_utf8_next_char(p)) {
+        gunichar character = g_utf8_get_char(p);
+        if (g_unichar_isspace(character)) {
+          wordStart = true;
+        } else if (wordStart) {
+          character = g_unichar_totitle(character);
+          wordStart = false;
+        }
+        gchar buffer[8];
+        result.append(buffer, g_unichar_to_utf8(character, buffer));
+      }
+      return result;
+    }
+    default:
+      return text;
+  }
+}
+
+PangoFontDescription *fontDescription(const TextAttributes &attributes)
+{
+  PangoFontDescription *description = pango_font_description_new();
+  const std::string &family = attributes.fontFamily;
+  bool isSystem = family.empty() || family == "System" || family == "system-ui" || family == "-apple-system";
+  pango_font_description_set_family(description, isSystem ? "sans" : family.c_str());
+  double size = std::isnan(attributes.fontSize) ? 14 : attributes.fontSize;
+  pango_font_description_set_absolute_size(description, size * PANGO_SCALE);
+  pango_font_description_set_weight(
+      description, static_cast<PangoWeight>(attributes.fontWeight ? static_cast<int>(*attributes.fontWeight) : 400));
+  if (attributes.fontStyle && *attributes.fontStyle != FontStyle::Normal) {
+    pango_font_description_set_style(description, PANGO_STYLE_ITALIC);
+  }
+  return description;
+}
+
+guint16 channel(float value)
+{
+  return static_cast<guint16>(std::lround(std::clamp(value, 0.0f, 1.0f) * 65535));
+}
+
+void addColor(PangoAttrList *list, SharedColor color, double opacityScale, guint start, guint end, bool foreground)
+{
+  auto components = colorComponentsFromColor(color);
+  PangoAttribute *rgb = foreground ? pango_attr_foreground_new(channel(components.red), channel(components.green), channel(components.blue))
+                                   : pango_attr_background_new(channel(components.red), channel(components.green), channel(components.blue));
+  PangoAttribute *alpha = foreground ? pango_attr_foreground_alpha_new(channel(components.alpha * opacityScale))
+                                     : pango_attr_background_alpha_new(channel(components.alpha * opacityScale));
+  rgb->start_index = alpha->start_index = start;
+  rgb->end_index = alpha->end_index = end;
+  pango_attr_list_insert(list, rgb);
+  pango_attr_list_insert(list, alpha);
+}
+
+PangoAlignment alignmentValue(std::optional<TextAlignment> alignment)
+{
+  if (!alignment) {
+    return PANGO_ALIGN_LEFT;
+  }
+  switch (*alignment) {
+    case TextAlignment::Center: return PANGO_ALIGN_CENTER;
+    case TextAlignment::Right: return PANGO_ALIGN_RIGHT;
+    default: return PANGO_ALIGN_LEFT;
+  }
+}
+
+PangoEllipsizeMode ellipsizeValue(EllipsizeMode mode)
+{
+  switch (mode) {
+    case EllipsizeMode::Head: return PANGO_ELLIPSIZE_START;
+    case EllipsizeMode::Middle: return PANGO_ELLIPSIZE_MIDDLE;
+    case EllipsizeMode::Tail: return PANGO_ELLIPSIZE_END;
+    case EllipsizeMode::Clip: return PANGO_ELLIPSIZE_NONE;
+  }
+  return PANGO_ELLIPSIZE_NONE;
+}
+
+} // namespace
+
+PangoLayout *OneLinuxCreateLayout(
+    const AttributedString &attributedString,
+    const ParagraphAttributes &paragraphAttributes,
+    double width,
+    bool applyAlignment,
+    std::vector<OneLinuxTextAttachment> *attachments)
+{
+  std::string text;
+  PangoAttrList *list = pango_attr_list_new();
+  std::optional<TextAlignment> alignment;
+
+  for (const auto &fragment : attributedString.getFragments()) {
+    const TextAttributes &attributes = fragment.textAttributes;
+    if (!alignment) {
+      alignment = attributes.alignment;
+    }
+    guint start = static_cast<guint>(text.size());
+    text += fragment.isAttachment() ? "\xef\xbf\xbc" : transformed(fragment.string, attributes.textTransform);
+    guint end = static_cast<guint>(text.size());
+    if (start == end) {
+      continue;
+    }
+
+    if (fragment.isAttachment()) {
+      auto size = fragment.parentShadowView.layoutMetrics.frame.size;
+      PangoRectangle ink{};
+      PangoRectangle logical{0, -static_cast<int>(std::ceil(size.height * PANGO_SCALE)),
+                             static_cast<int>(std::ceil(size.width * PANGO_SCALE)),
+                             static_cast<int>(std::ceil(size.height * PANGO_SCALE))};
+      PangoAttribute *shape = pango_attr_shape_new(&ink, &logical);
+      shape->start_index = start;
+      shape->end_index = end;
+      pango_attr_list_insert(list, shape);
+      if (attachments) {
+        attachments->push_back({static_cast<int>(start), size});
+      }
+    }
+
+    PangoFontDescription *description = fontDescription(attributes);
+    PangoAttribute *font = pango_attr_font_desc_new(description);
+    font->start_index = start;
+    font->end_index = end;
+    pango_attr_list_insert(list, font);
+    pango_font_description_free(description);
+
+    double opacity = std::isnan(attributes.opacity) ? 1 : attributes.opacity;
+    if (attributes.foregroundColor) {
+      addColor(list, attributes.foregroundColor, opacity, start, end, true);
+    }
+    if (attributes.backgroundColor) {
+      addColor(list, attributes.backgroundColor, opacity, start, end, false);
+    }
+    if (!std::isnan(attributes.letterSpacing)) {
+      PangoAttribute *spacing = pango_attr_letter_spacing_new(static_cast<int>(attributes.letterSpacing * PANGO_SCALE));
+      spacing->start_index = start;
+      spacing->end_index = end;
+      pango_attr_list_insert(list, spacing);
+    }
+    if (!std::isnan(attributes.lineHeight) && attributes.lineHeight > 0) {
+      PangoAttribute *lineHeight = pango_attr_line_height_new_absolute(static_cast<int>(attributes.lineHeight * PANGO_SCALE));
+      lineHeight->start_index = start;
+      lineHeight->end_index = end;
+      pango_attr_list_insert(list, lineHeight);
+    }
+    if (attributes.textDecorationLineType) {
+      auto line = *attributes.textDecorationLineType;
+      if (line == TextDecorationLineType::Underline || line == TextDecorationLineType::UnderlineStrikethrough) {
+        PangoAttribute *underline = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE);
+        underline->start_index = start;
+        underline->end_index = end;
+        pango_attr_list_insert(list, underline);
+      }
+      if (line == TextDecorationLineType::Strikethrough || line == TextDecorationLineType::UnderlineStrikethrough) {
+        PangoAttribute *strike = pango_attr_strikethrough_new(TRUE);
+        strike->start_index = start;
+        strike->end_index = end;
+        pango_attr_list_insert(list, strike);
+      }
+    }
+  }
+
+  PangoLayout *layout = pango_layout_new(threadContext());
+  pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.size()));
+  pango_layout_set_attributes(layout, list);
+  pango_attr_list_unref(list);
+  pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
+  if (width >= 0) {
+    pango_layout_set_width(layout, static_cast<int>(std::ceil(width * PANGO_SCALE)));
+    if (paragraphAttributes.maximumNumberOfLines > 0) {
+      pango_layout_set_ellipsize(layout, ellipsizeValue(paragraphAttributes.ellipsizeMode));
+      pango_layout_set_height(layout, -paragraphAttributes.maximumNumberOfLines);
+    }
+  }
+  if (applyAlignment) {
+    pango_layout_set_alignment(layout, alignmentValue(alignment));
+    pango_layout_set_justify(layout, alignment && *alignment == TextAlignment::Justified);
+  }
+  return layout;
+}
+
+// a GtkText measures its line from the font its style gives it, so the field's
+// font goes in its style rather than in the text attributes; the placeholder
+// then shares it
+std::string OneLinuxCreateFieldFontCss(const TextAttributes &attributes, const char *selector)
+{
+  PangoFontDescription *description = fontDescription(attributes);
+  std::string css = std::string(selector) + " { font-family: \"" + std::string(pango_font_description_get_family(description)) + "\"; font-size: " +
+      std::to_string(pango_font_description_get_size(description) / static_cast<double>(PANGO_SCALE)) + "px; font-weight: " +
+      std::to_string(static_cast<int>(pango_font_description_get_weight(description))) + "; font-style: " +
+      (pango_font_description_get_style(description) == PANGO_STYLE_ITALIC ? "italic" : "normal") + "; }";
+  pango_font_description_free(description);
+  return css;
+}
+
+std::string OneLinuxCreateColorCss(const SharedColor &color, double opacity, const char *selector, const char *property)
+{
+  if (!color) {
+    return "";
+  }
+  auto components = colorComponentsFromColor(color);
+  return std::string(selector) + " { " + property + ": rgba(" + std::to_string(static_cast<int>(std::lround(components.red * 255))) + ", " +
+      std::to_string(static_cast<int>(std::lround(components.green * 255))) + ", " +
+      std::to_string(static_cast<int>(std::lround(components.blue * 255))) + ", " + std::to_string(components.alpha * opacity) + "); }";
+}
+
+std::string OneLinuxCreateFieldColorCss(const TextAttributes &attributes, const char *selector)
+{
+  return OneLinuxCreateColorCss(attributes.foregroundColor, std::isnan(attributes.opacity) ? 1 : attributes.opacity, selector, "color");
+}
+
+} // namespace facebook::react

package/linux/cpp/textlayoutmanager/OneLinuxText.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <pango/pango.h>
+#include <vector>
+
+#include <react/renderer/attributedstring/AttributedString.h>
+#include <react/renderer/attributedstring/ParagraphAttributes.h>
+#include <react/renderer/attributedstring/TextAttributes.h>
+
+namespace facebook::react {
+
+struct OneLinuxTextAttachment {
+  int index;
+  Size size;
+};
+
+// builds the PangoLayout that both measurement and painting use. sizes are in
+// logical pixels with metric hinting off, so a measured size reproduces when
+// the layout is drawn at any scale. `width` below zero lays the text out
+// unwrapped. The caller owns the returned layout.
+PangoLayout *OneLinuxCreateLayout(
+    const AttributedString &attributedString,
+    const ParagraphAttributes &paragraphAttributes,
+    double width,
+    bool applyAlignment,
+    std::vector<OneLinuxTextAttachment> *attachments = nullptr);
+
+// the editable field's font as CSS for the node named by selector
+std::string OneLinuxCreateFieldFontCss(const TextAttributes &attributes, const char *selector = "text");
+// one color as a CSS rule for `property`; empty when the color is unset
+std::string OneLinuxCreateColorCss(const SharedColor &color, double opacity, const char *selector, const char *property);
+std::string OneLinuxCreateFieldColorCss(const TextAttributes &attributes, const char *selector);
+
+} // namespace facebook::react

package/linux/cpp/textlayoutmanager/react/renderer/textlayoutmanager/TextLayoutManager.cpp

@@ -0,0 +1,101 @@
+#include "TextLayoutManager.h"
+
+#include <react/renderer/attributedstring/PlaceholderAttributedString.h>
+#include <react/renderer/telemetry/TransactionTelemetry.h>
+#include <react/renderer/textlayoutmanager/TextMeasurementRounding.h>
+
+#include <algorithm>
+
+#include "OneLinuxText.h"
+
+namespace facebook::react {
+
+TextLayoutManager::TextLayoutManager(const std::shared_ptr<const ContextContainer> &contextContainer)
+    : contextContainer_(contextContainer), textMeasureCache_(kSimpleThreadSafeCacheSizeCap)
+{
+}
+
+static TextMeasurement measureString(
+    const AttributedString &attributedString,
+    const ParagraphAttributes &paragraphAttributes,
+    const TextLayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints)
+{
+  if (attributedString.isEmpty()) {
+    return {};
+  }
+  double maximumWidth = layoutConstraints.maximumSize.width;
+  std::vector<OneLinuxTextAttachment> attachments;
+  PangoLayout *layout = OneLinuxCreateLayout(
+      attributedString, paragraphAttributes, std::isfinite(maximumWidth) ? std::min(maximumWidth, 1e7) : -1, true, &attachments);
+  int width = 0;
+  int height = 0;
+  pango_layout_get_size(layout, &width, &height);
+
+  TextMeasurement measurement;
+  measurement.size = internal_roundTextMeasurementToPixelGrid(
+      Size{.width = static_cast<Float>(width) / PANGO_SCALE, .height = static_cast<Float>(height) / PANGO_SCALE},
+      layoutContext.pointScaleFactor);
+  if (!attachments.empty()) {
+    measurement.size = layoutConstraints.clamp(measurement.size);
+    pango_layout_set_width(layout, static_cast<int>(std::ceil(measurement.size.width * PANGO_SCALE)));
+    measurement.attachments.resize(attachments.size(), {.frame = {}, .isClipped = true});
+    PangoLayoutIter *iter = pango_layout_get_iter(layout);
+    do {
+      auto *run = pango_layout_iter_get_run_readonly(iter);
+      if (!run || (run->item->analysis.flags & PANGO_ANALYSIS_FLAG_IS_ELLIPSIS)) {
+        continue;
+      }
+      auto first = std::lower_bound(attachments.begin(), attachments.end(), run->item->offset,
+          [](const auto &attachment, int index) { return attachment.index < index; });
+      for (auto attachment = first; attachment != attachments.end() && attachment->index < run->item->offset + run->item->length; ++attachment) {
+        PangoRectangle position;
+        pango_layout_index_to_pos(layout, attachment->index, &position);
+        auto &result = measurement.attachments[attachment - attachments.begin()];
+        result = {.frame = {.origin = {.x = static_cast<Float>(position.x + std::min(0, position.width)) / PANGO_SCALE,
+                                      .y = static_cast<Float>(pango_layout_iter_get_baseline(iter)) / PANGO_SCALE - attachment->size.height},
+                            .size = attachment->size},
+                  .isClipped = false};
+      }
+    } while (pango_layout_iter_next_run(iter));
+    pango_layout_iter_free(iter);
+  }
+  g_object_unref(layout);
+  return measurement;
+}
+
+TextMeasurement TextLayoutManager::measure(
+    const AttributedStringBox &attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
+    const TextLayoutContext &layoutContext,
+    const LayoutConstraints &layoutConstraints) const
+{
+  auto measurement = TextMeasurement{};
+  if (attributedStringBox.getMode() == AttributedStringBox::Mode::Value) {
+    auto original = attributedStringBox.getValue();
+    auto attributedString = ensurePlaceholderIfEmpty_DO_NOT_USE(original);
+    measurement = textMeasureCache_.get(
+        {.attributedString = attributedString,
+         .paragraphAttributes = paragraphAttributes,
+         .layoutConstraints = layoutConstraints,
+         .pointScaleFactor = layoutContext.pointScaleFactor},
+        [&]() {
+          auto telemetry = TransactionTelemetry::threadLocalTelemetry();
+          if (telemetry) {
+            telemetry->willMeasureText();
+          }
+          auto result = measureString(attributedString, paragraphAttributes, layoutContext, layoutConstraints);
+          if (original.isEmpty()) {
+            result.size.width = 0;
+          }
+          if (telemetry) {
+            telemetry->didMeasureText();
+          }
+          return result;
+        });
+  }
+  measurement.size = layoutConstraints.clamp(measurement.size);
+  return measurement;
+}
+
+} // namespace facebook::react