react-native-windows 0.70.9 → 0.71.0-preview.2

package/Microsoft.ReactNative/Utils/ImageUtils.cpp

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "ImageUtils.h"
+
+#include <Shared/cdebug.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Web.Http.Headers.h>
+#include <winrt/Windows.Web.Http.h>
+
+namespace winrt {
+using namespace Windows::Foundation;
+using namespace Windows::Storage::Streams;
+using namespace Windows::Web::Http;
+} // namespace winrt
+
+namespace Microsoft::ReactNative {
+
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
+  try {
+    co_await winrt::resume_background();
+
+    auto httpMethod{
+        source.method.empty() ? winrt::HttpMethod::Get() : winrt::HttpMethod{winrt::to_hstring(source.method)}};
+
+    winrt::Uri uri{winrt::to_hstring(source.uri)};
+    winrt::HttpRequestMessage request{httpMethod, uri};
+
+    if (!source.headers.empty()) {
+      for (auto &header : source.headers) {
+        if (_stricmp(header.first.c_str(), "authorization") == 0) {
+          request.Headers().TryAppendWithoutValidation(
+              winrt::to_hstring(header.first), winrt::to_hstring(header.second));
+        } else {
+          request.Headers().Append(winrt::to_hstring(header.first), winrt::to_hstring(header.second));
+        }
+      }
+    }
+
+    winrt::HttpClient httpClient;
+    winrt::HttpResponseMessage response{co_await httpClient.SendRequestAsync(request)};
+
+    if (response && response.StatusCode() == winrt::HttpStatusCode::Ok) {
+      winrt::IInputStream inputStream{co_await response.Content().ReadAsInputStreamAsync()};
+      winrt::InMemoryRandomAccessStream memoryStream;
+      co_await winrt::RandomAccessStream::CopyAsync(inputStream, memoryStream);
+      memoryStream.Seek(0);
+
+      co_return memoryStream;
+    }
+  } catch (winrt::hresult_error const &e) {
+    DEBUG_HRESULT_ERROR(e);
+  }
+
+  co_return nullptr;
+}
+
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageInlineDataAsync(ReactImageSource source) {
+  size_t start = source.uri.find(',');
+  if (start == std::string::npos || start + 1 > source.uri.length())
+    co_return nullptr;
+
+  try {
+    co_await winrt::resume_background();
+
+    std::string_view base64String(source.uri.c_str() + start + 1, source.uri.length() - start - 1);
+    auto buffer = winrt::Windows::Security::Cryptography::CryptographicBuffer::DecodeFromBase64String(
+        winrt::to_hstring(base64String));
+
+    winrt::InMemoryRandomAccessStream memoryStream;
+    co_await memoryStream.WriteAsync(buffer);
+    memoryStream.Seek(0);
+
+    co_return memoryStream;
+  } catch (winrt::hresult_error const &) {
+    // Base64 decode failed
+  }
+
+  co_return nullptr;
+}
+
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageMemoryStreamAsync(ReactImageSource source) {
+  switch (source.sourceType) {
+    case ImageSourceType::Download:
+      co_return co_await GetImageStreamAsync(source);
+    case ImageSourceType::InlineData:
+      co_return co_await GetImageInlineDataAsync(source);
+    default: // ImageSourceType::Uri
+      co_return nullptr;
+  }
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/ImageUtils.h

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+#include <winrt/Windows.Storage.Streams.h>
+#include <string>
+
+namespace Microsoft::ReactNative {
+
+enum class ImageSourceType { Uri = 0, Download = 1, InlineData = 2 };
+enum class ImageSourceFormat { Bitmap = 0, Svg = 1 };
+
+struct ReactImageSource {
+  std::string uri;
+  std::string method;
+  std::string bundleRootPath;
+  std::vector<std::pair<std::string, std::string>> headers;
+  double width = 0;
+  double height = 0;
+  double scale = 1.0;
+  bool packagerAsset = false;
+  ImageSourceType sourceType = ImageSourceType::Uri;
+  ImageSourceFormat sourceFormat = ImageSourceFormat::Bitmap;
+};
+
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
+GetImageMemoryStreamAsync(ReactImageSource source);
+
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> GetImageStreamAsync(
+    ReactImageSource source);
+
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
+GetImageInlineDataAsync(ReactImageSource source);
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Utils/LocalBundleReader.cpp

@@ -76,14 +76,15 @@ std::future<std::string> LocalBundleReader::LoadBundleAsync(const std::string &b
   auto fileBuffer{co_await winrt::Windows::Storage::FileIO::ReadBufferAsync(file)};
   auto dataReader{winrt::Windows::Storage::Streams::DataReader::FromBuffer(fileBuffer)};
 
-  std::string script(fileBuffer.Length() + 1, '\0');
+  // No need to use length + 1, STL guarantees that string storage is null-terminated.
+  std::string script(fileBuffer.Length(), '\0');
 
   // Construct the array_view to slice into the first fileBuffer.Length bytes.
   // DataReader.ReadBytes will read as many bytes as are present in the
   // array_view. The backing string has fileBuffer.Length() + 1 bytes, without
   // an explicit end it will read 1 byte to many and throw.
   dataReader.ReadBytes(winrt::array_view<uint8_t>{
-      reinterpret_cast<uint8_t *>(&script[0]), reinterpret_cast<uint8_t *>(&script[script.length() - 1])});
+      reinterpret_cast<uint8_t *>(&script[0]), reinterpret_cast<uint8_t *>(&script[script.length()])});
   dataReader.Close();
 
   co_return script;

package/Microsoft.ReactNative/Utils/PropertyUtils.h

@@ -20,6 +20,10 @@ static double DefaultOrOverride(double defaultValue, double x) {
   return x != c_UndefinedEdge ? x : defaultValue;
 };
 
+static double DefaultOrOverrideWithClamp(double defaultValue, double x, double clamp) {
+  return std::min(DefaultOrOverride(defaultValue, x), clamp);
+};
+
 static const std::unordered_map<std::string, ShadowEdges> edgeTypeMap = {
     {"borderLeftWidth", ShadowEdges::Left},
     {"borderTopWidth", ShadowEdges::Top},
@@ -56,7 +60,9 @@ inline xaml::Thickness GetThickness(double thicknesses[(int)ShadowEdges::CountEd
   return thickness;
 }
 
-inline xaml::CornerRadius GetCornerRadius(double cornerRadii[(int)ShadowCorners::CountCorners]) {
+inline xaml::CornerRadius GetCornerRadius(
+    double cornerRadii[(int)ShadowCorners::CountCorners],
+    double maxCornerRadius) {
   xaml::CornerRadius cornerRadius;
   const double defaultRadius = std::max<double>(0, cornerRadii[(int)ShadowCorners::AllCorners]);
   double topStartRadius =
@@ -68,10 +74,15 @@ inline xaml::CornerRadius GetCornerRadius(double cornerRadii[(int)ShadowCorners:
   double bottomEndRadius =
       DefaultOrOverride(cornerRadii[(int)ShadowCorners::BottomRight], cornerRadii[(int)ShadowCorners::BottomEnd]);
 
-  cornerRadius.TopLeft = DefaultOrOverride(defaultRadius, topStartRadius);
-  cornerRadius.TopRight = DefaultOrOverride(defaultRadius, topEndRadius);
-  cornerRadius.BottomLeft = DefaultOrOverride(defaultRadius, bottomStartRadius);
-  cornerRadius.BottomRight = DefaultOrOverride(defaultRadius, bottomEndRadius);
+  // These values are clamped to 50% of the minimum of width or height
+  // dimension for cross-platform consistency with iOS, Android, and Web. We
+  // should revisit this clamping behavior if RN ever supports percentage
+  // values for the borderRadius prop as the default XAML behavior is
+  // consistent with Web behavior in this case.
+  cornerRadius.TopLeft = DefaultOrOverrideWithClamp(defaultRadius, topStartRadius, maxCornerRadius);
+  cornerRadius.TopRight = DefaultOrOverrideWithClamp(defaultRadius, topEndRadius, maxCornerRadius);
+  cornerRadius.BottomLeft = DefaultOrOverrideWithClamp(defaultRadius, bottomStartRadius, maxCornerRadius);
+  cornerRadius.BottomRight = DefaultOrOverrideWithClamp(defaultRadius, bottomEndRadius, maxCornerRadius);
 
   return cornerRadius;
 }
@@ -128,11 +139,22 @@ inline void UpdateCornerRadiusValueOnNode(
 }
 
 template <class T>
-void UpdateCornerRadiusOnElement(ShadowNodeBase *node, const T &element) {
-  xaml::CornerRadius cornerRadius = GetCornerRadius(node->m_cornerRadius);
+void UpdateCornerRadiusOnElement(ShadowNodeBase *node, const T &element, double maxCornerRadius) {
+  xaml::CornerRadius cornerRadius = GetCornerRadius(node->m_cornerRadius, maxCornerRadius);
   element.CornerRadius(cornerRadius);
 }
 
+template <class T>
+void UpdateCornerRadiusOnElement(ShadowNodeBase *node, const T &element) {
+  auto maxCornerRadius = std::numeric_limits<double>::max();
+  if (element.ReadLocalValue(xaml::FrameworkElement::WidthProperty()) != xaml::DependencyProperty::UnsetValue() &&
+      element.ReadLocalValue(xaml::FrameworkElement::HeightProperty()) != xaml::DependencyProperty::UnsetValue()) {
+    // Clamp CornerRadius to 50% of the minimum dimension between width and height.
+    maxCornerRadius = std::min(element.Width(), element.Height()) / 2;
+  }
+  UpdateCornerRadiusOnElement(node, element, maxCornerRadius);
+}
+
 template <class T>
 bool TryUpdateForeground(
     const T &element,
@@ -534,9 +556,9 @@ inline bool TryUpdateMouseEvents(
     const std::string &propertyName,
     const winrt::Microsoft::ReactNative::JSValue &propertyValue) {
   if (propertyName == "onMouseEnter")
-    node->m_onMouseEnterRegistered = !propertyValue.IsNull() && propertyValue.AsBoolean();
+    node->m_onMouseEnterRegistered = propertyValue.AsBoolean();
   else if (propertyName == "onMouseLeave")
-    node->m_onMouseLeaveRegistered = !propertyValue.IsNull() && propertyValue.AsBoolean();
+    node->m_onMouseLeaveRegistered = propertyValue.AsBoolean();
   else
     return false;
 

package/Microsoft.ReactNative/Views/ControlViewManager.cpp

@@ -105,13 +105,32 @@ bool ControlViewManager::UpdateProperty(
   return ret;
 }
 
+void ControlViewManager::SetLayoutProps(
+    ShadowNodeBase &nodeToUpdate,
+    const XamlView &viewToUpdate,
+    float left,
+    float top,
+    float width,
+    float height) {
+  Super::SetLayoutProps(nodeToUpdate, viewToUpdate, left, top, width, height);
+  if (viewToUpdate.try_as<xaml::Controls::IControl7>() &&
+      viewToUpdate.ReadLocalValue(xaml::Controls::Control::CornerRadiusProperty()) !=
+          xaml::DependencyProperty::UnsetValue()) {
+    const auto maxCornerRadius = std::min(width, height) / 2;
+    UpdateCornerRadiusOnElement(&nodeToUpdate, viewToUpdate.as<xaml::Controls::Control>(), maxCornerRadius);
+  }
+}
+
 void ControlViewManager::OnPropertiesUpdated(ShadowNodeBase *node) {
   auto control(node->GetView().as<xaml::Controls::Control>());
 
+  // If developer specifies either the accessible and focusable prop to be false
+  // remove accessibility and keyboard focus for component.
   if (IsAccessible() != IsFocusable()) {
     control.IsTabStop(false);
     xaml::Automation::AutomationProperties::SetAccessibilityView(
         control, xaml::Automation::Peers::AccessibilityView::Raw);
+    control.IsEnabled(false);
   }
 }
 

package/Microsoft.ReactNative/Views/ControlViewManager.h

@@ -21,6 +21,13 @@ class REACTWINDOWS_EXPORT ControlViewManager : public FrameworkElementViewManage
       const std::string &propertyName,
       const winrt::Microsoft::ReactNative::JSValue &propertyValue) override;
   void TransferProperties(const XamlView &oldView, const XamlView &newView) override;
+  void SetLayoutProps(
+      ShadowNodeBase &nodeToUpdate,
+      const XamlView &viewToUpdate,
+      float left,
+      float top,
+      float width,
+      float height) override;
 
  protected:
   void OnViewCreated(XamlView view) override;

package/Microsoft.ReactNative/Views/FlyoutViewManager.cpp

@@ -179,8 +179,7 @@ void FlyoutShadowNode::createView(const winrt::Microsoft::ReactNative::JSValueOb
   if (m_isFlyoutShowOptionsSupported)
     m_showOptions = winrt::FlyoutShowOptions();
 
-  m_touchEventHanadler = std::make_unique<TouchEventHandler>(
-      GetViewManager()->GetReactContext(), false /*Flyout not supported in fabric currently*/);
+  m_touchEventHanadler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext());
   m_previewKeyboardEventHandlerOnRoot =
       std::make_unique<PreviewKeyboardEventHandlerOnRoot>(GetViewManager()->GetReactContext());
 
@@ -405,9 +404,14 @@ winrt::Flyout FlyoutShadowNode::GetFlyout() {
 void FlyoutShadowNode::OnShowFlyout() {
   AdjustDefaultFlyoutStyle(50000, 50000);
   if (m_isFlyoutShowOptionsSupported) {
-    if (!m_targetElement && m_targetTag > 0) {
+    if (!m_flyout.XamlRoot()) {
+      LogErrorAndClose("The target view window was closed before flyout could be shown.");
+    } else if (!m_targetElement && m_targetTag > 0) {
       LogErrorAndClose("The target view unmounted before flyout could be shown.");
-    } else if (m_targetElement && m_flyout.XamlRoot() != m_targetElement.XamlRoot()) {
+    } else if (
+        m_targetElement &&
+        (m_flyout.XamlRoot() != m_targetElement.XamlRoot() ||
+         m_flyout.XamlRoot() != React::XamlUIService::GetXamlRoot(GetViewManager()->GetReactContext().Properties()))) {
       LogErrorAndClose("The target view window lost focus before flyout could be shown.");
     } else {
       m_flyout.ShowAt(m_targetElement, m_showOptions);

package/Microsoft.ReactNative/Views/ICompositionRootView.h

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/Composition/CompositionHelpers.h>
+#include <IReactRootView.h>
+#include <React.h>
+#include <folly/dynamic.h>
+#include <winrt/Windows.UI.Composition.h>
+
+namespace Microsoft::ReactNative {
+
+struct ICompositionRootView : public facebook::react::IReactRootView {
+  virtual winrt::Microsoft::ReactNative::Composition::IVisual GetVisual() const noexcept = 0;
+  virtual double ScaleFactor() noexcept = 0;
+};
+
+} // namespace Microsoft::ReactNative

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

@@ -189,6 +189,20 @@ void ImageViewManager::setSource(winrt::Grid grid, const winrt::Microsoft::React
   reactImage->Source(sources[0]);
 }
 
+void ImageViewManager::SetLayoutProps(
+    ShadowNodeBase &nodeToUpdate,
+    const XamlView &viewToUpdate,
+    float left,
+    float top,
+    float width,
+    float height) {
+  Super::SetLayoutProps(nodeToUpdate, viewToUpdate, left, top, width, height);
+  if (viewToUpdate.ReadLocalValue(winrt::Grid::CornerRadiusProperty()) != xaml::DependencyProperty::UnsetValue()) {
+    const auto maxCornerRadius = std::min(width, height) / 2;
+    UpdateCornerRadiusOnElement(&nodeToUpdate, viewToUpdate.as<winrt::Grid>(), maxCornerRadius);
+  }
+}
+
 void ImageViewManager::GetExportedCustomDirectEventTypeConstants(
     const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const {
   Super::GetExportedCustomDirectEventTypeConstants(writer);

package/Microsoft.ReactNative/Views/Image/ImageViewManager.h

@@ -19,6 +19,13 @@ class ImageViewManager : public FrameworkElementViewManager {
   void GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
   ShadowNode *createShadow() const override;
   void EmitImageEvent(xaml::Controls::Grid grid, const char *eventName, ReactImageSource &source);
+  void SetLayoutProps(
+      ShadowNodeBase &nodeToUpdate,
+      const XamlView &viewToUpdate,
+      float left,
+      float top,
+      float width,
+      float height) override;
 
  protected:
   bool UpdateProperty(

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

@@ -171,16 +171,6 @@ void ReactImage::Source(ReactImageSource source) {
   }
 }
 
-winrt::IAsyncOperation<winrt::IRandomAccessStream> ReactImage::GetImageMemoryStreamAsync(ReactImageSource source) {
-  switch (source.sourceType) {
-    case ImageSourceType::Download:
-      co_return co_await GetImageStreamAsync(source);
-    case ImageSourceType::InlineData:
-      co_return co_await GetImageInlineDataAsync(source);
-    default: // ImageSourceType::Uri
-      co_return nullptr;
-  }
-}
 template <typename TImage>
 std::wstring GetUriFromImage(const TImage &image) {
   return image.UriSource() ? image.UriSource().ToString().c_str() : L"<no Uri available>";
@@ -228,14 +218,16 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   auto weak_this{get_weak()};
 
   try {
-    memoryStream = co_await GetImageMemoryStreamAsync(source);
+    if (fromStream) {
+      memoryStream = co_await GetImageMemoryStreamAsync(source);
 
-    // Fire failed load event if we're not loading from URI and the memory stream is null.
-    if (fromStream && !memoryStream) {
-      if (auto strong_this{weak_this.get()}) {
-        strong_this->m_onLoadEndEvent(*strong_this, false);
+      // Fire failed load event if we're not loading from URI and the memory stream is null.
+      if (!memoryStream) {
+        if (auto strong_this{weak_this.get()}) {
+          strong_this->m_onLoadEndEvent(*strong_this, false);
+        }
+        co_return;
       }
-      co_return;
     }
   } catch (winrt::hresult_error const &) {
     const auto strong_this{weak_this.get()};
@@ -442,64 +434,4 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   }
 }
 
-winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
-  try {
-    co_await winrt::resume_background();
-
-    auto httpMethod{source.method.empty() ? winrt::HttpMethod::Get() : winrt::HttpMethod{Utf8ToUtf16(source.method)}};
-
-    winrt::Uri uri{Utf8ToUtf16(source.uri)};
-    winrt::HttpRequestMessage request{httpMethod, uri};
-
-    if (!source.headers.empty()) {
-      for (auto &header : source.headers) {
-        if (_stricmp(header.first.c_str(), "authorization") == 0) {
-          request.Headers().TryAppendWithoutValidation(Utf8ToUtf16(header.first), Utf8ToUtf16(header.second));
-        } else {
-          request.Headers().Append(Utf8ToUtf16(header.first), Utf8ToUtf16(header.second));
-        }
-      }
-    }
-
-    winrt::HttpClient httpClient;
-    winrt::HttpResponseMessage response{co_await httpClient.SendRequestAsync(request)};
-
-    if (response && response.StatusCode() == winrt::HttpStatusCode::Ok) {
-      winrt::IInputStream inputStream{co_await response.Content().ReadAsInputStreamAsync()};
-      winrt::InMemoryRandomAccessStream memoryStream;
-      co_await winrt::RandomAccessStream::CopyAsync(inputStream, memoryStream);
-      memoryStream.Seek(0);
-
-      co_return memoryStream;
-    }
-  } catch (winrt::hresult_error const &e) {
-    DEBUG_HRESULT_ERROR(e);
-  }
-
-  co_return nullptr;
-}
-
-winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageInlineDataAsync(ReactImageSource source) {
-  size_t start = source.uri.find(',');
-  if (start == std::string::npos || start + 1 > source.uri.length())
-    co_return nullptr;
-
-  try {
-    co_await winrt::resume_background();
-
-    std::string_view base64String(source.uri.c_str() + start + 1, source.uri.length() - start - 1);
-    auto buffer =
-        winrt::Windows::Security::Cryptography::CryptographicBuffer::DecodeFromBase64String(Utf8ToUtf16(base64String));
-
-    winrt::InMemoryRandomAccessStream memoryStream;
-    co_await memoryStream.WriteAsync(buffer);
-    memoryStream.Seek(0);
-
-    co_return memoryStream;
-  } catch (winrt::hresult_error const &) {
-    // Base64 decode failed
-  }
-
-  co_return nullptr;
-}
 } // namespace Microsoft::ReactNative

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

@@ -9,26 +9,11 @@
 #include <UI.Xaml.Controls.h>
 
 #include <JSValue.h>
+#include <Utils/ImageUtils.h>
 #include <folly/dynamic.h>
 
 namespace Microsoft::ReactNative {
 
-enum class ImageSourceType { Uri = 0, Download = 1, InlineData = 2 };
-enum class ImageSourceFormat { Bitmap = 0, Svg = 1 };
-
-struct ReactImageSource {
-  std::string uri;
-  std::string method;
-  std::string bundleRootPath;
-  std::vector<std::pair<std::string, std::string>> headers;
-  double width = 0;
-  double height = 0;
-  double scale = 1.0;
-  bool packagerAsset = false;
-  ImageSourceType sourceType = ImageSourceType::Uri;
-  ImageSourceFormat sourceFormat = ImageSourceFormat::Bitmap;
-};
-
 struct ReactImage : xaml::Controls::GridT<ReactImage> {
   using Super = xaml::Controls::GridT<ReactImage>;
 
@@ -69,8 +54,6 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
  private:
   xaml::Media::Stretch ResizeModeToStretch();
   xaml::Media::Stretch ResizeModeToStretch(winrt::Windows::Foundation::Size size);
-  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
-  GetImageMemoryStreamAsync(ReactImageSource source);
   winrt::fire_and_forget SetBackground(bool fireLoadEndEvent);
 
   bool m_useCompositionBrush{false};
@@ -90,9 +73,4 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
   xaml::Media::Imaging::SvgImageSource::OpenFailed_revoker m_svgImageSourceOpenFailedRevoker;
 };
 
-// Helper functions
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> GetImageStreamAsync(
-    ReactImageSource source);
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
-GetImageInlineDataAsync(ReactImageSource source);
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/KeyboardEventHandler.cpp

@@ -10,6 +10,10 @@
 #include "Utils/PropertyHandlerUtils.h"
 #include "Views/KeyboardEventHandler.h"
 
+#ifdef USE_WINUI3
+#include <winrt/Microsoft.UI.Input.h>
+#endif
+
 using namespace std::placeholders;
 
 static constexpr auto ALT_KEY = "altKey";
@@ -630,14 +634,23 @@ std::string KeyboardHelper::CodeFromVirtualKey(winrt::Windows::System::VirtualKe
 bool KeyboardHelper::IsModifiedKeyPressed(
     winrt::CoreWindow const &coreWindow,
     winrt::Windows::System::VirtualKey virtualKey) {
-  return (coreWindow.GetKeyState(virtualKey) & winrt::CoreVirtualKeyStates::Down) == winrt::CoreVirtualKeyStates::Down;
+#ifdef USE_WINUI3
+  auto const &keyState = winrt::Microsoft::UI::Input::InputKeyboardSource::GetKeyStateForCurrentThread(virtualKey);
+#else
+  auto const &keyState = coreWindow.GetKeyState(virtualKey);
+#endif // USE_WINUI3
+  return (keyState & winrt::CoreVirtualKeyStates::Down) == winrt::CoreVirtualKeyStates::Down;
 }
 
 bool KeyboardHelper::IsModifiedKeyLocked(
     winrt::CoreWindow const &coreWindow,
     winrt::Windows::System::VirtualKey virtualKey) {
-  return (coreWindow.GetKeyState(virtualKey) & winrt::CoreVirtualKeyStates::Locked) ==
-      winrt::CoreVirtualKeyStates::Locked;
+#ifdef USE_WINUI3
+  auto const &keyState = winrt::Microsoft::UI::Input::InputKeyboardSource::GetKeyStateForCurrentThread(virtualKey);
+#else
+  auto const &keyState = coreWindow.GetKeyState(virtualKey);
+#endif // USE_WINUI3
+  return (keyState & winrt::CoreVirtualKeyStates::Locked) == winrt::CoreVirtualKeyStates::Locked;
 }
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/PopupViewManager.cpp

@@ -78,8 +78,7 @@ void PopupShadowNode::createView(const winrt::Microsoft::ReactNative::JSValueObj
 
   auto popup = GetView().as<winrt::Popup>();
   auto control = GetControl();
-  m_touchEventHandler = std::make_unique<TouchEventHandler>(
-      GetViewManager()->GetReactContext(), false /*Popup not supported in fabric currently*/);
+  m_touchEventHandler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext());
   m_previewKeyboardEventHandlerOnRoot =
       std::make_unique<PreviewKeyboardEventHandlerOnRoot>(GetViewManager()->GetReactContext());
 

package/Microsoft.ReactNative/Views/ScrollViewManager.cpp

@@ -90,8 +90,7 @@ void ScrollViewShadowNode::dispatchCommand(
     scrollViewer.ChangeView(x, y, nullptr, !animated /*disableAnimation*/);
   } else if (commandId == ScrollViewCommands::ScrollToEnd) {
     bool animated = commandArgs[0].AsBoolean();
-    bool horiz = scrollViewer.HorizontalScrollMode() == winrt::ScrollMode::Auto;
-    if (horiz)
+    if (m_isHorizontal)
       scrollViewer.ChangeView(scrollViewer.ScrollableWidth(), nullptr, nullptr, !animated /*disableAnimation*/);
     else
       scrollViewer.ChangeView(nullptr, scrollViewer.ScrollableHeight(), nullptr, !animated /*disableAnimation*/);
@@ -490,7 +489,6 @@ XamlView ScrollViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microso
   scrollViewer.VerticalSnapPointsAlignment(winrt::SnapPointsAlignment::Near);
   scrollViewer.VerticalSnapPointsType(winrt::SnapPointsType::Mandatory);
   scrollViewer.HorizontalSnapPointsType(winrt::SnapPointsType::Mandatory);
-  scrollViewer.HorizontalScrollMode(winrt::ScrollMode::Disabled);
 
   const auto snapPointManager = SnapPointManagingContentControl::Create();
   scrollViewer.Content(*snapPointManager);

package/Microsoft.ReactNative/Views/ShadowNodeBase.h

@@ -44,6 +44,13 @@ enum class ShadowCorners : uint8_t {
   CountCorners
 };
 
+struct ShadowNodeLayout {
+  float Left;
+  float Top;
+  float Width;
+  float Height;
+};
+
 extern const DECLSPEC_SELECTANY double c_UndefinedEdge = -1;
 #define INIT_UNDEFINED_EDGES                                                                              \
   {                                                                                                       \
@@ -103,7 +110,6 @@ struct REACTWINDOWS_EXPORT ShadowNodeBase : public ShadowNode {
   virtual bool IsExternalLayoutDirty() const {
     return false;
   }
-  virtual void DoExtraLayoutPrep(YGNodeRef /*yogaNode*/) {}
 
   bool HasTransformPS() const {
     return m_transformPS != nullptr;
@@ -133,6 +139,9 @@ struct REACTWINDOWS_EXPORT ShadowNodeBase : public ShadowNode {
   // Pointer events
   PointerEventsKind m_pointerEvents = PointerEventsKind::Auto;
 
+  // Layout
+  ShadowNodeLayout m_layout;
+
   // Support Keyboard
  public:
   void UpdateHandledKeyboardEvents(

package/Microsoft.ReactNative/Views/ShadowNodeRegistry.cpp

@@ -55,18 +55,6 @@ std::unordered_set<int64_t> &ShadowNodeRegistry::getAllRoots() {
   return m_roots;
 }
 
-// iterate its parent to get the root shadow node
-ShadowNode *ShadowNodeRegistry::getParentRootShadowNode(int64_t nodeTag) {
-  auto node = findNode(nodeTag);
-  while (node) {
-    if (m_roots.find(node->m_tag) != m_roots.end()) {
-      return node;
-    }
-    node = findNode(node->m_parent);
-  }
-  return nullptr;
-}
-
 void ShadowNodeRegistry::ForAllNodes(const Mso::FunctorRef<void(int64_t, shadow_ptr const &) noexcept> &fnDo) noexcept {
   for (auto &kvp : m_allNodes) {
     fnDo(kvp.first, kvp.second);

package/Microsoft.ReactNative/Views/ShadowNodeRegistry.h

@@ -4,7 +4,7 @@
 #pragma once
 #include <Views/PaperShadowNode.h>
 #include <functional/functorref.h>
-#include <map>
+#include <unordered_map>
 
 namespace Microsoft::ReactNative {
 
@@ -30,13 +30,11 @@ struct ShadowNodeRegistry {
 
   std::unordered_set<int64_t> &getAllRoots();
 
-  ShadowNode *getParentRootShadowNode(int64_t nodeTag);
-
   void ForAllNodes(const Mso::FunctorRef<void(int64_t, shadow_ptr const &) noexcept> &fnDo) noexcept;
 
  private:
   std::unordered_set<int64_t> m_roots;
-  std::map<int64_t, std::unique_ptr<ShadowNode, ShadowNodeDeleter>> m_allNodes;
+  std::unordered_map<int64_t, std::unique_ptr<ShadowNode, ShadowNodeDeleter>> m_allNodes;
 };
 
 } // namespace Microsoft::ReactNative