react-native-windows 0.0.0-canary.618 → 0.0.0-canary.620

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

@@ -12,6 +12,7 @@
 #include <winrt/Windows.UI.Composition.h>
 #include "CompositionContextHelper.h"
 #include "CompositionHelpers.h"
+#include "RootComponentView.h"
 #include "d2d1helper.h"
 
 namespace Microsoft::ReactNative {
@@ -38,6 +39,13 @@ const std::vector<IComponentView *> &CompositionBaseComponentView::children() co
 }
 
 void CompositionBaseComponentView::parent(IComponentView *parent) noexcept {
+  if (!parent) {
+    auto root = rootComponentView();
+    if (root->GetFocusedComponent() == this) {
+      root->SetFocusedComponent(nullptr); // TODO need move focus logic - where should focus go?
+    }
+  }
+
   m_parent = parent;
 }
 
@@ -60,9 +68,13 @@ bool CompositionBaseComponentView::runOnChildren(bool forward, Mso::Functor<bool
   return false;
 }
 
-void CompositionBaseComponentView::onFocusLost() noexcept {}
+void CompositionBaseComponentView::onFocusLost() noexcept {
+  m_eventEmitter->onBlur();
+}
 
-void CompositionBaseComponentView::onFocusGained() noexcept {}
+void CompositionBaseComponentView::onFocusGained() noexcept {
+  m_eventEmitter->onFocus();
+}
 
 void CompositionBaseComponentView::updateEventEmitter(
     facebook::react::EventEmitter::Shared const &eventEmitter) noexcept {
@@ -971,9 +983,8 @@ void CompositionBaseComponentView::updateBorderLayoutMetrics(
     Visual().as<Composition::IVisualInterop>()->SetClippingPath(pathGeometry.get());
   }
 
-  if (m_needsBorderUpdate || m_layoutMetrics != layoutMetrics) {
-    m_needsBorderUpdate = false;
-    UpdateSpecialBorderLayers(layoutMetrics, viewProps);
+  if (m_layoutMetrics != layoutMetrics) {
+    m_needsBorderUpdate = true;
   }
 }
 
@@ -1219,7 +1230,12 @@ void CompositionViewComponentView::updateLayoutMetrics(
   });
 }
 
-void CompositionViewComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept {}
+void CompositionViewComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept {
+  if (m_needsBorderUpdate) {
+    m_needsBorderUpdate = false;
+    UpdateSpecialBorderLayers(m_layoutMetrics, *m_props);
+  }
+}
 
 void CompositionViewComponentView::prepareForRecycle() noexcept {}
 facebook::react::Props::Shared CompositionViewComponentView::props() noexcept {

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

@@ -558,14 +558,6 @@ WindowsTextInputComponentView::supplementalComponentDescriptorProviders() noexce
   return {};
 }
 
