react-native-windows 0.74.11 → 0.75.0-preview.1

package/Microsoft.ReactNative/Fabric/Composition/ReactNativeIsland.cpp

@@ -125,15 +125,6 @@ inline Mso::Future<void> CompositionReactViewInstance::PostInUIQueue(TAction &&a
   return promise.AsFuture();
 }
 
-void ApplyConstraints(
-    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,
-    facebook::react::LayoutConstraints &layoutConstraintsOut) noexcept {
-  layoutConstraintsOut.minimumSize = {layoutConstraintsIn.MinimumSize.Width, layoutConstraintsIn.MinimumSize.Height};
-  layoutConstraintsOut.maximumSize = {layoutConstraintsIn.MaximumSize.Width, layoutConstraintsIn.MaximumSize.Height};
-  layoutConstraintsOut.layoutDirection =
-      static_cast<facebook::react::LayoutDirection>(layoutConstraintsIn.LayoutDirection);
-}
-
 ReactNativeIsland::ReactNativeIsland() noexcept {}
 
 #ifdef USE_WINUI3
@@ -145,7 +136,6 @@ ReactNativeIsland::~ReactNativeIsland() noexcept {
 #ifdef USE_WINUI3
   if (m_island && m_island.IsConnected()) {
     m_island.AutomationProviderRequested(m_islandAutomationProviderRequestedToken);
-    m_island.StateChanged(m_islandStateChangedToken);
   }
 #endif
 
@@ -261,7 +251,6 @@ void ReactNativeIsland::ScaleFactor(float value) noexcept {
       rootView.Scale({invScale, invScale, invScale});
     }
     UpdateRootVisualSize();
-    Arrange(m_layoutConstraints, m_viewportOffset);
   }
 }
 
@@ -426,6 +415,13 @@ void ReactNativeIsland::UpdateRootViewInternal() noexcept {
   }
 }
 
