react-native-windows 0.78.5 → 0.78.7

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/HostPlatformColor.h

@@ -12,13 +12,10 @@ namespace facebook::react {
 
 struct Color {
   bool operator==(const Color &otherColor) const {
-    return m_isUndefined && otherColor.m_isUndefined ||
-        (m_isUndefined == otherColor.m_isUndefined && m_color == otherColor.m_color &&
-         m_platformColor == otherColor.m_platformColor);
+    return m_color == otherColor.m_color && m_platformColor == otherColor.m_platformColor;
   }
   bool operator!=(const Color &otherColor) const {
-    return m_isUndefined != otherColor.m_isUndefined || m_color != otherColor.m_color ||
-        m_platformColor != otherColor.m_platformColor;
+    return m_color != otherColor.m_color || m_platformColor != otherColor.m_platformColor;
   }
 
   winrt::Windows::UI::Color AsWindowsColor() const {
@@ -36,13 +33,14 @@ struct Color {
     return RGB(m_color.R, m_color.G, m_color.B) | (m_color.A << 24);
   }
 
-  bool m_isUndefined;
   winrt::Windows::UI::Color m_color;
   std::vector<std::string> m_platformColor;
 };
 
 namespace HostPlatformColor {
-static const facebook::react::Color UndefinedColor{true};
+static const facebook::react::Color UndefinedColor{
+    {0, 0, 0, 0} /*Black*/,
+    {"__undefinedColor"} /*Empty PlatformColors*/};
 } // namespace HostPlatformColor
 
 inline Color hostPlatformColorFromComponents(ColorComponents components) {
@@ -53,7 +51,6 @@ inline Color hostPlatformColorFromComponents(ColorComponents components) {
       static_cast<uint8_t>((int)round(components.green * ratio) & 0xff),
       static_cast<uint8_t>((int)round(components.blue * ratio) & 0xff)};
   return {
-      /* .m_isUndefined = */ false,
       /* .m_color = */ color,
       /* .m_platformColor = */ {}};
 }

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/PlatformColorParser.h

@@ -15,11 +15,10 @@ namespace facebook::react {
 
 inline SharedColor
 parsePlatformColor(const ContextContainer &contextContainer, int32_t surfaceId, const RawValue &value) {
-  if (value.hasType<std::unordered_map<std::string, std::string>>()) {
+  if (value.hasType<std::unordered_map<std::string, std::vector<std::string>>>()) {
     auto map = (std::unordered_map<std::string, std::vector<std::string>>)value;
     if (map.find("windowsbrush") != map.end()) {
       facebook::react::Color color = {
-          /* .m_isDefined = */ true,
           /* .m_color = */ {},
           /* .m_platformColor = */ std::move(map["windowsbrush"]),
       };

package/Microsoft.ReactNative/Fabric/platform/react/renderer/textlayoutmanager/TextLayoutManager.cpp

@@ -14,13 +14,64 @@
 
 #include <unicode.h>
 
+constexpr float cDefaultMaxFontSizeMultiplier = 0.0f;
+
 namespace facebook::react {
 
+// Creates an empty InlineObject since RN handles actually rendering the Inline object, this just reserves space for it.
+class AttachmentInlineObject : public winrt::implements<AttachmentInlineObject, IDWriteInlineObject> {
+ public:
+  AttachmentInlineObject(float width, float height) : m_width(width), m_height(height) {}
+
+  // IDWriteInlineObject methods
+  STDMETHOD(Draw)
+  (_In_opt_ void *clientDrawingContext,
+   _In_ IDWriteTextRenderer *renderer,
+   FLOAT originX,
+   FLOAT originY,
+   BOOL isSideways,
+   BOOL isRightToLeft,
+   _In_opt_ IUnknown *clientDrawingEffect) override {
+    // We don't need to draw anything here since the actual rendering is handled by React Native
+    return S_OK;
+  }
+
+  STDMETHOD(GetMetrics)(_Out_ DWRITE_INLINE_OBJECT_METRICS *metrics) override {
+    metrics->width = m_width;
+    metrics->height = m_height;
+    metrics->baseline =
+        m_height; // If the baseline is at the bottom, then baseline = height
+                  // (https://learn.microsoft.com/en-us/windows/win32/api/dwrite/ns-dwrite-dwrite_inline_object_metrics)
+    metrics->supportsSideways = true;
+    return S_OK;
+  }
+
+  STDMETHOD(GetOverhangMetrics)(_Out_ DWRITE_OVERHANG_METRICS *overhangs) override {
+    overhangs->left = 0;
+    overhangs->top = 0;
+    overhangs->right = 0;
+    overhangs->bottom = 0;
+    return S_OK;
+  }
+
+  STDMETHOD(GetBreakConditions)
+  (_Out_ DWRITE_BREAK_CONDITION *breakConditionBefore, _Out_ DWRITE_BREAK_CONDITION *breakConditionAfter) override {
+    *breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
+    *breakConditionAfter = DWRITE_BREAK_CONDITION_NEUTRAL;
+    return S_OK;
+  }
+
+ private:
+  float m_width;
+  float m_height;
+};
+
 void TextLayoutManager::GetTextLayout(
     const AttributedStringBox &attributedStringBox,
     const ParagraphAttributes &paragraphAttributes,
     Size size,
-    winrt::com_ptr<IDWriteTextLayout> &spTextLayout) noexcept {
+    winrt::com_ptr<IDWriteTextLayout> &spTextLayout,
+    TextMeasurement::Attachments &attachments) noexcept {
   const auto &attributedString = attributedStringBox.getValue();
   auto fragments = attributedString.getFragments();
   auto outerFragment = fragments[0];
@@ -32,6 +83,20 @@ void TextLayoutManager::GetTextLayout(
     style = DWRITE_FONT_STYLE_OBLIQUE;
 
   winrt::com_ptr<IDWriteTextFormat> spTextFormat;
+
+  float fontSizeText = outerFragment.textAttributes.fontSize;
+  if (outerFragment.textAttributes.allowFontScaling.value_or(true) &&
+      !std::isnan(outerFragment.textAttributes.fontSizeMultiplier)) {
+    float maxFontSizeMultiplierText = cDefaultMaxFontSizeMultiplier;
+    maxFontSizeMultiplierText =
+        (!std::isnan(outerFragment.textAttributes.maxFontSizeMultiplier)
+             ? outerFragment.textAttributes.maxFontSizeMultiplier
+             : cDefaultMaxFontSizeMultiplier);
+    fontSizeText *= (maxFontSizeMultiplierText >= 1.0f)
+        ? std::min(maxFontSizeMultiplierText, outerFragment.textAttributes.fontSizeMultiplier)
+        : outerFragment.textAttributes.fontSizeMultiplier;
+  }
+
   winrt::check_hresult(Microsoft::ReactNative::DWriteFactory()->CreateTextFormat(
       outerFragment.textAttributes.fontFamily.empty()
           ? L"Segoe UI"
@@ -41,10 +106,7 @@ void TextLayoutManager::GetTextLayout(
           static_cast<facebook::react::FontWeight>(DWRITE_FONT_WEIGHT_REGULAR))),
       style,
       DWRITE_FONT_STRETCH_NORMAL,
-      (outerFragment.textAttributes.allowFontScaling.value_or(true) &&
-       !std::isnan(outerFragment.textAttributes.fontSizeMultiplier))
-          ? (outerFragment.textAttributes.fontSizeMultiplier * outerFragment.textAttributes.fontSize)
-          : outerFragment.textAttributes.fontSize,
+      fontSizeText,
       L"",
       spTextFormat.put()));
 
@@ -62,6 +124,7 @@ void TextLayoutManager::GetTextLayout(
         outerFragment.textAttributes.lineHeight * 0.8f));
   }
 
+  // Set text alignment
   DWRITE_TEXT_ALIGNMENT alignment = DWRITE_TEXT_ALIGNMENT_LEADING;
   if (outerFragment.textAttributes.alignment) {
     switch (*outerFragment.textAttributes.alignment) {
@@ -87,6 +150,7 @@ void TextLayoutManager::GetTextLayout(
   }
   winrt::check_hresult(spTextFormat->SetTextAlignment(alignment));
 
+  // Get text with Object Replacement Characters for attachments
   auto str = GetTransformedText(attributedStringBox);
 
   winrt::check_hresult(Microsoft::ReactNative::DWriteFactory()->CreateTextLayout(
@@ -98,39 +162,82 @@ void TextLayoutManager::GetTextLayout(
       spTextLayout.put() // The IDWriteTextLayout interface pointer.
       ));
 
+  // Calculate positions for attachments and set inline objects
   unsigned int position = 0;
-  unsigned int length = 0;
   for (const auto &fragment : fragments) {
-    length = static_cast<UINT32>(fragment.string.length());
-    DWRITE_TEXT_RANGE range = {position, length};
-    TextAttributes attributes = fragment.textAttributes;
-    DWRITE_FONT_STYLE fragmentStyle = DWRITE_FONT_STYLE_NORMAL;
-    if (attributes.fontStyle == facebook::react::FontStyle::Italic)
-      fragmentStyle = DWRITE_FONT_STYLE_ITALIC;
-    else if (attributes.fontStyle == facebook::react::FontStyle::Oblique)
-      fragmentStyle = DWRITE_FONT_STYLE_OBLIQUE;
-
-    winrt::check_hresult(spTextLayout->SetFontFamilyName(
-        attributes.fontFamily.empty() ? L"Segoe UI"
-                                      : Microsoft::Common::Unicode::Utf8ToUtf16(attributes.fontFamily).c_str(),
-        range));
-    winrt::check_hresult(spTextLayout->SetFontWeight(
-        static_cast<DWRITE_FONT_WEIGHT>(
-            attributes.fontWeight.value_or(static_cast<facebook::react::FontWeight>(DWRITE_FONT_WEIGHT_REGULAR))),
-        range));
-    winrt::check_hresult(spTextLayout->SetFontStyle(fragmentStyle, range));
-    winrt::check_hresult(spTextLayout->SetFontSize(
-        (attributes.allowFontScaling.value_or(true) && !std::isnan(attributes.fontSizeMultiplier))
-            ? (attributes.fontSizeMultiplier * attributes.fontSize)
-            : attributes.fontSize,
-        range));
-
-    if (!isnan(attributes.letterSpacing)) {
-      winrt::check_hresult(
-          spTextLayout.as<IDWriteTextLayout1>()->SetCharacterSpacing(0, attributes.letterSpacing, 0, range));
-    }
+    if (fragment.isAttachment()) {
+      float width = fragment.parentShadowView.layoutMetrics.frame.size.width;
+      float height = fragment.parentShadowView.layoutMetrics.frame.size.height;
+
+      // Get current height to check if attachment needs to be clipped
+      DWRITE_TEXT_METRICS dtm{};
+      winrt::check_hresult(spTextLayout->GetMetrics(&dtm));
+
+      // Check if the attachment should be clipped
+      // TODO #14443: clipping works on the first-levels view, but any nested view won't be clipped
+      bool isClipped = height > dtm.height;
+      if (isClipped) {
+        height = dtm.height;
+      }
+
+      // Create an inline object (this just reserves space in RichEdit for ReactNative to render the actual attachment)
+      auto inlineObject = winrt::make<AttachmentInlineObject>(width, height);
+      winrt::check_hresult(spTextLayout->SetInlineObject(inlineObject.get(), {position, 1}));
+
+      // Get the position of the Object Replacement Character
+      DWRITE_HIT_TEST_METRICS hitTestMetrics;
+      float x, y;
+      winrt::check_hresult(spTextLayout->HitTestTextPosition(position, false, &x, &y, &hitTestMetrics));
+
+      // Store the attachment position for RN to render later
+      TextMeasurement::Attachment attachment;
+      attachment.frame = {
+          x, // left
+          y, // top
+          width, // width
+          height // height
+      };
+      attachment.isClipped = isClipped;
+      attachments.push_back(attachment);
+      position += 1;
+    } else {
+      unsigned int length = static_cast<UINT32>(fragment.string.length());
+      DWRITE_TEXT_RANGE range = {position, length};
+      TextAttributes attributes = fragment.textAttributes;
+      DWRITE_FONT_STYLE fragmentStyle = DWRITE_FONT_STYLE_NORMAL;
+      if (attributes.fontStyle == facebook::react::FontStyle::Italic)
+        fragmentStyle = DWRITE_FONT_STYLE_ITALIC;
+      else if (attributes.fontStyle == facebook::react::FontStyle::Oblique)
+        fragmentStyle = DWRITE_FONT_STYLE_OBLIQUE;
+
+      winrt::check_hresult(spTextLayout->SetFontFamilyName(
+          attributes.fontFamily.empty() ? L"Segoe UI"
+                                        : Microsoft::Common::Unicode::Utf8ToUtf16(attributes.fontFamily).c_str(),
+          range));
+      winrt::check_hresult(spTextLayout->SetFontWeight(
+          static_cast<DWRITE_FONT_WEIGHT>(
+              attributes.fontWeight.value_or(static_cast<facebook::react::FontWeight>(DWRITE_FONT_WEIGHT_REGULAR))),
+          range));
+      winrt::check_hresult(spTextLayout->SetFontStyle(fragmentStyle, range));
+
+      float maxFontSizeMultiplier = cDefaultMaxFontSizeMultiplier;
+      maxFontSizeMultiplier =
+          (!std::isnan(attributes.maxFontSizeMultiplier) ? attributes.maxFontSizeMultiplier
+                                                         : cDefaultMaxFontSizeMultiplier);
+      float fontSize = attributes.fontSize;
+      if (attributes.allowFontScaling.value_or(true) && (!std::isnan(attributes.fontSizeMultiplier))) {
+        fontSize *= (maxFontSizeMultiplier >= 1.0f) ? std::min(maxFontSizeMultiplier, attributes.fontSizeMultiplier)
+                                                    : attributes.fontSizeMultiplier;
+      }
 
-    position += length;
+      winrt::check_hresult(spTextLayout->SetFontSize(fontSize, range));
+
+      if (!isnan(attributes.letterSpacing)) {
+        winrt::check_hresult(
+            spTextLayout.as<IDWriteTextLayout1>()->SetCharacterSpacing(0, attributes.letterSpacing, 0, range));
+      }
+      position += length;
+    }
   }
 }
 
@@ -142,9 +249,86 @@ void TextLayoutManager::GetTextLayout(
   if (attributedStringBox.getValue().isEmpty())
     return;
 
-  GetTextLayout(attributedStringBox, paragraphAttributes, layoutConstraints.maximumSize, spTextLayout);
+  TextMeasurement::Attachments attachments;
+  if (paragraphAttributes.adjustsFontSizeToFit) {
+    auto minimumFontScale = 0.01f;
+    // Uncomment below part when minimumFontScale is available in ParagraphAttributes
+    // if (paragraphAttributes.minimumFontScale && paragraphAttributes.minimumFontScale >= 0.01f &&
+    //    paragraphAttributes.minimumFontScale <= 1.0f) {
+    //  minimumFontScale = paragraphAttributes.minimumFontScale;
+    //}
+    GetTextLayoutByAdjustingFontSizeToFit(
+        attributedStringBox, paragraphAttributes, layoutConstraints, spTextLayout, attachments, minimumFontScale);
+  } else {
+    GetTextLayout(attributedStringBox, paragraphAttributes, layoutConstraints.maximumSize, spTextLayout, attachments);
+  }
+}
+
+void TextLayoutManager::GetTextLayoutByAdjustingFontSizeToFit(
+    AttributedStringBox attributedStringBox,
+    const ParagraphAttributes &paragraphAttributes,
+    LayoutConstraints layoutConstraints,
+    winrt::com_ptr<IDWriteTextLayout> &spTextLayout,
+    TextMeasurement::Attachments &attachments,
+    float minimumFontScale) noexcept {
+  /* This function constructs a text layout from the given parameters.
+  If the generated text layout doesn't fit within the given layout constraints,
+  it will reduce the font size and construct a new text layout. This process will
+  be repeated until the text layout meets the constraints.*/
+
+  DWRITE_TEXT_METRICS metrics;
+
+  // Better Approach should be implemented, this uses O(n)
+  constexpr auto fontReduceFactor = 1.0f;
+  auto attributedStringToResize = attributedStringBox.getValue();
+  auto fragmentsCopyToResize = attributedStringToResize.getFragments();
+  if (fragmentsCopyToResize.empty()) {
+    return; // No fragments to process
+  }
+
+  float initialFontSize = fragmentsCopyToResize[0].textAttributes.fontSize;
+  float currentFontSize = initialFontSize;
+
+  // Calculate the minimum font size as per Android/IOS
+  float minimumFontSize = std::max(minimumFontScale * initialFontSize, 4.0f);
+
+  // Initial measurement
+  GetTextLayout(attributedStringBox, paragraphAttributes, layoutConstraints.maximumSize, spTextLayout, attachments);
+  if (spTextLayout) {
+    winrt::check_hresult(spTextLayout->GetMetrics(&metrics));
+  } else {
+    return;
+  }
+
+  // Loop until the font size is reduced to the minimum or the layout fits
+  while ((currentFontSize > minimumFontSize) &&
+         ((paragraphAttributes.maximumNumberOfLines != 0 &&
+           paragraphAttributes.maximumNumberOfLines < static_cast<int>(metrics.lineCount)) ||
+          metrics.height > metrics.layoutHeight || metrics.width > metrics.layoutWidth)) {
+    // Reduce the font size by 1 point (or a configurable factor)
+    currentFontSize = std::max(currentFontSize - fontReduceFactor, minimumFontSize);
+
+    // Adjust font size for all fragments proportionally
+    attributedStringToResize.getFragments().clear();
+    for (auto fragment : fragmentsCopyToResize) {
+      fragment.textAttributes.fontSize =
+          std::max(fragment.textAttributes.fontSize * (currentFontSize / initialFontSize), minimumFontSize);
+      attributedStringToResize.appendFragment(std::move(fragment));
+    }
+
+    attributedStringBox = facebook::react::AttributedStringBox(attributedStringToResize);
+
+    // Re-measure the text layout
+    GetTextLayout(attributedStringBox, paragraphAttributes, layoutConstraints.maximumSize, spTextLayout, attachments);
+    if (spTextLayout) {
+      winrt::check_hresult(spTextLayout->GetMetrics(&metrics));
+    } else {
+      return;
+    }
+  }
 }
 
+// measure entire text (inluding attachments)
 TextMeasurement TextLayoutManager::measure(
     const AttributedStringBox &attributedStringBox,
     const ParagraphAttributes &paragraphAttributes,
@@ -152,6 +336,7 @@ TextMeasurement TextLayoutManager::measure(
     LayoutConstraints layoutConstraints) const {
   TextMeasurement measurement{};
   auto &attributedString = attributedStringBox.getValue();
+
   measurement = m_measureCache.get(
       {attributedString, paragraphAttributes, layoutConstraints}, [&](TextMeasureCacheKey const &key) {
         auto telemetry = TransactionTelemetry::threadLocalTelemetry();
@@ -161,7 +346,9 @@ TextMeasurement TextLayoutManager::measure(
 
         winrt::com_ptr<IDWriteTextLayout> spTextLayout;
 
-        GetTextLayout(attributedStringBox, paragraphAttributes, layoutConstraints, spTextLayout);
+        TextMeasurement::Attachments attachments;
+        GetTextLayout(
+            attributedStringBox, paragraphAttributes, layoutConstraints.maximumSize, spTextLayout, attachments);
 
         if (spTextLayout) {
           auto maxHeight = std::numeric_limits<float>().max();
@@ -182,6 +369,7 @@ TextMeasurement TextLayoutManager::measure(
           DWRITE_TEXT_METRICS dtm{};
           winrt::check_hresult(spTextLayout->GetMetrics(&dtm));
           measurement.size = {dtm.width, std::min(dtm.height, maxHeight)};
+          measurement.attachments = attachments;
         }
 
         if (telemetry) {
@@ -190,7 +378,6 @@ TextMeasurement TextLayoutManager::measure(
 
         return measurement;
       });
-
   return measurement;
 }
 
@@ -232,8 +419,8 @@ LinesMeasurements TextLayoutManager::measureLines(
   LinesMeasurements lineMeasurements{};
 
   winrt::com_ptr<IDWriteTextLayout> spTextLayout;
-
-  GetTextLayout(attributedStringBox, paragraphAttributes, size, spTextLayout);
+  TextMeasurement::Attachments attachments;
+  GetTextLayout(attributedStringBox, paragraphAttributes, size, spTextLayout, attachments);
 
   if (spTextLayout) {
     std::vector<DWRITE_LINE_METRICS> lineMetrics;
@@ -313,17 +500,32 @@ Float TextLayoutManager::baseline(
     AttributedStringBox attributedStringBox,
     ParagraphAttributes paragraphAttributes,
     Size size) const {
-  return 0;
+  winrt::com_ptr<IDWriteTextLayout> spTextLayout;
+  TextMeasurement::Attachments attachments;
+  GetTextLayout(attributedStringBox, paragraphAttributes, size, spTextLayout, attachments);
+  if (!spTextLayout) {
+    return 0;
+  }
+
+  DWRITE_TEXT_METRICS metrics;
+  winrt::check_hresult(spTextLayout->GetMetrics(&metrics));
+  return metrics.height *
+      0.8f; // https://learn.microsoft.com/en-us/windows/win32/api/dwrite/nf-dwrite-idwritetextformat-getlinespacing
 }
 
 winrt::hstring TextLayoutManager::GetTransformedText(const AttributedStringBox &attributedStringBox) {
   winrt::hstring result{};
   const auto &attributedString = attributedStringBox.getValue();
+
   for (const auto &fragment : attributedString.getFragments()) {
-    result = result +
-        Microsoft::ReactNative::TransformableText::TransformText(
-                 winrt::hstring{Microsoft::Common::Unicode::Utf8ToUtf16(fragment.string)},
-                 ConvertTextTransform(fragment.textAttributes.textTransform));
+    if (fragment.isAttachment()) {
+      result = result + L"\uFFFC"; // Unicode Object Replacement Character, will be replaced with an inline object
+    } else {
+      result = result +
+          Microsoft::ReactNative::TransformableText::TransformText(
+                   winrt::hstring{Microsoft::Common::Unicode::Utf8ToUtf16(fragment.string)},
+                   ConvertTextTransform(fragment.textAttributes.textTransform));
+    }
   }
   return result;
 }

package/Microsoft.ReactNative/Fabric/platform/react/renderer/textlayoutmanager/TextLayoutManager.h

@@ -75,12 +75,27 @@ class TextLayoutManager {
    */
   void *getNativeTextLayoutManager() const;
 
+  static void GetTextLayout(
+      const AttributedStringBox &attributedStringBox,
+      const ParagraphAttributes &paragraphAttributes,
+      Size size,
+      winrt::com_ptr<IDWriteTextLayout> &spTextLayout,
+      TextMeasurement::Attachments &attachments) noexcept;
+
   static void GetTextLayout(
       const AttributedStringBox &attributedStringBox,
       const ParagraphAttributes &paragraphAttributes,
       LayoutConstraints layoutConstraints,
       winrt::com_ptr<IDWriteTextLayout> &spTextLayout) noexcept;
 
+  static void GetTextLayoutByAdjustingFontSizeToFit(
+      AttributedStringBox attributedStringBox,
+      const ParagraphAttributes &paragraphAttributes,
+      LayoutConstraints layoutConstraints,
+      winrt::com_ptr<IDWriteTextLayout> &spTextLayout,
+      TextMeasurement::Attachments &attachments,
+      float minimumFontScale) noexcept;
+
 #pragma endregion
 
  private:

package/Microsoft.ReactNative/Fabric/platform/react/threading/MessageQueueThreadImpl.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// [Windows] Brought forward from react-native - switch to using react-native/ReactCxxPlatform/react/threading version
+// once we integrate that far
+
+#include "MessageQueueThreadImpl.h"
+
+#include <functional>
+
+namespace facebook::react {
+
+void MessageQueueThreadImpl::runOnQueue(std::function<void()> &&runnable) {
+  if (!taskDispatchThread_.isRunning()) {
+    return;
+  }
+  taskDispatchThread_.runAsync([runnable = std::move(runnable)]() noexcept { runnable(); });
+}
+
+void MessageQueueThreadImpl::runOnQueueSync(std::function<void()> &&runnable) {
+  if (!taskDispatchThread_.isRunning()) {
+    return;
+  }
+  if (taskDispatchThread_.isOnThread()) {
+    runnable();
+  } else {
+    taskDispatchThread_.runSync([runnable = std::move(runnable)]() noexcept { runnable(); });
+  }
+}
+
+void MessageQueueThreadImpl::quitSynchronous() {
+  taskDispatchThread_.quit();
+}
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/platform/react/threading/MessageQueueThreadImpl.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// [Windows] Brought forward from react-native - switch to using react-native/ReactCxxPlatform/react/threading version
+// once we integrate that far
+
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <react/threading/TaskDispatchThread.h>
+#include <memory>
+
+namespace facebook::react {
+
+using MessageQueueThreadFactory = std::function<std::shared_ptr<MessageQueueThread>()>;
+
+constexpr char MessageQueueThreadFactoryKey[] = "MessageQueueThreadFactoryKey";
+
+/**
+ * MessageQueueThread implementation that uses a TaskDispatchThread for
+ * queueing and threading logic
+ */
+class MessageQueueThreadImpl : public MessageQueueThread {
+ public:
+  MessageQueueThreadImpl() noexcept = default;
+  explicit MessageQueueThreadImpl(int priorityOffset) noexcept : taskDispatchThread_("MessageQueue", priorityOffset) {}
+
+  ~MessageQueueThreadImpl() noexcept override = default;
+
+  /** Add a job to the queue asynchronously */
+  void runOnQueue(std::function<void()> &&runnable) override;
+
+  /**
+   * Add a job to the queue synchronously - call won't return until runnable
+   * has completed.  Will run immediately if called from the looper thread.
+   * Should only be used for initialization.
+   */
+  void runOnQueueSync(std::function<void()> &&runnable) override;
+
+  /**
+   * Stop the message queue thread. Should only be used for cleanup - once it
+   * returns, no further work should run on the queue.
+   */
+  void quitSynchronous() override;
+
+ private:
+  TaskDispatchThread taskDispatchThread_{"MessageQueue"};
+};
+
+} // namespace facebook::react