-void WindowsTextInputComponentView::parent(IComponentView *parent) noexcept {
-  if (!parent && rootComponentView()->GetFocusedComponent() == this) {
-    rootComponentView()->SetFocusedComponent(nullptr); // TODO need move focus logic - where should focus go?
-  }
-
-  Super::parent(parent);
-}
-
 void WindowsTextInputComponentView::mountChildComponentView(
     IComponentView &childComponentView,
     uint32_t index) noexcept {

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

@@ -46,7 +46,6 @@ struct WindowsTextInputComponentView : CompositionBaseComponentView {
   void handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept override;
   int64_t sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept override;
   facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
-  void parent(IComponentView *parent) noexcept override;
   void OnRenderingDeviceLost() noexcept override;
   winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
   void onFocusLost() noexcept override;

package/Microsoft.ReactNative/Utils/ImageUtils.cpp

@@ -5,6 +5,8 @@
 #include "ImageUtils.h"
 
 #include <Shared/cdebug.h>
+#include <Utils/CppWinrtLessExceptions.h>
+#include <windows.Web.Http.h>
 #include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
@@ -24,7 +26,10 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImag
     auto httpMethod{
         source.method.empty() ? winrt::HttpMethod::Get() : winrt::HttpMethod{winrt::to_hstring(source.method)}};
 
-    winrt::Uri uri{winrt::to_hstring(source.uri)};
+    winrt::Uri uri = UriTryCreate(winrt::to_hstring(source.uri));
+    if (!uri) {
+      co_return nullptr;
+    }
     winrt::HttpRequestMessage request{httpMethod, uri};
 
     if (!source.headers.empty()) {
@@ -39,14 +44,56 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImag
     }
 
     winrt::HttpClient httpClient;
-    winrt::HttpResponseMessage response{co_await httpClient.SendRequestAsync(request)};
+    auto httpClientAbi = reinterpret_cast<ABI::Windows::Web::Http::IHttpClient *>(winrt::get_abi(httpClient));
+
+    winrt::Windows::Foundation::IAsyncOperationWithProgress<
+        winrt::Windows::Web::Http::HttpResponseMessage,
+        winrt::Windows::Web::Http::HttpProgress>
+        asyncRequest{nullptr};
+
+    if (FAILED(httpClientAbi->SendRequestAsync(
+            reinterpret_cast<ABI::Windows::Web::Http::IHttpRequestMessage *>(winrt::get_abi(request)),
+            reinterpret_cast<
+                ABI::Windows::Foundation::
+                    __FIAsyncOperationWithProgress_2_Windows__CWeb__CHttp__CHttpResponseMessage_Windows__CWeb__CHttp__CHttpProgress_t
+                        **>(winrt::put_abi(asyncRequest))))) {
+      co_return nullptr;
+    }
+
+    if (!asyncRequest) {
+      co_return nullptr;
+    }
+
+    co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
+        winrt::Windows::Web::Http::HttpResponseMessage,
+        winrt::Windows::Web::Http::HttpProgress>>{asyncRequest};
+
+    if (FAILED(asyncRequest.ErrorCode())) {
+      co_return nullptr;
+    }
+
+    winrt::HttpResponseMessage response{asyncRequest.GetResults()};
 
     if (response && response.StatusCode() == winrt::HttpStatusCode::Ok) {
-      winrt::IInputStream inputStream{co_await response.Content().ReadAsInputStreamAsync()};
+      auto asyncRead = response.Content().ReadAsInputStreamAsync();
+      co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
+          winrt::Windows::Storage::Streams::IInputStream,
+          uint64_t>>{asyncRead};
+      if (FAILED(asyncRead.ErrorCode())) {
+        co_return nullptr;
+      }
+
+      winrt::IInputStream inputStream{asyncRead.GetResults()};
       winrt::InMemoryRandomAccessStream memoryStream;
-      co_await winrt::RandomAccessStream::CopyAsync(inputStream, memoryStream);
-      memoryStream.Seek(0);
 
+      auto asyncCopy = winrt::RandomAccessStream::CopyAsync(inputStream, memoryStream);
+      co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<uint64_t, uint64_t>>{
+          asyncCopy};
+      if (FAILED(asyncCopy.ErrorCode())) {
+        co_return nullptr;
+      }
+
+      memoryStream.Seek(0);
       co_return memoryStream;
     }
   } catch (winrt::hresult_error const &e) {
@@ -91,4 +138,20 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageMemoryStreamAsync(Rea
   }
 }
 
-} // namespace Microsoft::ReactNative
+// C# provides System.Uri.TryCreate, but no native equivalent seems to exist
+winrt::Uri UriTryCreate(winrt::param::hstring const &uri) {
+  auto factory = winrt::
+      get_activation_factory<winrt::Windows::Foundation::Uri, winrt::Windows::Foundation::IUriRuntimeClassFactory>();
+  auto abiFactory = static_cast<ABI::Windows::Foundation::IUriRuntimeClassFactory *>(winrt::get_abi(factory));
+
+  const winrt::hstring &localUri = uri;
+  winrt::Windows::Foundation::Uri returnValue{nullptr};
+  if (FAILED(abiFactory->CreateUri(
+          static_cast<HSTRING>(winrt::get_abi(localUri)),
+          reinterpret_cast<ABI::Windows::Foundation::IUriRuntimeClass **>(winrt::put_abi(returnValue))))) {
+    return winrt::Windows::Foundation::Uri{nullptr};
+  }
+  return returnValue;
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/ImageUtils.h

@@ -32,4 +32,6 @@ winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IR
 winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
 GetImageInlineDataAsync(ReactImageSource source);
 
-} // namespace Microsoft::ReactNative
+winrt::Windows::Foundation::Uri UriTryCreate(winrt::param::hstring const &uri);
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/ValueUtils.cpp

@@ -7,6 +7,7 @@
 #include <UI.Xaml.Markup.h>
 #include <UI.Xaml.Media.h>
 #include <Utils/ValueUtils.h>
