react-native-windows 0.82.1 → 0.83.0-preview.0

package/Microsoft.ReactNative/ReactNativeAppBuilder.cpp

@@ -20,19 +20,6 @@ ReactNativeAppBuilder::ReactNativeAppBuilder() {
 
 ReactNativeAppBuilder::~ReactNativeAppBuilder() {}
 
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetDispatcherQueueController(
-    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
-      dispatcherQueueController);
-  return *this;
-}
-
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
-    winrt::Microsoft::UI::Composition::Compositor const &compositor) {
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
-  return *this;
-}
-
 winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
     winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
@@ -41,34 +28,6 @@ winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetA
 }
 
 winrt::Microsoft::ReactNative::ReactNativeWin32App ReactNativeAppBuilder::Build() {
-  // Create the DispatcherQueueController if the app developer doesn't provide one
-  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController() == nullptr) {
-    assert(m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr);
-
-    // Create a DispatcherQueue for this thread. This is needed for Composition, Content, and Input APIs.
-    auto dispatcherQueueController =
-        winrt::Microsoft::UI::Dispatching::DispatcherQueueController::CreateOnCurrentThread();
-
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
-        dispatcherQueueController);
-  }
-
-  // Create the Compositor if the app developer doesn't provide one
-  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr) {
-    // Create the compositor on behalf of the App Developer.
-    auto compositor = winrt::Microsoft::UI::Composition::Compositor();
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
-  }
-
-  // Create the AppWindow if the app developer doesn't provide one
-  if (m_reactNativeWin32App.AppWindow() == nullptr) {
-    auto appWindow = winrt::Microsoft::UI::Windowing::AppWindow::Create();
-    appWindow.Title(L"ReactNativeWin32App");
-    appWindow.Resize({1000, 1000});
-
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
-  }
-
   return m_reactNativeWin32App;
 }
 

package/Microsoft.ReactNative/ReactNativeAppBuilder.idl

@@ -18,12 +18,6 @@ namespace Microsoft.ReactNative {
 
         ReactViewOptions ReactViewOptions {get;};
 
-        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
-        // Microsoft.UI.Composition.Compositor Compositor {get;};
-        // Microsoft.UI.Content.DesktopChildSiteBridge DesktopChildSiteBridge {get;};
-        // Microsoft.UI.Dispatching DispatcherQueueController {get;};
-        // ReactNativeIsland ReactNativeIsland {get;};
-
         // Methods
         void Start();
      }
@@ -38,11 +32,6 @@ namespace Microsoft.ReactNative {
 
         ReactNativeAppBuilder SetAppWindow(Microsoft.UI.Windowing.AppWindow appWindow);
 
-        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
-        // Compositor depends on the DispatcherQueue created by DispatcherQueueController
-        // ReactNativeAppBuilder SetCompositor(Microsoft.UI.Composition.Compositor compositor);
-        // ReactNativeAppBuilder SetDispatcherQueueController(Microsoft.UI.Dispatching DispatcherQueueController);
-
         ReactNativeWin32App Build();
     }
 }

package/Microsoft.ReactNative/ReactNativeIsland.idl

