react-native-windows 0.74.20 → 0.74.22

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

@@ -72,9 +72,10 @@ HRESULT UiaNavigateHelper(
       auto parentCV = view.Parent().as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
       if (parentCV != nullptr) {
         auto children = parentCV->Children();
-        for (auto it = children.end(); it != children.begin(); --it) {
-          if (*it == view) {
-            uiaProvider = (*it)
+        for (auto i = children.Size() - 1; i > 0; i--) {
+          auto child = children.GetAt(i);
+          if (child == view) {
+            uiaProvider = children.GetAt(i - 1)
                               .as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()
                               ->EnsureUiaProvider();
             break;
@@ -121,7 +122,9 @@ HRESULT UiaSetFocusHelper(::Microsoft::ReactNative::ReactTaggedView &view) noexc
   if (rootCV == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  return rootCV->TrySetFocusedComponent(strongView) ? S_OK : E_FAIL;
+  return rootCV->TrySetFocusedComponent(strongView, winrt::Microsoft::ReactNative::FocusNavigationDirection::None)
+      ? S_OK
+      : E_FAIL;
 }
 
 bool WasUiaPropertyAdvised(winrt::com_ptr<IRawElementProviderSimple> &providerSimple, PROPERTYID propId) noexcept {
@@ -162,4 +165,53 @@ void UpdateUiaProperty(
       spProviderSimple.get(), propId, CComVariant(oldValue.c_str()), CComVariant(newValue.c_str()));
 }
 
+long GetLiveSetting(const std::string &liveRegion) noexcept {
+  if (liveRegion == "polite") {
+    return LiveSetting::Polite;
+  } else if (liveRegion == "assertive") {
+    return LiveSetting::Assertive;
+  }
+  return LiveSetting::Off;
+}
+
+std::string extractAccessibilityValue(const facebook::react::AccessibilityValue &value) noexcept {
+  if (value.now.has_value()) {
+    return std::to_string(value.now.value());
+  } else if (value.text.has_value()) {
+    return value.text.value();
+  } else {
+    return "";
+  }
+}
+
+void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept {
+  auto strongView = view.view();
+
+  if (!strongView)
+    return;
+
+  auto baseView = strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+  if (baseView == nullptr)
+    return;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(baseView->props());
+  if (props == nullptr)
+    return;
+
+  auto accessibilityActions = props->accessibilityActions;
+  for (size_t i = 0; i < accessibilityActions.size(); i++) {
+    if (accessibilityActions[i].name == action) {
+      baseView->GetEventEmitter()->onAccessibilityAction(action);
+    }
+  }
+}
+
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
+  if (expanded) {
+    return ExpandCollapseState_Expanded;
+  } else {
+    return ExpandCollapseState_Collapsed;
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -29,4 +29,11 @@ void UpdateUiaProperty(
     const std::string &oldValue,
     const std::string &newValue) noexcept;
 
+long GetLiveSetting(const std::string &liveRegion) noexcept;
+
+std::string extractAccessibilityValue(const facebook::react::AccessibilityValue &value) noexcept;
+
+void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
+
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -24,8 +24,7 @@ UnimplementedNativeViewComponentView::UnimplementedNativeViewComponentView(
           reactContext,
           ComponentViewFeatures::Default &
               ~(ComponentViewFeatures::Background | ComponentViewFeatures::ShadowProps |
-                ComponentViewFeatures::NativeBorder),
-          false) {
+                ComponentViewFeatures::NativeBorder)) {
   m_labelVisual = compContext.CreateSpriteVisual();
   OuterVisual().InsertAt(m_labelVisual, 1);
 }
@@ -38,8 +37,7 @@ winrt::Microsoft::ReactNative::ComponentView UnimplementedNativeViewComponentVie
 }
 
 void UnimplementedNativeViewComponentView::HandleCommand(
-    winrt::hstring commandName,
-    const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept {
+    const winrt::Microsoft::ReactNative::HandleCommandArgs &args) noexcept {
   // Do not call base to avoid unknown command asserts
 }
 

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

@@ -25,8 +25,7 @@ struct UnimplementedNativeViewComponentView
       facebook::react::LayoutMetrics const &layoutMetrics,
       facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
 
-  void HandleCommand(winrt::hstring commandName, const winrt::Microsoft::ReactNative::IJSValueReader &args) noexcept
-      override;
+  void HandleCommand(const winrt::Microsoft::ReactNative::HandleCommandArgs &args) noexcept override;
 
   UnimplementedNativeViewComponentView(
       const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -2,12 +2,15 @@
 // Licensed under the MIT License.
 
 #include "pch.h"
+#include "HandleCommandArgs.g.cpp"
+#include "HandleCommandArgs.g.h"
 #include <AsynchronousEventBeat.h>
 #include <DynamicReader.h>
 #include <DynamicWriter.h>
 #include <Fabric/ComponentView.h>
 #include <Fabric/Composition/CompositionUIService.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/Composition/ReactNativeIsland.h>
 #include <Fabric/Composition/RootComponentView.h>
 #include <Fabric/FabricUIManagerModule.h>
 #include <Fabric/ReactNativeConfigProperties.h>
@@ -160,7 +163,7 @@ void FabricUIManager::startSurface(
 
   facebook::react::LayoutContext layoutContext;
   layoutContext.pointScaleFactor = rootView.ScaleFactor();
-  layoutContext.fontSizeMultiplier = rootView.ScaleFactor();
+  layoutContext.fontSizeMultiplier = rootView.FontSizeMultiplier();
 
   m_surfaceManager->startSurface(
       surfaceId,
@@ -173,6 +176,9 @@ void FabricUIManager::startSurface(
 
 void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept {
   m_surfaceManager->stopSurface(surfaceId);
+  auto &rootDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);
+  m_registry.enqueueComponentViewWithComponentHandle(
+      facebook::react::RootShadowNode::Handle(), surfaceId, rootDescriptor);
 }
 
 winrt::Microsoft::ReactNative::ReactNativeIsland FabricUIManager::GetReactNativeIsland(
@@ -257,9 +263,10 @@ void FabricUIManager::RCTPerformMountInstructions(
         newChildComponentView->updateEventEmitter(newChildShadowView.eventEmitter);
         newChildComponentView->updateState(newChildShadowView.state, oldChildShadowView.state);
         newChildComponentView->updateLayoutMetrics(newChildShadowView.layoutMetrics, oldChildShadowView.layoutMetrics);
-        newChildViewDescriptor.view.FinalizeUpdates(winrt::Microsoft::ReactNative::ComponentViewUpdateMask::All);
+        newChildComponentView->FinalizeUpdates(winrt::Microsoft::ReactNative::ComponentViewUpdateMask::All);
 
-        parentViewDescriptor.view.MountChildComponentView(*newChildComponentView, mutation.index);
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(parentViewDescriptor.view)
+            ->MountChildComponentView(*newChildComponentView, mutation.index);
         break;
       }
 
@@ -268,7 +275,8 @@ void FabricUIManager::RCTPerformMountInstructions(
         auto &parentShadowView = mutation.parentShadowView;
         auto &oldChildViewDescriptor = m_registry.componentViewDescriptorWithTag(oldChildShadowView.tag);
         auto &parentViewDescriptor = m_registry.componentViewDescriptorWithTag(parentShadowView.tag);
-        parentViewDescriptor.view.UnmountChildComponentView(oldChildViewDescriptor.view, mutation.index);
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(parentViewDescriptor.view)
+            ->UnmountChildComponentView(oldChildViewDescriptor.view, mutation.index);
         break;
       }
 
@@ -302,7 +310,8 @@ void FabricUIManager::RCTPerformMountInstructions(
         }
 
         if (mask != winrt::Microsoft::ReactNative::ComponentViewUpdateMask::None) {
-          newChildViewDescriptor.view.FinalizeUpdates(mask);
+          winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(newChildViewDescriptor.view)
+              ->FinalizeUpdates(mask);
         }
 
         break;
@@ -381,22 +390,44 @@ void FabricUIManager::schedulerDidRequestPreliminaryViewAllocation(
   */
 }
 
+struct HandleCommandArgs : public winrt::Microsoft::ReactNative::implementation::HandleCommandArgsT<HandleCommandArgs> {
+  HandleCommandArgs(winrt::hstring commandName, folly::dynamic const &arg) : m_commandName(commandName), m_args(arg) {}
+
+  winrt::hstring CommandName() const noexcept {
+    return m_commandName;
+  }
+  winrt::Microsoft::ReactNative::IJSValueReader CommandArgs() const noexcept {
+    return winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(m_args);
+  }
+  bool Handled() const noexcept {
+    return m_handled;
+  }
+  void Handled(bool value) noexcept {
+    m_handled = value;
+  }
+
+ private:
+  folly::dynamic const &m_args;
+  const winrt::hstring m_commandName;
+  bool m_handled{false};
+};
+
 void FabricUIManager::schedulerDidDispatchCommand(
     facebook::react::ShadowView const &shadowView,
     std::string const &commandName,
     folly::dynamic const &arg) {
   if (m_context.UIDispatcher().HasThreadAccess()) {
     auto descriptor = m_registry.componentViewDescriptorWithTag(shadowView.tag);
-    descriptor.view.HandleCommand(
-        winrt::to_hstring(commandName), winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(arg));
+    winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(descriptor.view)
+        ->HandleCommand(winrt::make<HandleCommandArgs>(winrt::to_hstring(commandName), arg));
   } else {
     m_context.UIDispatcher().Post(
         [wkThis = weak_from_this(), commandName, tag = shadowView.tag, args = folly::dynamic(arg)]() {
           if (auto pThis = wkThis.lock()) {
             auto view = pThis->m_registry.findComponentViewWithTag(tag);
             if (view) {
-              view.HandleCommand(
-                  winrt::to_hstring(commandName), winrt::make<winrt::Microsoft::ReactNative::DynamicReader>(args));
+              winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->HandleCommand(
+                  winrt::make<HandleCommandArgs>(winrt::to_hstring(commandName), args));
             }
           }
         });

package/Microsoft.ReactNative/Fabric/ReactTaggedView.h

@@ -31,6 +31,10 @@ struct ReactTaggedView {
     return strongView;
   }
 
+  facebook::react::Tag Tag() const noexcept {
+    return m_tag;
+  }
+
  private:
   facebook::react::Tag m_tag;
   winrt::weak_ref<winrt::Microsoft::ReactNative::ComponentView> m_view;

package/Microsoft.ReactNative/Fabric/WindowsComponentDescriptorRegistry.cpp

@@ -74,9 +74,7 @@ void WindowsComponentDescriptorRegistry::Add(
        m_descriptorFlavors.back()->c_str(),
        std::static_pointer_cast<void const>(m_descriptorFlavors.back()),
        winrt::get_self<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>(builder)
-               ->IsViewComponent()
-           ? &facebook::react::concreteComponentDescriptorConstructor<AbiViewComponentDescriptor>
-           : &facebook::react::concreteComponentDescriptorConstructor<AbiComponentDescriptor>});
+           ->GetComponentDescriptorProvider()});
 }
 
 winrt::Microsoft::ReactNative::IReactViewComponentBuilder WindowsComponentDescriptorRegistry::GetDescriptor(

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

@@ -26,7 +26,27 @@ HostPlatformViewProps::HostPlatformViewProps(
       focusable(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.focusable
-              : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})) {}
+              : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})),
+      tooltip(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.tooltip
+              : convertRawProp(context, rawProps, "tooltip", sourceProps.tooltip, {})),
+      accessibilityPosInSet(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.accessibilityPosInSet
+              : convertRawProp(context, rawProps, "accessibilityPosInSet", sourceProps.accessibilityPosInSet, 0)),
+      accessibilitySetSize(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.accessibilitySetSize
+              : convertRawProp(context, rawProps, "accessibilitySetSize", sourceProps.accessibilitySetSize, 0)),
+      accessibilityLiveRegion(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.accessibilityLiveRegion
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "accessibilityLiveRegion",
+                                                       sourceProps.accessibilityLiveRegion,
+                                                       "none")) {}
 
 #define WINDOWS_VIEW_EVENT_CASE(eventType)                    \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): {       \
@@ -61,8 +81,12 @@ void HostPlatformViewProps::setProp(
     WINDOWS_VIEW_EVENT_CASE(MouseLeave);
     RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityPosInSet);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilitySetSize);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLiveRegion);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(tooltip);
   }
 }
 

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -24,9 +24,12 @@ class HostPlatformViewProps : public BaseViewProps {
   WindowsViewEvents windowsEvents{};
   bool enableFocusRing{true};
   bool focusable{false};
+  int accessibilityPosInSet{0};
+  int accessibilitySetSize{0};
+  std::string accessibilityLiveRegion{"none"};
 
   // std::optional<std::string> overflowAnchor{};
-  // std::optional<std::string> tooltip{};
+  std::optional<std::string> tooltip{};
   std::vector<HandledKeyEvent> keyDownEvents{};
   std::vector<HandledKeyEvent> keyUpEvents{};
 };

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -13,7 +13,7 @@ inline bool formsStackingContext(ViewProps const &viewProps) {
   // Only Views which are marked as focusable can actually trigger the events, which will already avoid being collapsed.
   constexpr decltype(WindowsViewEvents::bits) focusEventsMask = {
       (1 << (int)WindowsViewEvents::Offset::Focus) & (1 << (int)WindowsViewEvents::Offset::Blur)};
-  return (viewProps.windowsEvents.bits & focusEventsMask).any();
+  return (viewProps.windowsEvents.bits & focusEventsMask).any() || viewProps.tooltip;
 }
 
 inline bool formsView(ViewProps const &viewProps) {

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

@@ -43,7 +43,10 @@ void TextLayoutManager::GetTextLayout(
           static_cast<facebook::react::FontWeight>(DWRITE_FONT_WEIGHT_REGULAR))),
       style,
       DWRITE_FONT_STRETCH_NORMAL,