+#include <windows.foundation.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 #include "Unicode.h"
 #include "XamlUtils.h"
@@ -313,15 +314,6 @@ REACTWINDOWS_API_(winrt::TimeSpan) TimeSpanFromMs(double ms) {
   return dur;
 }
 
-// C# provides System.Uri.TryCreate, but no native equivalent seems to exist
-winrt::Uri UriTryCreate(winrt::param::hstring const &uri) {
-  try {
-    return winrt::Uri(uri);
-  } catch (...) {
-    return winrt::Uri(nullptr);
-  }
-}
-
 bool IsValidOptionalColorValue(const winrt::Microsoft::ReactNative::JSValue &v) {
   return v.Type() == winrt::Microsoft::ReactNative::JSValueType::Null || IsValidColorValue(v);
 }

package/Microsoft.ReactNative/Utils/ValueUtils.h

@@ -56,8 +56,6 @@ IsValidColorValue(const winrt::Microsoft::ReactNative::JSValue &v);
 REACTWINDOWS_API_(winrt::Windows::Foundation::TimeSpan)
 TimeSpanFromMs(double ms);
 
-winrt::Uri UriTryCreate(winrt::param::hstring const &uri);
-
 winrt::Windows::UI::Color ColorFromNumber(DWORD argb) noexcept;
 
 bool IsValidOptionalColorValue(const winrt::Microsoft::ReactNative::JSValue &v);

package/Microsoft.ReactNative/Views/Image/ReactImage.cpp

@@ -12,7 +12,6 @@
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
 
-#include <Utils/ValueUtils.h>
 #include <Views/DynamicAutomationPeer.h>
 #include "Unicode.h"
 #include "XamlView.h"

package/Microsoft.ReactNative/Views/ViewViewManager.cpp

@@ -376,6 +376,7 @@ void ViewViewManager::GetNativeProps(const winrt::Microsoft::ReactNative::IJSVal
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"focusable", L"boolean");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"enableFocusRing", L"boolean");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"tabIndex", L"number");
+  winrt::Microsoft::ReactNative::WriteProperty(writer, L"collapsable", L"boolean");
 }
 
 bool ViewViewManager::UpdateProperty(

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,7 +10,7 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.618</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.620</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewEventEmitter.cpp

@@ -0,0 +1,127 @@
+/*
+ * 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.
+ */
+
+#include "ViewEventEmitter.h"
+
+namespace facebook::react {
+
+#pragma mark - Accessibility
+
+void ViewEventEmitter::onAccessibilityAction(std::string const &name) const {
+  dispatchEvent("accessibilityAction", [name](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "actionName", name);
+    return payload;
+  });
+}
+
+void ViewEventEmitter::onAccessibilityTap() const {
+  dispatchEvent("accessibilityTap");
+}
+
+void ViewEventEmitter::onAccessibilityMagicTap() const {
+  dispatchEvent("magicTap");
+}
+
+void ViewEventEmitter::onAccessibilityEscape() const {
+  dispatchEvent("accessibilityEscape");
+}
+
+#pragma mark - Layout
+
+void ViewEventEmitter::onLayout(const LayoutMetrics &layoutMetrics) const {
+  // A copy of a shared pointer (`layoutEventState_`) establishes shared
+  // ownership that will be captured by lambda.
+  auto layoutEventState = layoutEventState_;
+
+  // Dispatched `frame` values to JavaScript thread are throttled here.
+  // Basic ideas:
+  //  - Scheduling a lambda with some value that already was dispatched, does
+  //    nothing.
+  //  - If some lambda is already in flight, we don't schedule another;
+  //  - When a lambda is being executed on the JavaScript thread, the *most
+  //    recent* `frame` value is used (not the value that was current at the
+  //    moment of scheduling the lambda).
+  //
+  // This implies the following caveats:
+  //  - Some events can be skipped;
+  //  - When values change rapidly, even events with different values
+  //    can be skipped (only the very last will be delivered).
+  //  - Ordering is preserved.
+
+  {
+    std::lock_guard<std::mutex> guard(layoutEventState->mutex);
+
+    // If a *particular* `frame` was already dispatched to the JavaScript side,
+    // no other work is required.
+    if (layoutEventState->frame == layoutMetrics.frame &&
+        layoutEventState->wasDispatched) {
+      return;
+    }
+
+    // If the *particular* `frame` was not already dispatched *or*
+    // some *other* `frame` was dispatched before,
+    // we need to schedule the dispatching.
+    layoutEventState->wasDispatched = false;
+    layoutEventState->frame = layoutMetrics.frame;
+
+    // Something is already in flight, dispatching another event is not
+    // required.
+    if (layoutEventState->isDispatching) {
+      return;
+    }
+
+    layoutEventState->isDispatching = true;
+  }
+
+  dispatchEvent(
+      "layout",
+      [layoutEventState](jsi::Runtime &runtime) {
+        auto frame = Rect{};
+
+        {
+          std::lock_guard<std::mutex> guard(layoutEventState->mutex);
+
+          layoutEventState->isDispatching = false;
+
+          // If some *particular* `frame` was already dispatched before,
+          // and since then there were no other new values of the `frame`
+          // observed, do nothing.
+          if (layoutEventState->wasDispatched) {
+            return jsi::Value::null();
+          }
+
+          frame = layoutEventState->frame;
+
+          // If some *particular* `frame` was *not* already dispatched before,
+          // it's time to dispatch it and mark as dispatched.
+          layoutEventState->wasDispatched = true;
+        }
+
+        auto layout = jsi::Object(runtime);
+        layout.setProperty(runtime, "x", frame.origin.x);
+        layout.setProperty(runtime, "y", frame.origin.y);
+        layout.setProperty(runtime, "width", frame.size.width);
+        layout.setProperty(runtime, "height", frame.size.height);
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "layout", std::move(layout));
+        return jsi::Value(std::move(payload));
+      },
+      EventPriority::AsynchronousUnbatched);
+}
+
+// [Windows]
+void ViewEventEmitter::onFocus() const {
+  dispatchEvent("focus");
+}
+
+// [Windows]
+void ViewEventEmitter::onBlur() const {
+  dispatchEvent("blur");
+}
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewEventEmitter.h