+struct AutoMRE {
+  ~AutoMRE() {
+    mre.Set();
+  }
+  Mso::ManualResetEvent mre;
+};
+
 void ReactNativeIsland::UninitRootView() noexcept {
   if (!m_isInitialized) {
     return;
@@ -442,8 +438,10 @@ void ReactNativeIsland::UninitRootView() noexcept {
     // This is needed to ensure that the unmount JS logic is completed before the the instance is shutdown during
     // instance destruction. Aligns with similar code in ReactInstanceWin::DetachRootView for paper Future: Instead this
     // method should return a Promise, which should be resolved when the JS logic is complete.
+    // The task will auto set the event on destruction to ensure that the event is set if the JS Queue has already been
+    // shutdown
     Mso::ManualResetEvent mre;
-    m_context.JSDispatcher().Post([&]() { mre.Set(); });
+    m_context.JSDispatcher().Post([autoMRE = std::make_unique<AutoMRE>(AutoMRE{mre})]() {});
     mre.Wait();
 
     // Paper version gives the JS thread time to finish executing - Is this needed?
@@ -482,14 +480,10 @@ void ReactNativeIsland::ShowInstanceLoaded() noexcept {
       initProps = folly::dynamic::object();
     }
     initProps["concurrentRoot"] = true;
-
-    facebook::react::LayoutConstraints fbLayoutConstraints;
-    ApplyConstraints(m_layoutConstraints, fbLayoutConstraints);
-
     uiManager->startSurface(
         *this,
         static_cast<facebook::react::SurfaceId>(m_rootTag),
-        fbLayoutConstraints,
+        m_layoutConstraints,
         to_string(m_reactViewOptions.ComponentName()),
         initProps);
 
@@ -506,21 +500,16 @@ facebook::react::AttributedStringBox CreateLoadingAttributedString() noexcept {
   return facebook::react::AttributedStringBox{attributedString};
 }
 
-facebook::react::Size MeasureLoading(
-    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
-    float scaleFactor) {
-  facebook::react::LayoutConstraints fbLayoutConstraints;
-  ApplyConstraints(layoutConstraints, fbLayoutConstraints);
-
+facebook::react::Size MeasureLoading(const facebook::react::LayoutConstraints &layoutConstraints, float scaleFactor) {
   auto attributedStringBox = CreateLoadingAttributedString();
   winrt::com_ptr<::IDWriteTextLayout> textLayout;
   facebook::react::TextLayoutManager::GetTextLayout(
-      attributedStringBox, {} /*paragraphAttributes*/, fbLayoutConstraints, textLayout);
+      attributedStringBox, {} /*paragraphAttributes*/, layoutConstraints, textLayout);
 
   DWRITE_TEXT_METRICS tm;
-  textLayout->GetMetrics(&tm);
+  winrt::check_hresult(textLayout->GetMetrics(&tm));
 
-  return fbLayoutConstraints.clamp(
+  return layoutConstraints.clamp(
       {loadingActivityHorizontalOffset * scaleFactor + tm.width, loadingBarHeight * scaleFactor});
 }
 
@@ -535,7 +524,7 @@ void ReactNativeIsland::SizeChanged(winrt::event_token const &token) noexcept {
 }
 
 struct RootViewSizeChangedEventArgs : RootViewSizeChangedEventArgsT<RootViewSizeChangedEventArgs> {
-  RootViewSizeChangedEventArgs(winrt::Windows::Foundation::Size size) : m_size(size) {}
+  RootViewSizeChangedEventArgs(const winrt::Windows::Foundation::Size &size) : m_size(size) {}
   winrt::Windows::Foundation::Size Size() const noexcept {
     return m_size;
   }
@@ -645,6 +634,15 @@ void ReactNativeIsland::ShowInstanceLoading() noexcept {
   InternalRootVisual().InsertAt(m_loadingVisual, m_hasRenderedVisual ? 1 : 0);
 }
 
+void ApplyConstraints(
+    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,
+    facebook::react::LayoutConstraints &layoutConstraintsOut) noexcept {
+  layoutConstraintsOut.minimumSize = {layoutConstraintsIn.MinimumSize.Width, layoutConstraintsIn.MinimumSize.Height};
+  layoutConstraintsOut.maximumSize = {layoutConstraintsIn.MaximumSize.Width, layoutConstraintsIn.MaximumSize.Height};
+  layoutConstraintsOut.layoutDirection =
+      static_cast<facebook::react::LayoutDirection>(layoutConstraintsIn.LayoutDirection);
+}
+
 winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) const noexcept {
@@ -665,7 +663,7 @@ winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
       size = fabricuiManager->measureSurface(static_cast<facebook::react::SurfaceId>(m_rootTag), constraints, context);
     }
   } else if (m_loadingVisual) {
-    size = MeasureLoading(layoutConstraints, m_scaleFactor);
+    size = MeasureLoading(constraints, m_scaleFactor);
   }
 
   auto clampedSize = constraints.clamp(size);
@@ -675,10 +673,7 @@ winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
 void ReactNativeIsland::Arrange(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) noexcept {
-  m_layoutConstraints = layoutConstraints;
-  m_viewportOffset = viewportOffset;
-  facebook::react::LayoutConstraints fbLayoutConstraints;
-  ApplyConstraints(layoutConstraints, fbLayoutConstraints);
+  ApplyConstraints(layoutConstraints, m_layoutConstraints);
 
   if (m_isInitialized && m_rootTag != -1) {
     if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
@@ -689,11 +684,11 @@ void ReactNativeIsland::Arrange(
       context.viewportOffset = {viewportOffset.X, viewportOffset.Y};
 
       fabricuiManager->constraintSurfaceLayout(
-          static_cast<facebook::react::SurfaceId>(m_rootTag), fbLayoutConstraints, context);
+          static_cast<facebook::react::SurfaceId>(m_rootTag), m_layoutConstraints, context);
     }
   } else if (m_loadingVisual) {
     // TODO: Resize to align loading
-    auto s = fbLayoutConstraints.clamp(MeasureLoading(layoutConstraints, m_scaleFactor));
+    auto s = m_layoutConstraints.clamp(MeasureLoading(m_layoutConstraints, m_scaleFactor));
     NotifySizeChanged();
   }
 }
@@ -743,17 +738,6 @@ winrt::Microsoft::UI::Content::ContentIsland ReactNativeIsland::Island() {
         pThis->m_island = nullptr;
       }
     });