-      outerFragment.textAttributes.fontSize,
+      (outerFragment.textAttributes.allowFontScaling.value_or(true) &&
+       !std::isnan(outerFragment.textAttributes.fontSizeMultiplier))
+          ? (outerFragment.textAttributes.fontSizeMultiplier * outerFragment.textAttributes.fontSize)
+          : outerFragment.textAttributes.fontSize,
       L"",
       spTextFormat.put()));
 
@@ -118,7 +121,11 @@ void TextLayoutManager::GetTextLayout(
             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.fontSize, 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(

package/Microsoft.ReactNative/IReactCompositionViewComponentBuilder.idl

@@ -13,16 +13,26 @@ import "CompositionComponentView.idl";
 
 namespace Microsoft.ReactNative.Composition
 {
+  [webhosthidden]
+  [experimental]
+  delegate void ViewComponentViewInitializer(ViewComponentView view);
+
+  [webhosthidden]
   [experimental]
-  DOC_STRING("Provides a factory method to create an instance of a ViewComponentView. See @IReactCompositionViewComponentBuilder.SetCreateViewComponentView")
-  delegate Microsoft.ReactNative.Composition.ViewComponentView CompositionViewComponentViewFactory(CreateCompositionComponentViewArgs args);
+  delegate void ComponentIslandComponentViewInitializer(ContentIslandComponentView view);
+
+  [experimental]
+  [webhosthidden]
+  delegate Microsoft.UI.Composition.Visual CreateVisualDelegate(Microsoft.ReactNative.ComponentView view);
 
   [webhosthidden]
   [experimental]
   DOC_STRING(".")
   interface IReactCompositionViewComponentBuilder
   {
-    void SetCreateViewComponentView(CompositionViewComponentViewFactory impl);
+    void SetViewComponentViewInitializer(ViewComponentViewInitializer initializer);
+    void SetContentIslandComponentViewInitializer(ComponentIslandComponentViewInitializer initializer);
+    void SetCreateVisualHandler(CreateVisualDelegate impl);
   };
 
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/IReactViewComponentBuilder.idl

@@ -3,6 +3,7 @@
 
 import "ViewProps.idl";
 import "ComponentView.idl";
+import "IJSValueWriter.idl";
 
 #include "DocString.h"
 
@@ -34,6 +35,25 @@ namespace Microsoft.ReactNative
     LayoutDirection LayoutDirection;
   };
 
+  [experimental]
+  runtimeclass MountChildComponentViewArgs {
+    ComponentView Child { get; };
+    UInt32 Index { get; };
+  };
+
+  [experimental]
+  runtimeclass UnmountChildComponentViewArgs {
+    ComponentView Child { get; };
+    UInt32 Index { get; };
+  };
+
+  [experimental]
+  runtimeclass HandleCommandArgs {
+    String CommandName { get; };
+    IJSValueReader CommandArgs { get; };
+    Boolean Handled;
+  };
+
   [experimental]
   DOC_STRING("A delegate that creates a @IComponentProps object for an instance of @ViewProps. See @IReactViewComponentBuilder.SetCreateProps")
   delegate IComponentProps ViewPropsFactory(ViewProps props);
@@ -54,15 +74,39 @@ namespace Microsoft.ReactNative
   delegate Object InitialStateDataFactory(IComponentProps props);
 
   [experimental]
-  DOC_STRING("Provides a factory method to create an instance of a ComponentView. See @IReactViewComponentBuilder.SetCreateView")
-  delegate ComponentView ComponentViewFactory(CreateComponentViewArgs args);
+  DOC_STRING("Provides a method to initialize an instance of a ComponentView. See @IReactViewComponentBuilder.SetComponentViewInitializer")
+  delegate void ComponentViewInitializer(ComponentView view);
+
+  [experimental]
+  delegate void HandleCommandDelegate(ComponentView source, HandleCommandArgs args);
+
+  [experimental]
+  delegate void UpdateFinalizerDelegate(ComponentView source, ComponentViewUpdateMask updateMask);
+
+  [experimental]
+  delegate void UpdatePropsDelegate(ComponentView source, IComponentProps newProps, IComponentProps oldProps);
+
+  [experimental]
+  delegate void UpdateStateDelegate(ComponentView source, IComponentState newState);
+
+  [experimental]
+  delegate void MountChildComponentViewDelegate(ComponentView source, MountChildComponentViewArgs args);
+
+  [experimental]
+  delegate void UnmountChildComponentViewDelegate(ComponentView source, UnmountChildComponentViewArgs args);
+
+  [experimental]
+  runtimeclass EventEmitter {
+    void DispatchEvent(String eventName, JSValueArgWriter args);
+  };
+
+  [experimental]
+  delegate void UpdateEventEmitterDelegate(ComponentView source, EventEmitter eventEmitter);
 
   [webhosthidden]
   [experimental]
   interface IReactViewComponentBuilder
   {
-    void SetCreateComponentView(ComponentViewFactory impl);
-
     DOC_STRING("Create an implementation of your custom Props type that will be passed to your components @Composition.ICompositionViewComponent.UpdateProps method.")
     void SetCreateProps(ViewPropsFactory impl);
 
@@ -71,9 +115,24 @@ namespace Microsoft.ReactNative
     void SetInitialStateDataFactory(InitialStateDataFactory impl);
     void SetMeasureContentHandler(MeasureContentHandler impl);
     void SetLayoutHandler(LayoutHandler impl);
+
+    void SetComponentViewInitializer(ComponentViewInitializer initializer);
+    void SetCustomCommandHandler(HandleCommandDelegate impl);
+    void SetFinalizeUpdateHandler(UpdateFinalizerDelegate impl);
+    void SetUpdatePropsHandler(UpdatePropsDelegate impl);
+    void SetUpdateStateHandler(UpdateStateDelegate impl);
+    void SetUpdateEventEmitterHandler(UpdateEventEmitterDelegate impl);
+    void SetMountChildComponentViewHandler(MountChildComponentViewDelegate impl);
+    void SetUnmountChildComponentViewHandler(UnmountChildComponentViewDelegate impl);
   };
 
+  // [exclusiveto(ShadowNode)]
+  // [uuid(BF2A2A64-AB8B-47FC-BE69-E31DE6FC29A4)]
+  // interface IShadowNodeFactory
+  // {
+  // }
 
+  // [composable(IShadowNodeFactory, protected)]
   [webhosthidden]
   [experimental]
   unsealed runtimeclass ShadowNode
@@ -81,6 +140,7 @@ namespace Microsoft.ReactNative
     void EnsureUnsealed();
     Object Tag { get; set; };
     Object StateData{ get; set; };
+    EventEmitter EventEmitter { get; };
   };
 
   [webhosthidden]

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -142,7 +142,7 @@
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>winsqlite3.lib;ChakraRT.lib;dxguid.lib;dloadhelper.lib;OneCoreUap_apiset.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>winsqlite3.lib;ChakraRT.lib;dxguid.lib;dloadhelper.lib;OneCoreUap_apiset.lib;Dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <DelayLoadDLLs>
         api-ms-win-core-file-l1-2-0.dll;
         api-ms-win-core-windowserrorreporting-l1-1-0.dll;

package/Microsoft.ReactNative/Modules/LogBoxModule.cpp

@@ -19,6 +19,15 @@
 
 namespace Microsoft::ReactNative {
 
+LogBox::~LogBox() {
+#ifdef USE_FABRIC
+  if (m_hwnd) {
+    m_context.UIDispatcher().Post([hwnd = m_hwnd]() { DestroyWindow(hwnd); });
+    m_hwnd = nullptr;
+  }
+#endif
+}
+
 #ifdef USE_FABRIC
 constexpr PCWSTR c_logBoxWindowClassName = L"MS_REACTNATIVE_LOGBOX";
 constexpr auto CompHostProperty = L"CompHost";

package/Microsoft.ReactNative/Modules/LogBoxModule.h

@@ -14,6 +14,8 @@ REACT_MODULE(LogBox)
 struct LogBox : public std::enable_shared_from_this<LogBox> {
   using ModuleSpec = ReactNativeSpecs::LogBoxSpec;
 
+  ~LogBox();
+
   REACT_INIT(Initialize)
   void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 

package/Microsoft.ReactNative/Modules/SampleTurboModule.cpp

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "SampleTurboModule.h"
+
+namespace Microsoft::ReactNative {
+
+void SampleTurboModule::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  m_reactContext = reactContext;
+}
+
+ReactNativeSpecs::SampleTurboModuleSpec_Constants SampleTurboModule::GetConstants() noexcept {
+  ReactNativeSpecs::SampleTurboModuleSpec_Constants constants;
+  constants.const1 = true;
+  constants.const2 = 375;
+  constants.const3 = "something";
+  return constants;
+}
+
+void SampleTurboModule::voidFunc() noexcept {}
+
+bool SampleTurboModule::getBool(bool arg) noexcept {
+  return arg;
+}
+
+double SampleTurboModule::getEnum(double arg) noexcept {
+  return arg;
+}
+
+double SampleTurboModule::getNumber(double arg) noexcept {
+  return arg;
+}
+
+std::string SampleTurboModule::getString(std::string arg) noexcept {
+  return std::string(arg);
+}
+
+::React::JSValueArray SampleTurboModule::getArray(::React::JSValueArray &&arg) noexcept {
+  return arg.Copy();
+}
+
+::React::JSValue SampleTurboModule::getObject(::React::JSValue &&arg) noexcept {
+  assert(arg.Type() == ::React::JSValueType::Object);
+  return arg.Copy();
+}
+
+::React::JSValue SampleTurboModule::getUnsafeObject(::React::JSValue &&arg) noexcept {
+  assert(arg.Type() == ::React::JSValueType::Object);
+  return arg.Copy();
+}
+
+double SampleTurboModule::getRootTag(double arg) noexcept {
+  // TODO: Proper impl
+  return arg;
+}
+
+::React::JSValue SampleTurboModule::getValue(double x, std::string y, ::React::JSValue &&z) noexcept {
+  return ::React::JSValueObject{
+      {"x", x},
+      {"y", y},
+      {"z", z.Copy()},
+  };
+}
+
+void SampleTurboModule::getValueWithCallback(std::function<void(std::string)> const &callback) noexcept {
+  callback("value from callback!");
+}
+
+void SampleTurboModule::getValueWithPromise(bool error, ::React::ReactPromise<std::string> &&result) noexcept {
+  if (error) {
+    result.Reject("intentional promise rejection");
+  } else {
+    result.Resolve("result!");
+  }
+}
+
+void SampleTurboModule::voidFuncThrows() noexcept {
+  // TODO: Proper impl
+}
+
+::React::JSValue SampleTurboModule::getObjectThrows(::React::JSValue &&arg) noexcept {
+  // TODO: Proper impl
+  return nullptr;
+}
+
+void SampleTurboModule::promiseThrows(::React::ReactPromise<void> &&result) noexcept {
+  // TODO: Proper impl
+}
+
+void SampleTurboModule::voidFuncAssert() noexcept {
+  // TODO: Proper impl
+}
+
+::React::JSValue SampleTurboModule::getObjectAssert(::React::JSValue &&arg) noexcept {
+  // TODO: Proper impl
+  return nullptr;
+}
+
+void SampleTurboModule::promiseAssert(::React::ReactPromise<void> &&result) noexcept {
+  // TODO: Proper impl
+}
+
+} // namespace Microsoft::ReactNative