@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/ReactPrimitives.h>
+
+#include "TouchEventEmitter.h"
+
+namespace facebook {
+namespace react {
+
+struct FocusEvent {
+  int target;
+};
+
+class ViewEventEmitter;
+
+using SharedViewEventEmitter = std::shared_ptr<const ViewEventEmitter>;
+
+class ViewEventEmitter : public TouchEventEmitter {
+ public:
+  using TouchEventEmitter::TouchEventEmitter;
+
+#pragma mark - Accessibility
+
+  void onAccessibilityAction(std::string const &name) const;
+  void onAccessibilityTap() const;
+  void onAccessibilityMagicTap() const;
+  void onAccessibilityEscape() const;
+
+#pragma mark - Layout
+
+  void onLayout(const LayoutMetrics &layoutMetrics) const;
+
+#pragma mark - NativeHostPlatform
+
+  void onFocus() const; // [Windows]
+  void onBlur() const; // [Windows]
+
+ private:
+  /*
+   * Contains the most recent `frame` and a `mutex` protecting access to it.
+   */
+  struct LayoutEventState {
+    /*
+     * Protects an access to other fields of the struct.
+     */
+    std::mutex mutex;
+
+    /*
+     * Last dispatched `frame` value or value that's being dispatched right now.
+     */
+    Rect frame{};
+
+    /*
+     * Indicates that the `frame` value was already dispatched (and dispatching
+     * of the *same* value is not needed).
+     */
+    bool wasDispatched{false};
+
+    /*
+     * Indicates that some lambda is already being dispatching (and dispatching
+     * another one is not needed).
+     */
+    bool isDispatching{false};
+  };
+
+  mutable std::shared_ptr<LayoutEventState> layoutEventState_{
+      std::make_shared<LayoutEventState>()};
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewProps.cpp

@@ -283,6 +283,19 @@ ViewProps::ViewProps(
     return;                                             \
   }
 
+// [Windows]
+#define HOST_PLATFORM_VIEW_EVENT_CASE(eventType)                      \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): { \
+    const auto offset = HostPlatformViewEvents::Offset::eventType;  \
+    HostPlatformViewEvents defaultViewEvents{};                     \
+    bool res = defaultViewEvents[offset];               \
+    if (value.hasValue()) {                             \
+      fromRawValue(context, value, res);                \
+    }                                                   \
+    platformEvents[offset] = res;                               \
+    return;                                             \
+  }
+
 void ViewProps::setProp(
     const PropsParserContext &context,
     RawPropsPropNameHash hash,
@@ -339,6 +352,8 @@ void ViewProps::setProp(
     VIEW_EVENT_CASE(TouchCancel);
     VIEW_EVENT_CASE(MouseEnter); // [Windows]
     VIEW_EVENT_CASE(MouseLeave); // [Windows]
+    HOST_PLATFORM_VIEW_EVENT_CASE(Focus); // [Windows]
+    HOST_PLATFORM_VIEW_EVENT_CASE(Blur); // [Windows]
 
 #ifdef ANDROID
     RAW_SET_PROP_SWITCH_CASE_BASIC(elevation, {});

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewProps.h

@@ -77,6 +77,8 @@ class ViewProps : public YogaStylableProps, public AccessibilityProps {
 
   ViewEvents events{};
 
+  HostPlatformViewEvents platformEvents{}; // [Windows]
+
   bool collapsable{true};
 
   bool removeClippedSubviews{false};

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewShadowNode.cpp

@@ -56,6 +56,8 @@ void ViewShadowNode::initialize() noexcept {
       viewProps.importantForAccessibility != ImportantForAccessibility::Auto ||
       viewProps.removeClippedSubviews;
 
+  formsStackingContext = formsStackingContext || viewProps.platformEvents.bits.any(); // [Windows]
+
 #ifdef ANDROID
   formsStackingContext = formsStackingContext || viewProps.elevation != 0;
 #endif

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/primitives.h

@@ -82,6 +82,33 @@ inline static bool operator!=(ViewEvents const &lhs, ViewEvents const &rhs) {
   return lhs.bits != rhs.bits;
 }
 
+// [Windows]
+struct HostPlatformViewEvents {
+  std::bitset<32> bits{};
+
+  enum class Offset : std::size_t {
+    Focus = 0,
+    Blur = 1,
+  };
+  
+  constexpr bool operator[](const Offset offset) const {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+
+  std::bitset<32>::reference operator[](const Offset offset) {
+    return bits[static_cast<std::size_t>(offset)];
+  }
+  };
+
+
+inline static bool operator==(HostPlatformViewEvents const &lhs, HostPlatformViewEvents const &rhs) {
+  return lhs.bits == rhs.bits;
+}
+
+inline static bool operator!=(HostPlatformViewEvents const &lhs, HostPlatformViewEvents const &rhs) {
+  return lhs.bits != rhs.bits;
+}
+
 enum class BackfaceVisibility : uint8_t { Auto, Visible, Hidden };
 
 enum class BorderCurve : uint8_t { Circular, Continuous };

package/Shared/Networking/WinRTWebSocketResource.cpp

@@ -11,6 +11,8 @@
 #include <dispatchQueue/dispatchQueue.h>
 
 // Windows API
+#include <windows.Networking.Sockets.h>
+#include <windows.Storage.Streams.h>
 #include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Security.Cryptography.h>
 
@@ -203,7 +205,7 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
   }
 
   try {
-    size_t length;
+    size_t length = 0;
     string messageLocal;
     bool isBinaryLocal;
     {
@@ -216,8 +218,10 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
       self->m_socket.Control().MessageType(SocketMessageType::Binary);
 
       auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(messageLocal));
-      length = buffer.Length();
-      self->m_writer.WriteBuffer(buffer);
+      if (buffer) {
+        length = buffer.Length();
+        self->m_writer.WriteBuffer(buffer);
+      }
     } else {
       self->m_socket.Control().MessageType(SocketMessageType::Utf8);
 
@@ -292,49 +296,59 @@ void WinRTWebSocketResource::Synchronize() noexcept {
 #pragma region IWebSocketResource
 
 void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
-  m_socket.MessageReceived(
-      [self = shared_from_this()](IWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
-        try {
-          string response;
-          IDataReader reader = args.GetDataReader();
-          auto len = reader.UnconsumedBufferLength();
-          if (args.MessageType() == SocketMessageType::Utf8) {
-            reader.UnicodeEncoding(UnicodeEncoding::Utf8);
-            vector<uint8_t> data(len);
-            reader.ReadBytes(data);
-
-            response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
-          } else {
-            auto buffer = reader.ReadBuffer(len);
-            winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
-
-            response = winrt::to_string(std::wstring_view(data));
-          }
-
-          if (self->m_readHandler) {
-            self->m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
-          }
-        } catch (hresult_error const &e) {
-          if (self->m_errorHandler) {
-            string errorMessage;
-            ErrorType errorType;
-            // See
-            // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-19041#remarks
-            if (e.code() == WININET_E_CONNECTION_ABORTED) {
-              errorMessage = "[0x80072EFE] Underlying TCP connection suddenly terminated";
-              errorType = ErrorType::Connection;
-              self->m_errorHandler({errorMessage, errorType});
-
-              // Note: We are not clear whether all read-related errors should close the socket.
-              self->Close(CloseCode::BadPayload, std::move(errorMessage));
-            } else {
-              errorMessage = Utilities::HResultToString(e);
-              errorType = ErrorType::Receive;
-              self->m_errorHandler({errorMessage, errorType});
-            }
-          }
+  m_socket.MessageReceived([self = shared_from_this()](
+                               IWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
+    try {
+      string response;
+
+      IDataReader reader{nullptr};
+      // Use ABI version to avoid throwing exceptions on expected code paths
+      HRESULT hr =
+          reinterpret_cast<ABI::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs *>(
+              winrt::get_abi(args))
+              ->GetDataReader(reinterpret_cast<ABI::Windows::Storage::Streams::IDataReader **>(winrt::put_abi(reader)));
+
+      if (FAILED(hr)) {
+        // See
+        // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-19041#remarks
+        if (hr == WININET_E_CONNECTION_ABORTED) {
+          string errorMessage{"[0x80072EFE] Underlying TCP connection suddenly terminated"};
+          self->m_errorHandler({errorMessage, ErrorType::Connection});
+          // Note: We are not clear whether all read-related errors should close the socket.
+          self->Close(CloseCode::BadPayload, std::move(errorMessage));
+        } else {
+          self->m_errorHandler({Utilities::HResultToString(hr), ErrorType::Receive});
         }
-      });
+        return;
+      }
+
+      auto len = reader.UnconsumedBufferLength();
+      if (args.MessageType() == SocketMessageType::Utf8) {
+        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+        vector<uint8_t> data(len);
+        reader.ReadBytes(data);
+
+        response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
+      } else {
+        auto buffer = reader.ReadBuffer(len);
+        winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+        response = winrt::to_string(std::wstring_view(data));
+      }
+
+      if (self->m_readHandler) {
+        self->m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
+      }
+    } catch (hresult_error const &e) {
+      if (self->m_errorHandler) {
+        string errorMessage;
+        ErrorType errorType;
+        errorMessage = Utilities::HResultToString(e);
+        errorType = ErrorType::Receive;
+        self->m_errorHandler({errorMessage, errorType});
+      }
+    }
+  });
 
   m_readyState = ReadyState::Connecting;
 

package/generate.js

@@ -7,4 +7,9 @@
 
 // This file provides a stable entry-point to call the generator for this
 // version of react-native-windows.
-module.exports = require('@react-native-windows/cli').generateWindows;
+
+try {
+  module.exports = require('@react-native-windows/cli').generateWindows;
+} catch (e) {
+  console.error('Failure during generate ', e);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.618",
+  "version": "0.0.0-canary.620",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "@react-native-community/cli": "10.0.0",
     "@react-native-community/cli-platform-android": "10.0.0",
     "@react-native-community/cli-platform-ios": "10.0.0",
-    "@react-native-windows/cli": "0.0.0-canary.163",
+    "@react-native-windows/cli": "0.0.0-canary.164",
     "@react-native/assets": "1.0.0",
     "@react-native/assets-registry": "^0.72.0",
     "@react-native/codegen": "^0.72.1",
@@ -61,7 +61,7 @@
     "ws": "^6.2.2"
   },
   "devDependencies": {
-    "@react-native-windows/codegen": "0.0.0-canary.51",
+    "@react-native-windows/codegen": "0.0.0-canary.52",
     "@rnw-scripts/babel-react-native-config": "0.0.0",
     "@rnw-scripts/eslint-config": "1.1.15",
     "@rnw-scripts/jest-out-of-tree-snapshot-resolver": "^1.1.1",
@@ -79,7 +79,7 @@
     "prettier": "^2.4.1",
     "react": "18.2.0",
     "react-native": "0.0.0-20230201-2114-a0800ffc7",
-    "react-native-platform-override": "^1.9.1",
+    "react-native-platform-override": "^1.9.2",
     "react-refresh": "^0.4.0",
     "typescript": "^4.9.5"
   },