-
-    m_islandStateChangedToken =
-        m_island.StateChanged([weakThis = get_weak()](
-                                  winrt::Microsoft::UI::Content::ContentIsland const &island,
-                                  winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
-          if (auto pThis = weakThis.get()) {
-            if (args.DidRasterizationScaleChange()) {
-              pThis->ScaleFactor(island.RasterizationScale());
-            }
-          }
-        });
   }
   return m_island;
 }

package/Microsoft.ReactNative/Fabric/Composition/ReactNativeIsland.h

@@ -125,7 +125,6 @@ struct ReactNativeIsland
   winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
   winrt::event_token m_islandFrameworkClosedToken;
   winrt::event_token m_islandAutomationProviderRequestedToken;
-  winrt::event_token m_islandStateChangedToken;
 #endif
 
   HWND m_hwnd{0};
@@ -148,8 +147,7 @@ struct ReactNativeIsland
   winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader m_resources{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme::ThemeChanged_revoker m_themeChangedRevoker;
-  winrt::Microsoft::ReactNative::LayoutConstraints m_layoutConstraints;
-  winrt::Windows::Foundation::Point m_viewportOffset{0, 0};
+  facebook::react::LayoutConstraints m_layoutConstraints;
   winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::ReactNative::RootViewSizeChangedEventArgs>>
       m_sizeChangedEvent;
 

package/Microsoft.ReactNative/Fabric/Composition/ScrollViewComponentView.cpp

@@ -1138,7 +1138,7 @@ winrt::Microsoft::ReactNative::Composition::Experimental::IVisual ScrollViewComp
         updateStateWithContentOffset();
         auto eventEmitter = GetEventEmitter();
         if (eventEmitter) {
-          facebook::react::ScrollViewMetrics scrollMetrics;
+          facebook::react::ScrollViewEventEmitter::Metrics scrollMetrics;
           scrollMetrics.containerSize.height = m_layoutMetrics.frame.size.height;
           scrollMetrics.containerSize.width = m_layoutMetrics.frame.size.width;
           scrollMetrics.contentOffset.x = args.Position().x / m_layoutMetrics.pointScaleFactor;

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -947,6 +947,10 @@ void WindowsTextInputComponentView::onGotFocus(
     LRESULT lresult;
     DrawBlock db(*this);
     m_textServices->TxSendMessage(WM_SETFOCUS, 0, 0, &lresult);
+
+    if (windowsTextInputProps().clearTextOnFocus) {
+      m_textServices->TxSetText(L"");
+    }
   }
 }
 
@@ -1112,8 +1116,6 @@ void WindowsTextInputComponentView::updateState(
     return;
   }
 
-  auto data = m_state->getData();
-
   if (!oldState) {
     m_mostRecentEventCount = m_state->getData().mostRecentEventCount;
   }
@@ -1122,19 +1124,11 @@ void WindowsTextInputComponentView::updateState(
     m_comingFromState = true;
     // Only handle single/empty fragments right now -- ignore the other fragments
 
-    LRESULT res;
-    CHARRANGE cr;
-    cr.cpMin = cr.cpMax = 0;
-    winrt::check_hresult(m_textServices->TxSendMessage(EM_EXGETSEL, 0, reinterpret_cast<LPARAM>(&cr), &res));
-
     UpdateText(
         m_state->getData().attributedString.getFragments().size()
             ? m_state->getData().attributedString.getFragments()[0].string
             : "");
 
-    winrt::check_hresult(
-        m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(cr.cpMin), static_cast<LPARAM>(cr.cpMax), &res));
-
     m_comingFromState = false;
   }
 }
@@ -1153,7 +1147,8 @@ void WindowsTextInputComponentView::UpdateText(const std::string &str) noexcept
   winrt::check_hresult(m_textServices->TxSendMessage(
       EM_SETTEXTEX, reinterpret_cast<WPARAM>(&stt), reinterpret_cast<LPARAM>(str.c_str()), &res));
 