@@ -80,9 +80,6 @@ namespace Microsoft.ReactNative
   DOC_STRING("A windows composition component that hosts React Native UI elements.")
   runtimeclass ReactNativeIsland
   {
-    DOC_STRING("Creates a new instance of @ReactNativeIsland. Can be implemented with a ReactViewHost or a ComponentView with reactContext")
-    ReactNativeIsland();
-
     ReactNativeIsland(Microsoft.UI.Composition.Compositor compositor);
 
     DOC_STRING("Used to create react portals, such as a native modal component.")
@@ -98,6 +95,8 @@ namespace Microsoft.ReactNative
 
     Windows.Foundation.Size Size { get; };
 
+    Microsoft.UI.Composition.Compositor Compositor { get; };
+
     DOC_STRING("ScaleFactor for this windows (DPI/96)")
     Single ScaleFactor {get; set;};
   

package/Microsoft.ReactNative/ReactNativeWin32App.cpp

@@ -15,34 +15,10 @@
 #include "winrt/Microsoft.UI.Interop.h"
 #include "winrt/Microsoft.UI.Windowing.h"
 
-// Scaling factor for the window's content based on the DPI of the display where the window is located.
-float ScaleFactor(HWND hwnd) noexcept {
-  return GetDpiForWindow(hwnd) / static_cast<float>(USER_DEFAULT_SCREEN_DPI);
-}
-
-void UpdateRootViewSizeToAppWindow(
-    winrt::Microsoft::ReactNative::ReactNativeIsland const &rootView,
-    winrt::Microsoft::UI::Windowing::AppWindow const &window) {
-  auto hwnd = winrt::Microsoft::UI::GetWindowFromWindowId(window.Id());
-  auto scaleFactor = ScaleFactor(hwnd);
-  winrt::Windows::Foundation::Size size{
-      window.ClientSize().Width / scaleFactor, window.ClientSize().Height / scaleFactor};
-  // Do not relayout when minimized
-  if (window.Presenter().as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>().State() !=
-      winrt::Microsoft::UI::Windowing::OverlappedPresenterState::Minimized) {
-    winrt::Microsoft::ReactNative::LayoutConstraints constraints;
-    constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::Undefined;
-    constraints.MaximumSize = constraints.MinimumSize = size;
-    rootView.Arrange(constraints, {0, 0});
-  }
-}
-
 namespace winrt::Microsoft::ReactNative::implementation {
 ReactNativeWin32App::ReactNativeWin32App() {}
 
 ReactNativeWin32App::~ReactNativeWin32App() {
-  m_desktopChildSiteBridge = nullptr;
-
   // Destroy all Composition objects
   if (m_compositor != nullptr) {
     m_compositor.Close();
@@ -51,7 +27,7 @@ ReactNativeWin32App::~ReactNativeWin32App() {
 }
 
 winrt::Microsoft::UI::Windowing::AppWindow ReactNativeWin32App::AppWindow() {
-  return m_appWindow;
+  return ReactNativeWindow().AppWindow();
 }
 
 void ReactNativeWin32App::AppWindow(winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
@@ -59,29 +35,19 @@ void ReactNativeWin32App::AppWindow(winrt::Microsoft::UI::Windowing::AppWindow c
 }
 
 winrt::Microsoft::UI::Composition::Compositor ReactNativeWin32App::Compositor() {
-  return m_compositor;
-}
-
-void ReactNativeWin32App::Compositor(winrt::Microsoft::UI::Composition::Compositor const &compositor) {
-  m_compositor = compositor;
-}
-
-void ReactNativeWin32App::DesktopChildSiteBridge(
-    winrt::Microsoft::UI::Content::DesktopChildSiteBridge const &desktopChildSiteBridge) {
-  m_desktopChildSiteBridge = desktopChildSiteBridge;
-}
-
-winrt::Microsoft::UI::Content::DesktopChildSiteBridge ReactNativeWin32App::DesktopChildSiteBridge() {
-  return m_desktopChildSiteBridge;
-}
+  if (m_compositor == nullptr) {
+    // Create a DispatcherQueue for this thread. This is needed for Composition, Content, and Input APIs.
+    m_dispatcherQueueController = winrt::Microsoft::UI::Dispatching::DispatcherQueueController::CreateOnCurrentThread();
 
-winrt::Microsoft::UI::Dispatching::DispatcherQueueController ReactNativeWin32App::DispatcherQueueController() {
-  return m_dispatcherQueueController;
-}
+    // Currently set the property to use current thread dispatcher as a default UI dispatcher.
+    ReactNativeHost().InstanceSettings().Properties().Set(
+        ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
 
-void ReactNativeWin32App::DispatcherQueueController(
-    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
-  m_dispatcherQueueController = dispatcherQueueController;
+    m_compositor = winrt::Microsoft::UI::Composition::Compositor();
+    winrt::Microsoft::ReactNative::Composition::CompositionUIService::SetCompositor(
+        ReactNativeHost().InstanceSettings(), m_compositor);
+  }
+  return m_compositor;
 }
 
 winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeWin32App::ReactNativeHost() {
@@ -91,18 +57,6 @@ winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeWin32App::ReactNativeH
   return m_host;
 }
 
-void ReactNativeWin32App::ReactNativeHost(winrt::Microsoft::ReactNative::ReactNativeHost const &host) {
-  m_host = host;
-}
-
-winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeWin32App::ReactNativeIsland() {
-  return m_reactNativeIsland;
-}
-
-void ReactNativeWin32App::ReactNativeIsland(winrt::Microsoft::ReactNative::ReactNativeIsland const &reactNativeIsland) {
-  m_reactNativeIsland = reactNativeIsland;
-}
-
 winrt::Microsoft::ReactNative::ReactViewOptions ReactNativeWin32App::ReactViewOptions() {
   if (m_reactViewOptions == nullptr) {
     m_reactViewOptions = winrt::make<winrt::Microsoft::ReactNative::implementation::ReactViewOptions>();
@@ -114,45 +68,36 @@ void ReactNativeWin32App::ReactViewOptions(winrt::Microsoft::ReactNative::ReactV
   m_reactViewOptions = viewOptions;
 }
 
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWin32App::ReactNativeWindow() noexcept {
+  if (!m_rnWindow) {
+    if (m_appWindow) {
+      m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromWindow(m_appWindow, Compositor());
+    } else {
+      m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromCompositor(Compositor());
+      m_appWindow = m_rnWindow.AppWindow();
+      m_appWindow.Title(L"ReactNativeWin32App");
+      m_appWindow.Resize({1000, 1000});
+    }
+  }
+
+  return m_rnWindow;
+}
+
 void ReactNativeWin32App::Start() {
   // Show the hosting AppWindow
-  m_appWindow.Show();
-
-  // Currently set the property to use current thread dispatcher as a default UI dispatcher.
-  // TODO: Use the correct dispatcher from a developer-provided DispatcherQueueController
-  ReactNativeHost().InstanceSettings().Properties().Set(
-      ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
+  AppWindow().Show();
 
   auto hwnd{winrt::Microsoft::UI::GetWindowFromWindowId(m_appWindow.Id())};
 
   winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
       ReactNativeHost().InstanceSettings().Properties(), reinterpret_cast<uint64_t>(hwnd));
 
-  winrt::Microsoft::ReactNative::Composition::CompositionUIService::SetCompositor(
-      ReactNativeHost().InstanceSettings(), m_compositor);
-
   // Start the react-native instance, which will create a JavaScript runtime and load the applications bundle.
   ReactNativeHost().ReloadInstance();
 
-  // Create a RootView which will present a react-native component
-  if (m_reactNativeIsland == nullptr) {
-    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland(m_compositor);
-  }
-
-  m_reactNativeIsland.ReactViewHost(
+  m_rnWindow.ReactNativeIsland().ReactViewHost(
       winrt::Microsoft::ReactNative::ReactCoreInjection::MakeViewHost(ReactNativeHost(), ReactViewOptions()));
 
-  // Update the size of the RootView when the AppWindow changes size
-  m_appWindow.Changed([wkRootView = winrt::make_weak(m_reactNativeIsland)](
-                          winrt::Microsoft::UI::Windowing::AppWindow const &window,
-                          winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) {
-    if (args.DidSizeChange() || args.DidVisibilityChange()) {
-      if (auto rootView = wkRootView.get()) {
-        UpdateRootViewSizeToAppWindow(rootView, window);
-      }
-    }
-  });
-
   // Quit application when main window is closed
   m_appWindow.Destroying([this](
                              winrt::Microsoft::UI::Windowing::AppWindow const &window,
@@ -166,28 +111,13 @@ void ReactNativeWin32App::Start() {
     });
   });
 
-  // DesktopChildSiteBridge create a ContentSite that can host the RootView ContentIsland
-  m_desktopChildSiteBridge =
-      winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(m_compositor, m_appWindow.Id());
-
-  m_desktopChildSiteBridge.Connect(m_reactNativeIsland.Island());
-
-  m_desktopChildSiteBridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
-
-  auto scaleFactor = ScaleFactor(hwnd);
-  m_reactNativeIsland.ScaleFactor(scaleFactor);
-
-  UpdateRootViewSizeToAppWindow(m_reactNativeIsland, m_appWindow);
-
-  m_desktopChildSiteBridge.Show();
-
   // Run the main application event loop
   m_dispatcherQueueController.DispatcherQueue().RunEventLoop();
 
+  m_appWindow.Destroy();
+
   // Rundown the DispatcherQueue. This drains the queue and raises events to let components
   // know the message loop has finished.
   m_dispatcherQueueController.ShutdownQueue();
-
-  m_desktopChildSiteBridge.Close();
 }
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactNativeWin32App.h

@@ -15,20 +15,10 @@ struct ReactNativeWin32App : ReactNativeWin32AppT<ReactNativeWin32App> {
   winrt::Microsoft::UI::Windowing::AppWindow AppWindow();
 
   winrt::Microsoft::UI::Composition::Compositor Compositor();
-  void Compositor(winrt::Microsoft::UI::Composition::Compositor const &compositor);
-
-  winrt::Microsoft::UI::Content::DesktopChildSiteBridge DesktopChildSiteBridge();
-  void DesktopChildSiteBridge(winrt::Microsoft::UI::Content::DesktopChildSiteBridge const &desktopChildSiteBridge);
-
-  winrt::Microsoft::UI::Dispatching::DispatcherQueueController DispatcherQueueController();
-  void DispatcherQueueController(
-      winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController);
 
   winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeHost();
-  void ReactNativeHost(winrt::Microsoft::ReactNative::ReactNativeHost const &host);
 
-  winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeIsland();
-  void ReactNativeIsland(winrt::Microsoft::ReactNative::ReactNativeIsland const &reactNativeIsland);
+  winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow() noexcept;
 
   winrt::Microsoft::ReactNative::ReactViewOptions ReactViewOptions();
   void ReactViewOptions(winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions);
@@ -36,12 +26,11 @@ struct ReactNativeWin32App : ReactNativeWin32AppT<ReactNativeWin32App> {
   void Start();
 
  private:
+  winrt::Microsoft::ReactNative::ReactNativeWindow m_rnWindow{nullptr};
   winrt::Microsoft::UI::Windowing::AppWindow m_appWindow{nullptr};
   winrt::Microsoft::UI::Composition::Compositor m_compositor{nullptr};
-  winrt::Microsoft::UI::Content::DesktopChildSiteBridge m_desktopChildSiteBridge{nullptr};
   winrt::Microsoft::UI::Dispatching::DispatcherQueueController m_dispatcherQueueController{nullptr};
   winrt::Microsoft::ReactNative::ReactNativeHost m_host{nullptr};
-  winrt::Microsoft::ReactNative::ReactNativeIsland m_reactNativeIsland{nullptr};
   winrt::Microsoft::ReactNative::ReactViewOptions m_reactViewOptions{nullptr};
 };
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactNativeWindow.idl

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "ReactNativeIsland.idl";
+
+#include "NamespaceRedirect.h"
+#include "DocString.h"
+
+namespace Microsoft.ReactNative
+{
+
+  [experimental]
+  enum ContentSizePolicy
+  {
+    None,
+    ResizeContentToParentWindow,
+    ResizeParentWindowToContent,
+  };
+
+  [default_interface]
+  [webhosthidden]
+  [experimental]
+  DOC_STRING("Simplifies hosting a ReactNativeIsland inside a Window.")
+  runtimeclass ReactNativeWindow : Windows.Foundation.IClosable
+  {
+    static ReactNativeWindow CreateFromCompositor(Microsoft.UI.Composition.Compositor compositor);
+    static ReactNativeWindow CreateFromWindow(Microsoft.UI.Windowing.AppWindow appWindow, Microsoft.UI.Composition.Compositor compositor);
+    static ReactNativeWindow CreateFromContentSiteBridgeAndIsland(Microsoft.UI.Content.IContentSiteBridge bridge, Microsoft.ReactNative.ReactNativeIsland island);
+    static ReactNativeWindow CreateFromWindowAndIsland(Microsoft.UI.Windowing.AppWindow appWindow, Microsoft.ReactNative.ReactNativeIsland island);
+
+    ReactNativeIsland ReactNativeIsland { get; };
+
+    Microsoft.UI.Windowing.AppWindow AppWindow { get; };
+
+    Microsoft.UI.Content.IContentSiteBridge ContentSiteBridge { get; };
+    ContentSizePolicy ResizePolicy { get; set; };
+
+    DOC_STRING("When the ResizePolicy is set to ResizeParentWindowToContent, these LayoutConstraints will control the layout of the content."
+     " When ResizePolicy is set to ResizeContentToParentWindow, these constraints will be ignored. Instead the window can be constrained using"
+     " OverlappedPresenter.PreferredMaximumHeight etc.")
+    LayoutConstraints LayoutConstraints { get; set; };
+  }
+
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative.Cxx/AutoDraw.h

@@ -16,7 +16,10 @@ class AutoDrawDrawingSurface {
       POINT *offset) noexcept {
     drawingSurface.as(m_drawingSurfaceInterop);
     auto dpi = scaleFactor * 96.0f;
-    m_drawingSurfaceInterop->BeginDraw(m_d2dDeviceContext.put(), dpi, dpi, offset);
+    auto hr = m_drawingSurfaceInterop->BeginDraw(m_d2dDeviceContext.put(), dpi, dpi, offset);
+    if (FAILED(hr)) {
+      m_d2dDeviceContext = nullptr;
+    }
   }
 
   ~AutoDrawDrawingSurface() noexcept {
@@ -34,6 +37,11 @@ class AutoDrawDrawingSurface {
     return m_d2dDeviceContext.get();
   }
 
+  // Returns true if the device context is valid and safe to use for drawing operations
+  bool IsValid() const noexcept {
+    return m_d2dDeviceContext != nullptr;
+  }
+
  private:
   winrt::com_ptr<Experimental::ICompositionDrawingSurfaceInterop> m_drawingSurfaceInterop;
   winrt::com_ptr<ID2D1DeviceContext> m_d2dDeviceContext;

package/Microsoft.ReactNative.Cxx/ReactCommon/CallInvoker.h

@@ -18,7 +18,7 @@ class Runtime;
 
 namespace facebook::react {
 
-using CallFunc = std::function<void(jsi::Runtime&)>;
+using CallFunc = std::function<void(jsi::Runtime &)>;
 
 /**
  * An interface for a generic native-to-JS call invoker. See BridgeJSCallInvoker
@@ -26,23 +26,24 @@ using CallFunc = std::function<void(jsi::Runtime&)>;
  */
 class CallInvoker {
  public:
-  virtual void invokeAsync(CallFunc&& func) noexcept = 0;
-  virtual void invokeAsync(
-      SchedulerPriority /*priority*/,
-      CallFunc&& func) noexcept {
+  virtual void invokeAsync(CallFunc &&func) noexcept = 0;
+  virtual void invokeAsync(SchedulerPriority /*priority*/, CallFunc &&func) noexcept
+  {
     // When call with priority is not implemented, fall back to a regular async
     // execution
     invokeAsync(std::move(func));
   }
-  virtual void invokeSync(CallFunc&& func) = 0;
+  virtual void invokeSync(CallFunc &&func) = 0;
 
   // Backward compatibility only, prefer the CallFunc methods instead
-  virtual void invokeAsync(std::function<void()>&& func) noexcept {
-    invokeAsync([func](jsi::Runtime&) { func(); });
+  virtual void invokeAsync(std::function<void()> &&func) noexcept
+  {
+    invokeAsync([func = std::move(func)](jsi::Runtime &) { func(); });
   }
 
-  virtual void invokeSync(std::function<void()>&& func) {
-    invokeSync([func](jsi::Runtime&) { func(); });
+  virtual void invokeSync(std::function<void()> &&func)
+  {
+    invokeSync([func = std::move(func)](jsi::Runtime &) { func(); });
   }
 
   virtual ~CallInvoker() = default;
@@ -52,12 +53,8 @@ using NativeMethodCallFunc = std::function<void()>;
 
 class NativeMethodCallInvoker {
  public:
-  virtual void invokeAsync(
-      const std::string& methodName,
-      NativeMethodCallFunc&& func) noexcept = 0;
-  virtual void invokeSync(
-      const std::string& methodName,
-      NativeMethodCallFunc&& func) = 0;
+  virtual void invokeAsync(const std::string &methodName, NativeMethodCallFunc &&func) noexcept = 0;
+  virtual void invokeSync(const std::string &methodName, NativeMethodCallFunc &&func) = 0;
   virtual ~NativeMethodCallInvoker() = default;
 };
 

package/Microsoft.ReactNative.Cxx/ReactCommon/TurboModule.h

@@ -36,9 +36,7 @@ enum TurboModuleMethodValueKind {
 /**
  * Determines TurboModuleMethodValueKind based on the jsi::Value type.
  */
-TurboModuleMethodValueKind getTurboModuleMethodValueKind(
-    jsi::Runtime& rt,
-    const jsi::Value* value);
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(jsi::Runtime &rt, const jsi::Value *value);
 
 class TurboCxxModule;
 class TurboModuleBinding;
@@ -55,8 +53,8 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
   // JS representation. To customize lookup of properties, override `create`.
   // Note: keep this method declared inline to avoid conflicts
   // between RTTI and non-RTTI compilation units
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName)
-      override {
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &propName) override
+  {
     auto prop = create(runtime, propName);
     // If we have a JS wrapper, cache the result of this lookup
     // We don't cache misses, to allow for methodMap_ to dynamically be
@@ -64,15 +62,14 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
     // [Windows] Reenable once https://github.com/microsoft/react-native-windows/issues/14128 is fixed
 #ifndef WINAPI_FAMILY
     if (jsRepresentation_ && !prop.isUndefined()) {
-      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
-          runtime, propName, prop);
+      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(runtime, propName, prop);
     }
 #endif
     return prop;
   }
 
-  std::vector<jsi::PropNameID> getPropertyNames(
-      jsi::Runtime& runtime) override {
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &runtime) override
+  {
     std::vector<jsi::PropNameID> result;
     result.reserve(methodMap_.size());
     for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
@@ -87,18 +84,14 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
 
   struct MethodMetadata {
     size_t argCount;
-    jsi::Value (*invoker)(
-        jsi::Runtime& rt,
-        TurboModule& turboModule,
-        const jsi::Value* args,
-        size_t count);
+    jsi::Value (*invoker)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t count);
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
-  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
-      eventEmitterMap_;
 
-  using ArgFactory =
-      std::function<void(jsi::Runtime& runtime, std::vector<jsi::Value>& args)>;
+  friend class TurboModuleTestFixtureInternal;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>> eventEmitterMap_;
+
+  using ArgFactory = std::function<void(jsi::Runtime &runtime, std::vector<jsi::Value> &args)>;
 
   /**
    * Calls RCTDeviceEventEmitter.emit to JavaScript, with given event name and
@@ -112,35 +105,31 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
    *      args.emplace_back(jsi::Value(42));
    *  });
    */
-  void emitDeviceEvent(
-      const std::string& eventName,
-      ArgFactory&& argFactory = nullptr);
+  void emitDeviceEvent(const std::string &eventName, ArgFactory &&argFactory = nullptr);
 
   // Backwards compatibility version
   void emitDeviceEvent(
-      jsi::Runtime& /*runtime*/,
+      jsi::Runtime & /*runtime*/,
 
-      const std::string& eventName,
-      ArgFactory&& argFactory = nullptr) {
+      const std::string &eventName,
+      ArgFactory &&argFactory = nullptr)
+  {
     emitDeviceEvent(eventName, std::move(argFactory));
   }
 
-  virtual jsi::Value create(
-      jsi::Runtime& runtime,
-      const jsi::PropNameID& propName) {
+  virtual jsi::Value create(jsi::Runtime &runtime, const jsi::PropNameID &propName)
+  {
     std::string propNameUtf8 = propName.utf8(runtime);
-    if (auto methodIter = methodMap_.find(propNameUtf8);
-        methodIter != methodMap_.end()) {
-      const MethodMetadata& meta = methodIter->second;
+    if (auto methodIter = methodMap_.find(propNameUtf8); methodIter != methodMap_.end()) {
+      const MethodMetadata &meta = methodIter->second;
       return jsi::Function::createFromHostFunction(
           runtime,
           propName,
           static_cast<unsigned int>(meta.argCount),
           [this, meta](
-              jsi::Runtime& rt,
-              [[maybe_unused]] const jsi::Value& thisVal,
-              const jsi::Value* args,
-              size_t count) { return meta.invoker(rt, *this, args, count); });
+              jsi::Runtime &rt, [[maybe_unused]] const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
+            return meta.invoker(rt, *this, args, count);
+          });
     } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
                eventEmitterIter != eventEmitterMap_.end()) {
       return eventEmitterIter->second->get(runtime, jsInvoker_);
@@ -159,7 +148,6 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
  * An app/platform-specific provider function to get an instance of a module
  * given a name.
  */
-using TurboModuleProviderFunctionType =
-    std::function<std::shared_ptr<TurboModule>(const std::string& name)>;
+using TurboModuleProviderFunctionType = std::function<std::shared_ptr<TurboModule>(const std::string &name)>;
 
 } // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/TurboModuleUtils.h

@@ -16,19 +16,16 @@
 namespace facebook::react {
 
 struct Promise : public LongLivedObject {
-  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
+  Promise(jsi::Runtime &rt, jsi::Function resolve, jsi::Function reject);
 
-  void resolve(const jsi::Value& result);
-  void reject(const std::string& message);
+  void resolve(const jsi::Value &result);
+  void reject(const std::string &message);
 
   jsi::Function resolve_;
   jsi::Function reject_;
 };
 
-using PromiseSetupFunctionType =
-    std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
-jsi::Value createPromiseAsJSIValue(
-    jsi::Runtime& rt,
-    PromiseSetupFunctionType&& func);
+using PromiseSetupFunctionType = std::function<void(jsi::Runtime &rt, std::shared_ptr<Promise>)>;
+jsi::Value createPromiseAsJSIValue(jsi::Runtime &rt, PromiseSetupFunctionType &&func);
 
 } // namespace facebook::react

package/Microsoft.ReactNative.Cxx/ReactCommon/react/bridging/AString.h

@@ -16,25 +16,27 @@ namespace facebook::react {
 
 template <>
 struct Bridging<std::string> {
-  static std::string fromJs(jsi::Runtime& rt, const jsi::String& value) {
+  static std::string fromJs(jsi::Runtime &rt, const jsi::String &value)
+  {
     return value.utf8(rt);
   }
 
-  static jsi::String toJs(jsi::Runtime& rt, const std::string& value) {
+  static jsi::String toJs(jsi::Runtime &rt, const std::string &value)
+  {
     return jsi::String::createFromUtf8(rt, value);
   }
 };
 
 template <>
 struct Bridging<std::string_view> {
-  static jsi::String toJs(jsi::Runtime& rt, std::string_view value) {
-    return jsi::String::createFromUtf8(
-        rt, reinterpret_cast<const uint8_t*>(value.data()), value.length());
+  static jsi::String toJs(jsi::Runtime &rt, std::string_view value)
+  {
+    return jsi::String::createFromUtf8(rt, reinterpret_cast<const uint8_t *>(value.data()), value.length());
   }
 };
 
 template <>
-struct Bridging<const char*> : Bridging<std::string_view> {};
+struct Bridging<const char *> : Bridging<std::string_view> {};
 
 template <size_t N>
 struct Bridging<char[N]> : Bridging<std::string_view> {};