react-native-windows 0.68.1 → 0.69.0-preview.1

package/Microsoft.ReactNative/Views/TouchEventHandler.cpp

@@ -26,7 +26,10 @@
 #include <winrt/Windows.UI.Input.h>
 
 #ifdef USE_WINUI3
-#include <winrt/Microsoft.UI.Input.Experimental.h>
+#include <winrt/Microsoft.UI.Input.h>
+namespace input = winrt::Microsoft::UI::Input;
+#else
+namespace input = winrt::Windows::UI::Input;
 #endif
 
 namespace Microsoft::ReactNative {
@@ -46,7 +49,7 @@ TouchEventHandler::~TouchEventHandler() {
 }
 
 void TouchEventHandler::AddTouchHandlers(XamlView xamlView, XamlView rootView, bool handledEventsToo) {
-  auto uiElement(xamlView.as<xaml::UIElement>());
+  auto uiElement(xamlView.try_as<xaml::UIElement>());
   if (uiElement == nullptr) {
     assert(false);
     return;
@@ -118,7 +121,7 @@ void TouchEventHandler::OnPointerPressed(
 
   // If this was caused by the user pressing the "back" hardware button, fire that event instead
   if (args.GetCurrentPoint(sourceElement).Properties().PointerUpdateKind() ==
-      winrt::Windows::UI::Input::PointerUpdateKind::XButton1Pressed) {
+      input::PointerUpdateKind::XButton1Pressed) {
     args.Handled(DispatchBackEvent());
     return;
   }
@@ -127,16 +130,9 @@ void TouchEventHandler::OnPointerPressed(
     assert(!tagsForBranch.empty());
     const auto tag = tagsForBranch.front();
 
-    // Pointer pressing updates the enter/leave state
-    UpdatePointersInViews(args, sourceElement, std::move(tagsForBranch));
-
     size_t pointerIndex = AddReactPointer(args, tag, sourceElement);
 
-    // For now, when using the mouse we only want to send click events for the left button.
-    // Finger and pen taps will also set isLeftButton.
-    if (m_pointers[pointerIndex].isLeftButton) {
-      DispatchTouchEvent(eventType, pointerIndex);
-    }
+    DispatchTouchEvent(eventType, pointerIndex);
   }
 }
 
@@ -189,10 +185,11 @@ void TouchEventHandler::OnPointerMoved(
   if (optPointerIndex) {
     UpdateReactPointer(m_pointers[*optPointerIndex], args, sourceElement);
     DispatchTouchEvent(eventType, *optPointerIndex);
-  } else {
-    // Move with no buttons pressed
-    UpdatePointersInViews(args, sourceElement, std::move(tagsForBranch));
   }
+
+  // If we re-introduce onMouseMove to react-native-windows, we should add an
+  // argument to ensure we do not emit these events while the pointer is down.
+  UpdatePointersInViews(args, sourceElement, std::move(tagsForBranch));
 }
 
 void TouchEventHandler::OnPointerConcluded(TouchEventType eventType, const winrt::PointerRoutedEventArgs &args) {
@@ -213,23 +210,18 @@ void TouchEventHandler::OnPointerConcluded(TouchEventType eventType, const winrt
   if (PropagatePointerEventAndFindReactSourceBranch(reactArgs, &tagsForBranch, &sourceElement))
     UpdateReactPointer(m_pointers[*optPointerIndex], args, sourceElement);
 
-  if (m_pointers[*optPointerIndex].isLeftButton) {
-    // In case a PointerCaptureLost event should be treated as an "end" event,
-    // check the ReactPointerEventArgs Kind property before emitting the event.
-    const auto adjustedEventType = reactArgs.Kind() == winrt::Microsoft::ReactNative::PointerEventKind::End
-        ? TouchEventType::End
-        : TouchEventType::Cancel;
-    DispatchTouchEvent(adjustedEventType, *optPointerIndex);
-  }
+  // In case a PointerCaptureLost event should be treated as an "end" event,
+  // check the ReactPointerEventArgs Kind property before emitting the event.
+  const auto adjustedEventType = reactArgs.Kind() == winrt::Microsoft::ReactNative::PointerEventKind::End
+      ? TouchEventType::End
+      : TouchEventType::Cancel;
+  DispatchTouchEvent(adjustedEventType, *optPointerIndex);
 
   m_pointers.erase(cbegin(m_pointers) + *optPointerIndex);
   if (m_pointers.size() == 0)
     m_touchId = 0;
 
   m_xamlView.as<xaml::FrameworkElement>().ReleasePointerCapture(args.Pointer());
-
-  // Updates the enter/leave state when pointer was being tracked
-  UpdatePointersInViews(args, sourceElement, std::move(tagsForBranch));
 }
 
 size_t TouchEventHandler::AddReactPointer(
@@ -334,7 +326,7 @@ void TouchEventHandler::UpdatePointersInViews(
     } else {
       // newViews is empty when UpdatePointersInViews is called from outside
       // the root view, in this case use -1 for the JS event pointer target
-      const auto tag = !newViews.empty() ? newViews.front() : -1;
+      const auto tag = !newViews.empty() ? newViews.front() : InvalidTag;
       pointer = CreateReactPointer(args, tag, sourceElement);
     }
 
@@ -373,7 +365,21 @@ void TouchEventHandler::UpdatePointersInViews(
   }
 }
 
+// defines button payload, follows https://developer.mozilla.org/docs/Web/API/MouseEvent/button
+enum class MouseEventButtonKind { None = -1, Main = 0, Auxiliary = 1, Secondary = 2, Eraser = 5 };
+
 winrt::Microsoft::ReactNative::JSValue TouchEventHandler::GetPointerJson(const ReactPointer &pointer, int64_t target) {
+  MouseEventButtonKind button = MouseEventButtonKind::None;
+  if (pointer.isLeftButton) {
+    button = MouseEventButtonKind::Main;
+  } else if (pointer.isMiddleButton) {
+    button = MouseEventButtonKind::Auxiliary;
+  } else if (pointer.isRightButton || pointer.isBarrelButton) {
+    button = MouseEventButtonKind::Secondary;
+  } else if (pointer.isEraser) {
+    button = MouseEventButtonKind::Eraser;
+  }
+
   return winrt::Microsoft::ReactNative::JSValueObject{
       {"target", target},
       {"identifier", pointer.identifier},
@@ -395,6 +401,7 @@ winrt::Microsoft::ReactNative::JSValue TouchEventHandler::GetPointerJson(const R
       {"isEraser", pointer.isEraser},
       {"shiftKey", pointer.shiftKey},
       {"ctrlKey", pointer.ctrlKey},
+      {"button", static_cast<int>(button)},
       {"altKey", pointer.altKey}};
 }
 
@@ -414,9 +421,9 @@ facebook::react::SharedEventEmitter EventEmitterForElement(
   auto element = view->Element();
   while (auto parent = element.Parent()) {
     if (element = parent.try_as<xaml::FrameworkElement>()) {
-      auto boxedTag = element.Tag();
-      if (boxedTag) {
-        if (tag = winrt::unbox_value<facebook::react::Tag>(element.Tag()))
+      auto elementTag = GetTag(element);
+      if (elementTag != InvalidTag) {
+        if ((tag = static_cast<facebook::react::Tag>(elementTag)) != InvalidTag)
           return EventEmitterForElement(uimanager, tag);
       }
     }
@@ -438,6 +445,109 @@ facebook::react::Touch TouchEventHandler::TouchForPointer(const ReactPointer &po
   t.timestamp = static_cast<facebook::react::Float>(pointer.timestamp);
   return t;
 }
+
+winrt::IPropertyValue TestHit(
+    const winrt::Collections::IVectorView<xaml::Documents::Inline> &inlines,
+    const winrt::Point &pointerPos,
+    bool &isHit) {
+  winrt::IPropertyValue tag(nullptr);
+
+  for (const auto &el : inlines) {
+    if (const auto span = el.try_as<xaml::Documents::Span>()) {
+      auto resTag = TestHit(span.Inlines().GetView(), pointerPos, isHit);
+
+      if (resTag)
+        return resTag;
+
+      if (isHit) {
+        tag = el.GetValue(xaml::FrameworkElement::TagProperty()).try_as<winrt::IPropertyValue>();
+        if (tag) {
+          return tag;
+        }
+      }
+    } else if (const auto run = el.try_as<xaml::Documents::Run>()) {
+      const auto start = el.ContentStart();
+      const auto end = el.ContentEnd();
+
+      auto startRect = start.GetCharacterRect(xaml::Documents::LogicalDirection::Forward);
+      auto endRect = end.GetCharacterRect(xaml::Documents::LogicalDirection::Forward);
+
+      // Swap rectangles in RTL scenarios.
+      if (startRect.X > endRect.X) {
+        const auto tempRect = startRect;
+        startRect = endRect;
+        endRect = tempRect;
+      }
+
+      // Approximate the bounding rect (for now, don't account for text wrapping).
+      if ((startRect.X <= pointerPos.X) && (endRect.X + endRect.Width >= pointerPos.X) &&
+          (startRect.Y <= pointerPos.Y) && (endRect.Y + endRect.Height >= pointerPos.Y)) {
+        isHit = true;
+        return nullptr;
+      }
+    }
+  }
+
+  return tag;
+}
+
+bool TagFromOriginalSource(const winrt::PointerRoutedEventArgs &args, int64_t *pTag, xaml::UIElement *pSourceElement) {
+  assert(pTag != nullptr);
+  assert(pSourceElement != nullptr);
+
+  // Find the React element that triggered the input event
+  xaml::UIElement sourceElement = args.OriginalSource().try_as<xaml::UIElement>();
+  winrt::IPropertyValue tag(nullptr);
+
+  while (sourceElement) {
+    auto tagValue = sourceElement.ReadLocalValue(xaml::FrameworkElement::TagProperty());
+    if (tagValue != xaml::DependencyProperty::UnsetValue()) {
+      tag = tagValue.try_as<winrt::IPropertyValue>();
+      // If a TextBlock was the UIElement event source, perform a more accurate hit test,
+      // searching for the tag of the nested Run/Span XAML elements that the user actually clicked.
+      // This is to support nested <Text> elements in React.
+      // Nested React <Text> elements get translated into nested XAML <Span> elements,
+      // while the content of the <Text> becomes a list of XAML <Run> elements.
+      // However, we should report the Text element as the target, not the contexts of the text.
+      if (const auto textBlock = sourceElement.try_as<xaml::Controls::TextBlock>()) {
+        const auto pointerPos = args.GetCurrentPoint(textBlock).RawPosition();
+        const auto inlines = textBlock.Inlines().GetView();
+
+        bool isHit = false;
+        const auto finerTag = TestHit(inlines, pointerPos, isHit);
+        if (finerTag) {
+          tag = finerTag;
+        }
+      }
+
+      break;
+    }
+
+    sourceElement = winrt::VisualTreeHelper::GetParent(sourceElement).try_as<xaml::UIElement>();
+  }
+
+  if (tag == nullptr) {
+    // If the root view fails to be fully created, then the Tag property will
+    // never be set. This can happen,
+    //  for example, when the red box error box is shown.
+    return false;
+  }
+
+  *pTag = tag.GetInt64();
+  *pSourceElement = sourceElement;
+  return true;
+}
+
+bool TouchEventHandler::IsEndishEventType(TouchEventType eventType) noexcept {
+  switch (eventType) {
+    case TouchEventType::End:
+    case TouchEventType::Cancel:
+    case TouchEventType::CaptureLost:
+      return true;
+    default:
+      return false;
+  }
+}
 #endif
 
 void TouchEventHandler::DispatchTouchEvent(TouchEventType eventType, size_t pointerIndex) {
@@ -456,8 +566,13 @@ void TouchEventHandler::DispatchTouchEvent(TouchEventType eventType, size_t poin
 
     size_t index = 0;
     for (const auto &pointer : m_pointers) {
-      te.touches.insert(TouchForPointer(pointer));
-      if (pointerIndex == index++)
+      bool isChangedPointer = pointerIndex == index++;
+
+      if (!isChangedPointer || !IsEndishEventType(eventType)) {
+        te.touches.insert(TouchForPointer(pointer));
+      }
+
+      if (isChangedPointer)
         te.changedTouches.insert(TouchForPointer(pointer));
 
       auto emitter = std::static_pointer_cast<facebook::react::TouchEventEmitter>(
@@ -530,17 +645,16 @@ bool TouchEventHandler::DispatchBackEvent() {
   return true;
 }
 
-const char *TouchEventHandler::GetPointerDeviceTypeName(
-    winrt::Windows::Devices::Input::PointerDeviceType deviceType) noexcept {
+const char *TouchEventHandler::GetPointerDeviceTypeName(PointerDeviceType deviceType) noexcept {
   const char *deviceTypeName = "unknown";
   switch (deviceType) {
-    case winrt::Windows::Devices::Input::PointerDeviceType::Mouse:
+    case PointerDeviceType::Mouse:
       deviceTypeName = "mouse";
       break;
-    case winrt::Windows::Devices::Input::PointerDeviceType::Pen:
+    case PointerDeviceType::Pen:
       deviceTypeName = "pen";
       break;
-    case winrt::Windows::Devices::Input::PointerDeviceType::Touch:
+    case PointerDeviceType::Touch:
       deviceTypeName = "touch";
       break;
     default:
@@ -605,6 +719,18 @@ bool TouchEventHandler::PropagatePointerEventAndFindReactSourceBranch(
   assert(pTagsForBranch != nullptr);
   assert(pSourceElement != nullptr);
 
+#ifdef USE_FABRIC
+  if (m_fabric) {
+    int64_t tag;
+    if (TagFromOriginalSource(args.Args(), &tag, pSourceElement)) {
+      std::vector<int64_t> tagsForBranch;
+      tagsForBranch.push_back(tag);
+      *pTagsForBranch = std::move(tagsForBranch);
+    }
+    return pSourceElement != nullptr;
+  }
+#endif
+
   if (const auto uiManager = GetNativeUIManager(*m_context).lock()) {
     xaml::UIElement sourceElement = args.Args().OriginalSource().try_as<xaml::UIElement>();
     ShadowNodeBase *node = nullptr;
@@ -691,7 +817,7 @@ std::vector<int64_t> GetTagsForBranch(INativeUIManagerHost *host, int64_t tag, i
   std::vector<int64_t> tags;
 
   auto *shadowNode = host->FindShadowNodeForTag(tag);
-  while (shadowNode != nullptr && tag != -1) {
+  while (shadowNode != nullptr && tag != InvalidTag) {
     if (tag == rootTag) {
       break;
     }

package/Microsoft.ReactNative/Views/TouchEventHandler.h

@@ -50,6 +50,12 @@ class TouchEventHandler {
   winrt::IInspectable m_exitedHandler;
   winrt::IInspectable m_movedHandler;
 
+#ifdef USE_WINUI3
+  using PointerDeviceType = winrt::Microsoft::UI::Input::PointerDeviceType;
+#else
+  using PointerDeviceType = winrt::Windows::Devices::Input::PointerDeviceType;
+#endif
+
   struct ReactPointer {
     int64_t target = 0;
     int64_t identifier = 0;
@@ -57,8 +63,7 @@ class TouchEventHandler {
     uint64_t timestamp = 0;
     winrt::Point positionRoot = {0, 0};
     winrt::Point positionView = {0, 0};
-    winrt::Windows::Devices::Input::PointerDeviceType deviceType{
-        winrt::Windows::Devices::Input::PointerDeviceType::Mouse};
+    PointerDeviceType deviceType{PointerDeviceType::Mouse};
     float pressure = 0;
     bool isLeftButton = false;
     bool isRightButton = false;
@@ -80,14 +85,16 @@ class TouchEventHandler {
       xaml::UIElement sourceElement,
       std::vector<int64_t> &&newViews);
 
+  enum class TouchEventType { Start = 0, End, Move, Cancel, CaptureLost, PointerEntered, PointerExited, PointerMove };
 #ifdef USE_FABRIC
   facebook::react::Touch TouchForPointer(const ReactPointer &pointer) noexcept;
+  static bool IsEndishEventType(TouchEventType eventType) noexcept;
 #endif
-  enum class TouchEventType { Start = 0, End, Move, Cancel, CaptureLost, PointerEntered, PointerExited, PointerMove };
   void OnPointerConcluded(TouchEventType eventType, const winrt::PointerRoutedEventArgs &args);
   void DispatchTouchEvent(TouchEventType eventType, size_t pointerIndex);
   bool DispatchBackEvent();
-  const char *GetPointerDeviceTypeName(winrt::Windows::Devices::Input::PointerDeviceType deviceType) noexcept;
+  const char *GetPointerDeviceTypeName(PointerDeviceType deviceType) noexcept;
+
   winrt::Microsoft::ReactNative::PointerEventKind GetPointerEventKind(TouchEventType eventType) noexcept;
   const wchar_t *GetTouchEventTypeName(TouchEventType eventType) noexcept;
 

package/Microsoft.ReactNative/Views/ViewPanel.cpp

@@ -47,14 +47,6 @@ winrt::AutomationPeer ViewPanel::OnCreateAutomationPeer() {
     panel->m_propertiesChanged = true;
 }
 
-/*static*/ void ViewPanel::PositionPropertyChanged(
-    xaml::DependencyObject sender,
-    xaml::DependencyPropertyChangedEventArgs e) {
-  auto element{sender.as<xaml::UIElement>()};
-  if (element != nullptr)
-    InvalidateForArrange(element);
-}
-
 /*static*/ xaml::DependencyProperty ViewPanel::ViewBackgroundProperty() {
   static xaml::DependencyProperty s_viewBackgroundProperty = xaml::DependencyProperty::Register(
       L"ViewBackground",
@@ -96,23 +88,11 @@ winrt::AutomationPeer ViewPanel::OnCreateAutomationPeer() {
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::TopProperty() {
-  static xaml::DependencyProperty s_topProperty = xaml::DependencyProperty::RegisterAttached(
-      L"Top",
-      winrt::xaml_typename<double>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(winrt::box_value((double)0), ViewPanel::PositionPropertyChanged));
-
-  return s_topProperty;
+  return xaml::Controls::Canvas::TopProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::LeftProperty() {
-  static xaml::DependencyProperty s_LeftProperty = xaml::DependencyProperty::RegisterAttached(
-      L"Left",
-      winrt::xaml_typename<double>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(winrt::box_value((double)0), ViewPanel::PositionPropertyChanged));
-
-  return s_LeftProperty;
+  return xaml::Controls::Canvas::LeftProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::ClipChildrenProperty() {
@@ -135,7 +115,7 @@ winrt::AutomationPeer ViewPanel::OnCreateAutomationPeer() {
   InvalidateForArrange(element);
 }
 
-void ViewPanel::InvalidateForArrange(xaml::UIElement element) {
+void ViewPanel::InvalidateForArrange(const xaml::DependencyObject &element) {
   // If the element's position has changed, we must invalidate the parent for arrange,
   // as it's the parent's responsibility to arrange its children.
   if (auto parent = VisualTreeHelper::GetParent(element)) {

package/Microsoft.ReactNative/Views/ViewPanel.h

@@ -77,13 +77,13 @@ struct ViewPanel : ViewPanelT<ViewPanel> {
     return winrt::unbox_value<double>(element.GetValue(LeftProperty()));
   }
 
+  static void InvalidateForArrange(const xaml::DependencyObject &element);
+
  private:
   void Remove(xaml::UIElement element) const;
 
   void UpdateClip(winrt::Windows::Foundation::Size &finalSize);
 
-  static void InvalidateForArrange(xaml::UIElement element);
-
  private:
   bool m_propertiesChanged{false};
 
@@ -93,7 +93,6 @@ struct ViewPanel : ViewPanelT<ViewPanel> {
 
  private:
   static void VisualPropertyChanged(xaml::DependencyObject sender, xaml::DependencyPropertyChangedEventArgs e);
-  static void PositionPropertyChanged(xaml::DependencyObject sender, xaml::DependencyPropertyChangedEventArgs e);
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Views/ViewViewManager.cpp

@@ -7,6 +7,7 @@
 
 #include "ViewControl.h"
 
+#include <UI.Xaml.Automation.Peers.h>
 #include "DynamicAutomationProperties.h"
 
 #include <JSValueWriter.h>
@@ -127,6 +128,14 @@ class ViewShadowNode : public ShadowNodeBase {
       GetControl().IsTabStop(m_isFocusable);
   }
 
+  bool IsAccessible() const {
+    return m_isAccessible;
+  }
+
+  void IsAccessible(bool isAccessible) {
+    m_isAccessible = isAccessible;
+  }
+
   bool IsHitTestBrushRequired() const {
     return IsRegisteredForMouseEvents();
   }
@@ -251,6 +260,7 @@ class ViewShadowNode : public ShadowNodeBase {
   bool m_enableFocusRing = true;
   bool m_onClick = false;
   bool m_isFocusable = false;
+  bool m_isAccessible = false;
   int32_t m_tabIndex = std::numeric_limits<std::int32_t>::max();
 
   xaml::Controls::ContentControl::GotFocus_revoker m_contentControlGotFocusRevoker{};
@@ -420,6 +430,11 @@ bool ViewViewManager::UpdateProperty(
         pViewShadowNode->TabIndex(std::numeric_limits<std::int32_t>::max());
       }
     } else {
+      if (propertyName == "accessible") {
+        if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
+          pViewShadowNode->IsAccessible(propertyValue.AsBoolean());
+        }
+      }
       ret = Super::UpdateProperty(nodeToUpdate, propertyName, propertyValue);
     }
   }
@@ -563,6 +578,12 @@ void ViewViewManager::TryUpdateView(
 
   if (useControl)
     pViewShadowNode->GetControl().Content(visualRoot);
+
+  if (useControl && pViewShadowNode->IsAccessible() != pViewShadowNode->IsFocusable()) {
+    pViewShadowNode->GetControl().IsTabStop(false);
+    xaml::Automation::AutomationProperties::SetAccessibilityView(
+        pViewShadowNode->GetControl(), xaml::Automation::Peers::AccessibilityView::Raw);
+  }
 }
 
 void ViewViewManager::SetLayoutProps(

package/Microsoft.ReactNative/XamlUIService.cpp

@@ -37,7 +37,7 @@ void XamlUIService::DispatchEvent(
     JSValueArgWriter const &eventDataArgWriter) noexcept {
   auto paramsWriter = winrt::make_self<DynamicWriter>();
   paramsWriter->WriteArrayBegin();
-  paramsWriter->WriteInt64(unbox_value<int64_t>(view.Tag()));
+  paramsWriter->WriteInt64(::Microsoft::ReactNative::GetTag(view));
   paramsWriter->WriteString(eventName);
   if (eventDataArgWriter) {
     eventDataArgWriter(*paramsWriter);

package/Microsoft.ReactNative/XamlView.h

@@ -8,14 +8,19 @@
 namespace Microsoft::ReactNative {
 
 using XamlView = xaml::DependencyObject;
+constexpr int64_t InvalidTag = -1;
 
 inline int64_t GetTag(XamlView view) {
   auto tagValue = view.ReadLocalValue(xaml::FrameworkElement::TagProperty());
   if (tagValue != xaml::DependencyProperty::UnsetValue()) {
-    return tagValue.as<winrt::IPropertyValue>().GetInt64();
-  } else {
-    return -1;
+    if (auto tagValueInt = tagValue.try_as<winrt::IPropertyValue>()) {
+      if (tagValueInt.Type() == winrt::PropertyType::Int64) {
+        return tagValueInt.GetInt64();
+      }
+    }
   }
+
+  return InvalidTag;
 }
 
 inline void SetTag(XamlView view, int64_t tag) {

package/Microsoft.ReactNative.Cxx/CppWinRTIncludes.h

@@ -17,13 +17,12 @@ namespace xaml = winrt::Windows::UI::Xaml;
 namespace comp = winrt::Windows::UI::Composition;
 namespace ui = winrt::Windows::UI;
 namespace winrt {
-namespace system = winrt::Windows::System;
-using ColorHelper = winrt::Windows::UI::ColorHelper;
+namespace dispatching = winrt::Windows::System;
 using Colors = winrt::Windows::UI::Colors;
 } // namespace winrt
 #else
 
-#include <winrt/Microsoft.System.h>
+#include <winrt/Microsoft.UI.Dispatching.h>
 #include <winrt/Microsoft.UI.Xaml.h>
 
 #define XAML_CPPWINRT_NAMESPACE winrt::Microsoft::UI::Xaml
@@ -31,8 +30,7 @@ namespace xaml = winrt::Microsoft::UI::Xaml;
 namespace comp = winrt::Microsoft::UI::Composition;
 namespace ui = winrt::Microsoft::UI;
 namespace winrt {
-namespace system = winrt::Microsoft::System;
-using ColorHelper = winrt::Microsoft::UI::ColorHelper;
+namespace dispatching = winrt::Microsoft::UI::Dispatching;
 using Colors = winrt::Microsoft::UI::Colors;
 } // namespace winrt
 

package/Microsoft.ReactNative.Cxx/DesktopWindowBridge.h

@@ -92,7 +92,7 @@ __declspec(selectany) std::unordered_map<std::wstring, IndirectLibrary> indirect
 } // namespace details
 
 template <typename TFn, typename... TArgs>
-auto CallIndirect(const wchar_t *dllName, const char *fnName, TArgs &&... args) noexcept {
+auto CallIndirect(const wchar_t *dllName, const char *fnName, TArgs &&...args) noexcept {
   if (details::indirectLibraries.count(dllName) == 0) {
     details::indirectLibraries.emplace(dllName, WINRT_IMPL_LoadLibraryW(dllName));
   }

package/Microsoft.ReactNative.Cxx/JSI/JsiAbiApi.cpp

@@ -306,6 +306,15 @@ PropNameID JsiAbiRuntime::createPropNameIDFromString(const String &str) try {
   throw;
 }
 
+PropNameID JsiAbiRuntime::createPropNameIDFromSymbol(const Symbol &sym) {
+  // TODO: Support for symbols through the native API in JSC is very limited.
+  // While we could construct a PropNameID here, we would not be able to get a
+  // symbol property through the C++ API.
+  UNREFERENCED_PARAMETER(sym);
+  RethrowJsiError();
+  throw;
+}
+
 std::string JsiAbiRuntime::utf8(const PropNameID &propertyId) try {
   std::string dataResult;
   m_runtime.PropertyIdToUtf8(AsJsiPropertyIdRef(propertyId), [&dataResult](array_view<uint8_t const> utf8) {
@@ -994,7 +1003,7 @@ size_t JsiAbiRuntime::ValueRefArray::Size() const noexcept {
 //===========================================================================
 
 JsiAbiRuntime::PropNameIDRef::PropNameIDRef(JsiPropertyIdRef const &data) noexcept
-    : m_propertyId{make<PropNameID>(new (std::addressof(m_pointerStore)) DataPointerValue(data.Data))} {}
+    : m_propertyId{make<PropNameID>(new(std::addressof(m_pointerStore)) DataPointerValue(data.Data))} {}
 
 JsiAbiRuntime::PropNameIDRef::~PropNameIDRef() noexcept {}
 
@@ -1004,4 +1013,4 @@ JsiAbiRuntime::PropNameIDRef::operator facebook::jsi::PropNameID const &() const
 
 } // namespace winrt::Microsoft::ReactNative
 
-#pragma warning(pop)
+#pragma warning(pop)

package/Microsoft.ReactNative.Cxx/JSI/JsiAbiApi.h

@@ -99,6 +99,7 @@ struct JsiAbiRuntime : facebook::jsi::Runtime {
   facebook::jsi::PropNameID createPropNameIDFromAscii(const char *str, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromUtf8(const uint8_t *utf8, size_t length) override;
   facebook::jsi::PropNameID createPropNameIDFromString(const facebook::jsi::String &str) override;
+  facebook::jsi::PropNameID createPropNameIDFromSymbol(const facebook::jsi::Symbol &sym);
   std::string utf8(const facebook::jsi::PropNameID &propertyNameId) override;
   bool compare(const facebook::jsi::PropNameID &left, const facebook::jsi::PropNameID &right) override;