-  winrt::check_hresult(m_textServices->TxSendMessage(EM_EXGETSEL, 0, reinterpret_cast<LPARAM>(&cr), &res));
+  winrt::check_hresult(
+      m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(cr.cpMin), static_cast<LPARAM>(cr.cpMax), &res));
 
   // enable colored emojis
   winrt::check_hresult(
@@ -1216,7 +1211,7 @@ void WindowsTextInputComponentView::OnTextUpdated() noexcept {
 }
 
 void WindowsTextInputComponentView::OnSelectionChanged(LONG start, LONG end) noexcept {
-  if (m_eventEmitter /* && !m_comingFromJS ?? */) {
+  if (m_eventEmitter && !m_comingFromState /* && !m_comingFromJS ?? */) {
     auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
     facebook::react::WindowsTextInputEventEmitter::OnSelectionChange onSelectionChangeArgs;
     onSelectionChangeArgs.selection.start = start;

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputShadowNode.cpp

@@ -185,8 +185,7 @@ Size WindowsTextInputShadowNode::measureContent(
           AttributedStringBox{attributedString},
           {}, // TODO getConcreteProps().paragraphAttributes,
           textLayoutContext,
-          layoutConstraints,
-          nullptr)
+          layoutConstraints)
       .size;
 }
 

package/Microsoft.ReactNative/Fabric/Composition/UriImageManager.cpp

@@ -285,9 +285,15 @@ ImageResponseOrImageErrorInfo ImageResponse::ResolveImage() {
 
 ImageResponseOrImageErrorInfo ImageFailedResponse::ResolveImage() {
   ImageResponseOrImageErrorInfo imageOrError;
-  imageOrError.errorInfo = winrt::to_string(m_errorMessage);
-  if (imageOrError.errorInfo.empty()) {
-    imageOrError.errorInfo = "Failed to load image.";
+  imageOrError.errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+  imageOrError.errorInfo->responseCode = static_cast<int>(m_statusCode);
+  imageOrError.errorInfo->error = winrt::to_string(m_errorMessage);
+  if (imageOrError.errorInfo->error.empty()) {
+    imageOrError.errorInfo->error = "Failed to load image.";
+  }
+  for (auto &&[header, value] : m_responseHeaders) {
+    imageOrError.errorInfo->httpResponseHeaders.push_back(
+        std::make_pair<std::string, std::string>(winrt::to_string(header), winrt::to_string(value)));
   }
   return imageOrError;
 }

package/Microsoft.ReactNative/Fabric/Composition/UriImageManager.h

@@ -41,7 +41,7 @@ winrt::Microsoft::ReactNative::Composition::ImageSource MakeImageSource(
 
 struct ImageResponseOrImageErrorInfo {
   std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage> image;
-  std::string errorInfo;
+  std::shared_ptr<facebook::react::ImageErrorInfo> errorInfo;
 };
 
 struct ImageResponse : ImageResponseT<ImageResponse /*, IResolveImage*/> {

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -79,20 +79,8 @@ void FabricUIManager::installFabricUIManager() noexcept {
     runtimeExecutor = [runtimeScheduler](std::function<void(facebook::jsi::Runtime & runtime)> &&callback) {
       runtimeScheduler->scheduleWork(std::move(callback));
     };
-    facebook::react::EventBeat::Factory synchronousBeatFactory =
-        [runtimeExecutor, context = m_context, runtimeScheduler](
-            facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
-          return std::make_unique<SynchronousEventBeat>(ownerBox, context, runtimeExecutor, runtimeScheduler);
-        };
-    toolbox.synchronousEventBeatFactory = synchronousBeatFactory;
   } else {
     runtimeExecutor = SchedulerSettings::GetRuntimeExecutor(m_context.Properties());
-
-    facebook::react::EventBeat::Factory synchronousBeatFactory =
-        [runtimeExecutor, context = m_context](facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
-          return std::make_unique<AsynchronousEventBeat>(ownerBox, context, runtimeExecutor);
-        };
-    toolbox.synchronousEventBeatFactory = synchronousBeatFactory;
   }
 
   facebook::react::EventBeat::Factory asynchronousBeatFactory =
@@ -324,9 +312,6 @@ void FabricUIManager::initiateTransaction(facebook::react::MountingCoordinator::
 }
 
 void FabricUIManager::schedulerDidFinishTransaction(
-    const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {}
-
-void FabricUIManager::schedulerShouldRenderTransactions(
     const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {
   // Should cache this locally
 
@@ -338,9 +323,17 @@ void FabricUIManager::schedulerShouldRenderTransactions(
   }
 }
 
-void FabricUIManager::schedulerDidRequestPreliminaryViewAllocation(
-    facebook::react::SurfaceId surfaceId,
-    const facebook::react::ShadowNode &shadowView) {
+void FabricUIManager::schedulerShouldRenderTransactions(
+    const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {
+  if (m_context.UIDispatcher().HasThreadAccess()) {
+    initiateTransaction(mountingCoordinator);
+  } else {
+    m_context.UIDispatcher().Post(
+        [mountingCoordinator, self = shared_from_this()]() { self->initiateTransaction(mountingCoordinator); });
+  }
+}
+
+void FabricUIManager::schedulerDidRequestPreliminaryViewAllocation(const facebook::react::ShadowNode &shadowView) {
   // iOS does not do this optimization, but Android does.  It maybe that android's allocations are more expensive due to
   // the Java boundary.
   // TODO: We should do some perf tests to see if this is worth doing.

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -79,13 +79,11 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   std::unordered_map<facebook::react::SurfaceId, SurfaceInfo> m_surfaceRegistry;
 
   // Inherited via SchedulerDelegate
-  virtual void schedulerShouldRenderTransactions(
-      const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
   virtual void schedulerDidFinishTransaction(
       const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
-  virtual void schedulerDidRequestPreliminaryViewAllocation(
-      facebook::react::SurfaceId surfaceId,
-      const facebook::react::ShadowNode &shadowView) override;
+  virtual void schedulerShouldRenderTransactions(
+      const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
+  virtual void schedulerDidRequestPreliminaryViewAllocation(const facebook::react::ShadowNode &shadowView) override;
   virtual void schedulerDidDispatchCommand(
       facebook::react::ShadowView const &shadowView,
       std::string const &commandName,

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -43,8 +43,11 @@ WindowsImageManager::WindowsImageManager(winrt::Microsoft::ReactNative::ReactCon
   }
 }
 
-std::tuple<winrt::com_ptr<IWICBitmapSource>, winrt::com_ptr<IWICImagingFactory>, std::string> wicBitmapSourceFromStream(
-    const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept {
+std::tuple<
+    winrt::com_ptr<IWICBitmapSource>,
+    winrt::com_ptr<IWICImagingFactory>,
+    std::shared_ptr<facebook::react::ImageErrorInfo>>
+wicBitmapSourceFromStream(const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept {
   try {
     winrt::com_ptr<IWICImagingFactory> imagingFactory;
     winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
@@ -58,14 +61,19 @@ std::tuple<winrt::com_ptr<IWICBitmapSource>, winrt::com_ptr<IWICImagingFactory>,
         istream.get(), nullptr, WICDecodeMetadataCacheOnDemand, bitmapDecoder.put()));
 
     if (!bitmapDecoder) {
-      return {nullptr, nullptr, "Failed to decode the image."};
+      auto errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+      errorInfo->error = "Failed to decode the image.";
+      return {nullptr, nullptr, errorInfo};
     }
 
     winrt::com_ptr<IWICBitmapFrameDecode> decodedFrame;
     winrt::check_hresult(bitmapDecoder->GetFrame(0, decodedFrame.put()));
-    return {decodedFrame, imagingFactory, {}};
+    return {decodedFrame, imagingFactory, nullptr};
   } catch (winrt::hresult_error const &ex) {
-    return {nullptr, nullptr, ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex))};
+    auto errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+    errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+    errorInfo->error = ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex));
+    return {nullptr, nullptr, errorInfo};
   }
 }
 
@@ -87,11 +95,6 @@ WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) co
     }
 
     winrt::Windows::Storage::StorageFile file(co_await getFileSync);
-
-    if (!file) {
-      co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(L"Failed to get file.");
-    }
-
     co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(co_await file.OpenReadAsync());
   }
 
@@ -171,16 +174,20 @@ facebook::react::ImageRequest WindowsImageManager::requestImage(
           observerCoordinator->nativeImageResponseComplete(
               facebook::react::ImageResponse(imageResultOrError.image, nullptr /*metadata*/));
         } else {
-          observerCoordinator->nativeImageResponseFailed();
+          observerCoordinator->nativeImageResponseFailed(facebook::react::ImageLoadError(imageResultOrError.errorInfo));
         }
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Canceled: {
-        observerCoordinator->nativeImageResponseFailed();
+        auto errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+        errorInfo->error = FormatHResultError(winrt::hresult_error(asyncOp.ErrorCode()));
+        observerCoordinator->nativeImageResponseFailed(facebook::react::ImageLoadError(errorInfo));
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Error: {
-        observerCoordinator->nativeImageResponseFailed();
+        auto errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+        errorInfo->error = FormatHResultError(winrt::hresult_error(asyncOp.ErrorCode()));
+        observerCoordinator->nativeImageResponseFailed(facebook::react::ImageLoadError(errorInfo));
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Started: {
@@ -202,8 +209,7 @@ ImageResponseOrImageErrorInfo StreamImageResponse::ResolveImage() {
   try {
     auto result = ::Microsoft::ReactNative::wicBitmapSourceFromStream(m_stream);
 
-    auto &errorInfo = std::get<std::string>(result);
-    if (!errorInfo.empty()) {
+    if (auto errorInfo = std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
       imageOrError.errorInfo = errorInfo;
       return imageOrError;
     }
@@ -227,7 +233,8 @@ ImageResponseOrImageErrorInfo StreamImageResponse::ResolveImage() {
     winrt::check_hresult(imagingFactory->CreateBitmapFromSource(
         converter.get(), WICBitmapCacheOnLoad, imageOrError.image->m_wicbmp.put()));
   } catch (winrt::hresult_error const &ex) {
-    imageOrError.errorInfo = ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex));
+    imageOrError.errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
+    imageOrError.errorInfo->error = ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex));
   }
   return imageOrError;
 }

package/Microsoft.ReactNative/Fabric/WindowsImageManager.h

@@ -30,7 +30,10 @@ struct WindowsImageManager {
   std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> m_uriImageManager;
 };
 
-std::tuple<winrt::com_ptr<IWICBitmapSource>, winrt::com_ptr<IWICImagingFactory>, std::string> wicBitmapSourceFromStream(
-    const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept;
+std::tuple<
+    winrt::com_ptr<IWICBitmapSource>,
+    winrt::com_ptr<IWICImagingFactory>,
+    std::shared_ptr<facebook::react::ImageErrorInfo>>
+wicBitmapSourceFromStream(const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept;
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewEventEmitter.cpp

@@ -39,19 +39,11 @@ void HostPlatformViewEventEmitter::onBlur() const {
 #pragma mark - Mouse Events
 
 void HostPlatformViewEventEmitter::onMouseEnter(PointerEvent const &pointerEvent) const {
-  dispatchEvent(
-      "mouseEnter",
-      std::make_shared<PointerEvent>(pointerEvent),
-      EventPriority::AsynchronousBatched,
-      RawEvent::Category::ContinuousStart);
+  dispatchEvent("mouseEnter", std::make_shared<PointerEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
 }
 
 void HostPlatformViewEventEmitter::onMouseLeave(PointerEvent const &pointerEvent) const {
-  dispatchEvent(
-      "mouseLeave",
-      std::make_shared<PointerEvent>(pointerEvent),
-      EventPriority::AsynchronousBatched,
-      RawEvent::Category::ContinuousStart);
+  dispatchEvent("mouseLeave", std::make_shared<PointerEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
 }
 
 } // namespace facebook::react