react-native-windows 0.66.3 → 0.67.0-preview.3

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.cpp

@@ -168,10 +168,13 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
       React::JSValueArray &&point,
       std::function<void(double nativeViewTag, double left, double top, double width, double height)>
           &&callback) noexcept {
-    auto &node = m_nodeRegistry.getNode(reactTag);
-    float x = static_cast<float>(point[0]);
-    float y = static_cast<float>(point[1]);
-    m_nativeUIManager->findSubviewIn(node, x, y, std::move(callback));
+    if (auto node = m_nodeRegistry.findNode(reactTag)) {
+      float x = static_cast<float>(point[0]);
+      float y = static_cast<float>(point[1]);
+      m_nativeUIManager->findSubviewIn(*node, x, y, std::move(callback));
+    } else {
+      callback(0, 0, 0, 0, 0);
+    }
   }
 
   void dispatchViewManagerCommand(
@@ -179,34 +182,40 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
       winrt::Microsoft::ReactNative::JSValue &&commandID,
       React::JSValueArray &&commandArgs) noexcept {
     m_nativeUIManager->ensureInBatch();
-    auto &node = m_nodeRegistry.getNode(reactTag);
-
-    if (!node.m_zombie)
-      node.dispatchCommand(commandID.AsString(), std::move(commandArgs));
+    if (auto node = m_nodeRegistry.findNode(reactTag)) {
+      if (!node->m_zombie)
+        node->dispatchCommand(commandID.AsString(), std::move(commandArgs));
+    }
   }
 
   void measure(
       int64_t reactTag,
       std::function<void(double left, double top, double width, double height, double pageX, double pageY)>
           &&callback) noexcept {
-    auto &node = m_nodeRegistry.getNode(reactTag);
-    int64_t rootTag = reactTag;
-    while (true) {
-      auto &currNode = m_nodeRegistry.getNode(rootTag);
-      if (currNode.m_parent == -1)
-        break;
-      rootTag = currNode.m_parent;
-    }
-    auto &rootNode = m_nodeRegistry.getNode(rootTag);
+    if (auto node = m_nodeRegistry.findNode(reactTag)) {
+      int64_t rootTag = reactTag;
+      while (true) {
+        if (auto currNode = m_nodeRegistry.findNode(rootTag)) {
+          if (currNode->m_parent == -1) {
+            break;
+          }
+          rootTag = currNode->m_parent;
+        } else {
+          callback(0, 0, 0, 0, 0, 0);
+          return;
+        }
+      }
+      auto &rootNode = m_nodeRegistry.getNode(rootTag);
 
-    m_nativeUIManager->measure(node, rootNode, std::move(callback));
+      m_nativeUIManager->measure(*node, rootNode, std::move(callback));
+    }
   }
 
   void measureInWindow(
       int64_t reactTag,
       std::function<void(double x, double y, double width, double height)> &&callback) noexcept {
-    auto &node = m_nodeRegistry.getNode(reactTag);
-    m_nativeUIManager->measureInWindow(node, std::move(callback));
+    if (auto node = m_nodeRegistry.findNode(reactTag))
+      m_nativeUIManager->measureInWindow(*node, std::move(callback));
   }
 
   void viewIsDescendantOf(
@@ -222,9 +231,11 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
       int64_t ancestorReactTag,
       std::function<void(React::JSValue const &)> &&errorCallback,
       std::function<void(double left, double top, double width, double height)> &&callback) noexcept {
-    auto &node = m_nodeRegistry.getNode(reactTag);
-    auto &ancestorNode = m_nodeRegistry.getNode(ancestorReactTag);
-    m_nativeUIManager->measureLayout(node, ancestorNode, std::move(errorCallback), std::move(callback));
+    auto node = m_nodeRegistry.findNode(reactTag);
+    auto ancestorNode = m_nodeRegistry.findNode(ancestorReactTag);
+    if (node && ancestorNode) {
+      m_nativeUIManager->measureLayout(*node, *ancestorNode, std::move(errorCallback), std::move(callback));
+    }
   }
 
   void measureLayoutRelativeToParent(
@@ -252,13 +263,13 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
 
   void removeSubviewsFromContainerWithID(int64_t containerID) noexcept {
     m_nativeUIManager->ensureInBatch();
-    auto &containerNode = m_nodeRegistry.getNode(containerID);
-
-    std::vector<int64_t> indicesToRemove(containerNode.m_children.size());
-    for (size_t i = 0; i < containerNode.m_children.size(); i++)
-      indicesToRemove[static_cast<size_t>(i)] = static_cast<int64_t>(i);
-    std::vector<int64_t> emptyVec;
-    manageChildren(containerID, emptyVec, emptyVec, emptyVec, emptyVec, indicesToRemove);
+    if (auto containerNode = m_nodeRegistry.findNode(containerID)) {
+      std::vector<int64_t> indicesToRemove(containerNode->m_children.size());
+      for (size_t i = 0; i < containerNode->m_children.size(); i++)
+        indicesToRemove[static_cast<size_t>(i)] = static_cast<int64_t>(i);
+      std::vector<int64_t> emptyVec;
+      manageChildren(containerID, emptyVec, emptyVec, emptyVec, emptyVec, indicesToRemove);
+    }
   }
 
   void replaceExistingNonRootView(int64_t reactTag, int64_t newReactTag) noexcept {
@@ -268,39 +279,44 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
     std::vector<int64_t> tagToAdd(1);
     tagToAdd[0] = newReactTag;
 
-    CHECK(m_nodeRegistry.getNode(reactTag).m_parent != -1) << "oldTag must have a parent";
-    auto &parent = m_nodeRegistry.getNode(m_nodeRegistry.getNode(reactTag).m_parent);
-    auto it = find(parent.m_children.begin(), parent.m_children.end(), reactTag);
-    CHECK(it != parent.m_children.end());
-    indicesToAdd[0] = indicesToRemove[0] = it - parent.m_children.begin();
+    if (auto node = m_nodeRegistry.findNode(reactTag)) {
+      CHECK(node->m_parent != -1) << "oldTag must have a parent";
+      if (auto parent = m_nodeRegistry.findNode(node->m_parent)) {
+        auto it = find(parent->m_children.begin(), parent->m_children.end(), reactTag);
+        CHECK(it != parent->m_children.end());
+        indicesToAdd[0] = indicesToRemove[0] = it - parent->m_children.begin();
 
-    std::vector<int64_t> emptyVec;
-    manageChildren(parent.m_tag, emptyVec, emptyVec, tagToAdd, indicesToAdd, indicesToRemove);
+        std::vector<int64_t> emptyVec;
+        manageChildren(parent->m_tag, emptyVec, emptyVec, tagToAdd, indicesToAdd, indicesToRemove);
+      }
+    }
   }
 
   void removeRootView(int64_t rootViewTag) noexcept {
     m_nativeUIManager->ensureInBatch();
-    auto &node = m_nodeRegistry.getRoot(rootViewTag);
-    m_nativeUIManager->removeRootView(node);
-    DropView(rootViewTag, true);
-    m_nodeRegistry.removeRootView(rootViewTag);
-    m_nativeUIManager->destroyRootShadowNode(&node);
+    if (auto node = m_nodeRegistry.findNode(rootViewTag)) {
+      m_nativeUIManager->removeRootView(*node);
+      DropView(rootViewTag, true);
+      m_nodeRegistry.removeRootView(rootViewTag);
+      m_nativeUIManager->destroyRootShadowNode(node);
+    }
   }
 
   void setChildren(int64_t containerTag, React::JSValueArray &&reactTags) noexcept {
     m_nativeUIManager->ensureInBatch();
-    auto &parent = m_nodeRegistry.getNode(containerTag);
-    int64_t index = 0;
-    for (auto &&childTag : reactTags) {
-      auto tag = childTag.AsInt64();
-      auto &childNode = m_nodeRegistry.getNode(tag);
-      childNode.m_parent = parent.m_tag;
-      parent.m_children.push_back(tag);
-      if (!parent.m_zombie)
-        parent.AddView(childNode, index);
-
-      m_nativeUIManager->AddView(parent, childNode, index);
-      ++index;
+    if (auto parent = m_nodeRegistry.findNode(containerTag)) {
+      int64_t index = 0;
+      for (auto &&childTag : reactTags) {
+        auto tag = childTag.AsInt64();
+        auto childNode = m_nodeRegistry.findNode(tag);
+        childNode->m_parent = parent->m_tag;
+        parent->m_children.push_back(tag);
+        if (!parent->m_zombie)
+          parent->AddView(*childNode, index);
+
+        m_nativeUIManager->AddView(*parent, *childNode, index);
+        ++index;
+      }
     }
   }
 
@@ -483,23 +499,23 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
   }
 
   void DropView(int64_t tag, bool removeChildren = true, bool zombieView = false) {
-    auto &node = m_nodeRegistry.getNode(tag);
+    if (auto node = m_nodeRegistry.findNode(tag)) {
+      node->onDropViewInstance();
 
-    node.onDropViewInstance();
+      m_nativeUIManager->RemoveView(*node, removeChildren);
 
-    m_nativeUIManager->RemoveView(node, removeChildren);
+      if (zombieView)
+        node->m_zombie = true;
 
-    if (zombieView)
-      node.m_zombie = true;
+      for (auto childTag : node->m_children)
+        DropView(childTag, removeChildren, zombieView);
 
-    for (auto childTag : node.m_children)
-      DropView(childTag, removeChildren, zombieView);
+      if (removeChildren)
+        node->removeAllChildren();
 
-    if (removeChildren)
-      node.removeAllChildren();
-
-    if (!zombieView)
-      m_nodeRegistry.removeNode(tag);
+      if (!zombieView)
+        m_nodeRegistry.removeNode(tag);
+    }
   }
 
   winrt::Microsoft::ReactNative::ReactContext m_context;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -22,7 +22,9 @@
 #include "../../codegen/NativeClipboardSpec.g.h"
 #include "../../codegen/NativeDevSettingsSpec.g.h"
 #include "../../codegen/NativeDeviceInfoSpec.g.h"
+#include "../../codegen/NativeDialogManagerWindowsSpec.g.h"
 #include "../../codegen/NativeI18nManagerSpec.g.h"
+#include "../../codegen/NativeImageLoaderIOSSpec.g.h"
 #include "../../codegen/NativeLogBoxSpec.g.h"
 #include "../../codegen/NativeUIManagerSpec.g.h"
 #include "NativeModules.h"
@@ -54,6 +56,7 @@
 #endif
 #include "Modules/DevSettingsModule.h"
 #ifndef CORE_ABI
+#include <Modules/ImageViewManagerModule.h>
 #include "Modules/DeviceInfoModule.h"
 #include "Modules/I18nManagerModule.h"
 #include "Modules/LogBoxModule.h"
@@ -294,7 +297,11 @@ void ReactInstanceWin::LoadModules(
           ::Microsoft::ReactNative::AccessibilityInfo,
           ::Microsoft::ReactNativeSpecs::AccessibilityInfoSpec>());
 
-  registerTurboModule(L"Alert", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Alert>());
+  registerTurboModule(
+      L"Alert",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
+          ::Microsoft::ReactNative::Alert,
+          ::Microsoft::ReactNativeSpecs::DialogManagerWindowsSpec>());
 
   registerTurboModule(
       L"AppState",
@@ -316,6 +323,12 @@ void ReactInstanceWin::LoadModules(
       winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
           ::Microsoft::ReactNative::DeviceInfo,
           ::Microsoft::ReactNativeSpecs::DeviceInfoSpec>());
+
+  registerTurboModule(
+      L"ImageLoader",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<
+          ::Microsoft::ReactNative::ImageLoader,
+          ::Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec>());
 #endif
 
   registerTurboModule(

package/Microsoft.ReactNative/ReactInstanceSettings.idl

@@ -217,7 +217,9 @@ namespace Microsoft.ReactNative
 
     DOC_STRING(
       "The @JSIEngine override to be used with the React instance.\n"
-      "In order the override to work the Microsoft.ReactNative must be compiled with support of that engine.")
+      "In order for the override to work, Microsoft.ReactNative must be compiled with support of that engine. "
+      "This override will be ignored when @.UseWebDebugger is set to true, since the browser must use its own "
+      "engine to debug correctly.")
     DOC_DEFAULT("JSIEngine.Chakra")
     JSIEngine JSIEngineOverride { get; set; };
 

package/Microsoft.ReactNative/ReactPointerEventArgs.cpp

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "ReactPointerEventArgs.h"
+#include "ReactPointerEventArgs.g.cpp"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+xaml::Input::PointerRoutedEventArgs ReactPointerEventArgs::Args() const noexcept {
+  return m_args;
+}
+
+PointerEventKind ReactPointerEventArgs::Kind() const noexcept {
+  return m_kind;
+}
+
+void ReactPointerEventArgs::Kind(PointerEventKind kind) noexcept {
+  // The only event type change that is supported is CaptureLost to End.
+  assert(kind == PointerEventKind::End && m_kind == PointerEventKind::CaptureLost);
+  m_kind = kind;
+}
+
+winrt::IInspectable ReactPointerEventArgs::Target() const noexcept {
+  return m_target;
+}
+
+void ReactPointerEventArgs::Target(winrt::IInspectable const &target) noexcept {
+  m_target = target;
+}
+
+ReactPointerEventArgs::ReactPointerEventArgs(
+    PointerEventKind kind,
+    xaml::Input::PointerRoutedEventArgs const &args) noexcept
+    : m_kind{kind}, m_args{args} {}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactPointerEventArgs.h

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ReactPointerEventArgs.g.h"
+#include <UI.Xaml.Input.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+struct ReactPointerEventArgs : ReactPointerEventArgsT<ReactPointerEventArgs> {
+  xaml::Input::PointerRoutedEventArgs Args() const noexcept;
+
+  PointerEventKind Kind() const noexcept;
+  void Kind(PointerEventKind kind) noexcept;
+
+  winrt::IInspectable Target() const noexcept;
+  void Target(winrt::IInspectable const &target) noexcept;
+
+  // Internal use
+  ReactPointerEventArgs(PointerEventKind kind, xaml::Input::PointerRoutedEventArgs const &args) noexcept;
+
+ private:
+  PointerEventKind m_kind;
+  xaml::Input::PointerRoutedEventArgs const &m_args;
+  winrt::IInspectable m_target{nullptr};
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactPointerEventArgs.idl

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "DocString.h"
+#include "NamespaceRedirect.h"
+
+namespace Microsoft.ReactNative {
+  [experimental]
+  [webhosthidden]
+  enum PointerEventKind {
+    DOC_STRING(
+      "Default pointer event kind that corresponding to events that should be "
+      "ignored by the React root view pointer event handler."
+    )
+    None,
+    DOC_STRING(
+      "Pointer event kind corresponding to "
+      "@Windows.UI.Xaml.UIElement.PointerPressedEvent on the React root view."
+    )
+    Start,
+    DOC_STRING(
+      "Pointer event kind corresponding to "
+      "@Windows.UI.Xaml.UIElement.PointerReleasedEvent on the React root view."
+    )
+    End,
+    DOC_STRING(
+      "Pointer event kind corresponding to "
+      "@Windows.UI.Xaml.UIElement.PointerMovedEvent on the React root view."
+    )
+    Move,
+    DOC_STRING(
+      "Pointer event kind corresponding to "
+      "@Windows.UI.Xaml.UIElement.PointerCanceledEvent on the React root view."
+    )
+    Cancel,
+    DOC_STRING(
+      "Pointer event kind corresponding to "
+      "@Windows.UI.Xaml.UIElement.PointerCaptureLostEvent on the React root view."
+    )
+    CaptureLost,
+  };
+
+  [experimental]
+  [webhosthidden]
+  DOC_STRING("Event arguments wrapper for @IViewManagerWithPointerEvents.")
+  runtimeclass ReactPointerEventArgs {
+    DOC_STRING("Gets the wrapped routed pointer event.")
+    XAML_NAMESPACE.Input.PointerRoutedEventArgs Args {
+      get;
+    };
+    DOC_STRING(
+      "Gets or sets the pointer event kind. The only valid override is "
+      "@PointerEventKind.CaptureLost to @PointerEventKind.End to handle cases "
+      "where PointerCaptureLost events on ReactRootView can be safely treated "
+      "as PointerReleased events, e.g., for pointer events on selectable text."
+    )
+    PointerEventKind Kind {
+      get;
+      set;
+    };
+    DOC_STRING("Gets or sets the React target for the pointer event.")
+    Object Target {
+      get;
+      set;
+    };
+  }
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/Utils/TextTransform.h

@@ -4,5 +4,5 @@
 #pragma once
 
 namespace Microsoft::ReactNative {
-enum class TextTransform : uint8_t { Undefined, None, Uppercase, Lowercase, Capitalize };
+enum class TextTransform : uint8_t { Undefined = 0, None, Uppercase, Lowercase, Capitalize };
 }

package/Microsoft.ReactNative/Utils/XamlIslandUtils.cpp

@@ -30,21 +30,35 @@ struct CustomAppBarButton : xaml::Controls::AppBarButtonT<CustomAppBarButton> {
   }
 };
 
-void FixProofingMenuCrashForXamlIsland(xaml::Controls::TextCommandBarFlyout const &flyout) {
+void FixProofingMenuCrashForXamlIsland(xaml::Controls::Primitives::FlyoutBase const &flyout) {
   flyout.Opening([](winrt::IInspectable const &sender, auto &&) {
-    const auto &flyout = sender.as<xaml::Controls::TextCommandBarFlyout>();
+    const auto &flyout = sender.as<winrt::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout>();
     if (const auto &textBox = flyout.Target().try_as<xaml::Controls::TextBox>()) {
       const auto &commands = flyout.SecondaryCommands();
       for (uint32_t i = 0; i < commands.Size(); ++i) {
         if (const auto &appBarButton = commands.GetAt(i).try_as<xaml::Controls::AppBarButton>()) {
-          if (appBarButton.Flyout() == textBox.ProofingMenuFlyout()) {
-            // Replace the AppBarButton for the proofing menu with one that doesn't crash
-            const auto customAppBarButton = winrt::make<CustomAppBarButton>();
-            customAppBarButton.Label(appBarButton.Label());
-            customAppBarButton.Icon(appBarButton.Icon());
-            customAppBarButton.Flyout(appBarButton.Flyout());
-            commands.RemoveAt(i);
-            commands.InsertAt(i, customAppBarButton);
+          if (!appBarButton.Flyout()) {
+            // This works around a loss of focus from the target element when clicking on
+            // on the menu items.
+            // https://github.com/microsoft/microsoft-ui-xaml/issues/5818
+            appBarButton.Click([weakCommandBarFlyout = winrt::make_weak(flyout)](auto &&...) {
+              if (auto flyout = weakCommandBarFlyout.get()) {
+                xaml::Input::FocusManager::TryFocusAsync(flyout.Target(), xaml::FocusState::Programmatic);
+              }
+            });
+          } else if (appBarButton.Flyout() == textBox.ProofingMenuFlyout()) {
+            if (!appBarButton.try_as<CustomAppBarButton>()) {
+              // Replace the AppBarButton for the proofing menu with one that doesn't crash
+              const auto customAppBarButton = winrt::make<CustomAppBarButton>();
+              customAppBarButton.Label(appBarButton.Label());
+              customAppBarButton.Icon(appBarButton.Icon());
+              customAppBarButton.Flyout(appBarButton.Flyout());
+              commands.RemoveAt(i);
+              commands.InsertAt(i, customAppBarButton);
+            } else if (!textBox.IsSpellCheckEnabled()) {
+              // Remove proofing menu option if spell-check is disabled
+              commands.RemoveAt(i);
+            }
 
             // There is only one proofing menu option
             break;

package/Microsoft.ReactNative/Utils/XamlIslandUtils.h

@@ -8,9 +8,11 @@
 #include <UI.Xaml.Controls.Primitives.h>
 #include <UI.Xaml.Controls.h>
 
+#include <winrt/Microsoft.UI.Xaml.Controls.h>
+
 namespace Microsoft::ReactNative {
 
-void FixProofingMenuCrashForXamlIsland(xaml::Controls::TextCommandBarFlyout const &flyout);
+void FixProofingMenuCrashForXamlIsland(xaml::Controls::Primitives::FlyoutBase const &flyout);
 
 template <typename T>
 inline void EnsureUniqueTextFlyoutForXamlIsland(T const &textView) {
@@ -19,7 +21,7 @@ inline void EnsureUniqueTextFlyoutForXamlIsland(T const &textView) {
   // to show the flyout on other windows cause the first window to get focus.
   // https://github.com/microsoft/microsoft-ui-xaml/issues/5341
   if (IsXamlIsland()) {
-    xaml::Controls::TextCommandBarFlyout flyout;
+    winrt::Microsoft::UI::Xaml::Controls::TextCommandBarFlyout flyout;
     flyout.Placement(xaml::Controls::Primitives::FlyoutPlacementMode::BottomEdgeAlignedLeft);
 
     // This works around a XAML Islands bug where the Proofing sub-menu for

package/Microsoft.ReactNative/Version.rc

@@ -3,29 +3,12 @@
 #define XSTRINGIZE(s) STRINGIZE(s)
 #define STRINGIZE(s) #s
 
-#ifdef RNW_PKG_VERSION_STR
-#define VER_FILEVERSION_STR XSTRINGIZE(RNW_PKG_VERSION_STR)
-#else
-#define VER_FILEVERSION_STR "Private Build"
-#endif
-
-#ifndef RNW_PKG_VERSION_MAJOR
-#define RNW_PKG_VERSION_MAJOR 1000
-#endif
-
-#ifndef RNW_PKG_VERSION_MINOR
-#define RNW_PKG_VERSION_MINOR 0
-#endif
-
-#ifndef RNW_PKG_VERSION_PATCH
-#define RNW_PKG_VERSION_PATCH 0
-#endif
-
 #ifndef RNW_PKG_VERSION_BUILD
 #define RNW_PKG_VERSION_BUILD 0
 #endif
 
-#define VER_FILEVERSION RNW_PKG_VERSION_MAJOR,RNW_PKG_VERSION_MINOR,RNW_PKG_VERSION_PATCH,RNW_PKG_VERSION_BUILD
+#define VER_FILEVERSION_STR XSTRINGIZE(RNW_VERSION)
+#define VER_FILEVERSION RNW_MAJOR,RNW_MINOR,RNW_PATCH,RNW_PKG_VERSION_BUILD
 
 #ifndef DEBUG
 #define VER_DEBUG                   0

package/Microsoft.ReactNative/Views/FlyoutViewManager.cpp

@@ -62,6 +62,12 @@ static const std::unordered_map<std::string, winrt::FlyoutPlacementMode> placeme
     {"right-edge-aligned-top", winrt::FlyoutPlacementMode::RightEdgeAlignedTop},
     {"right-edge-aligned-bottom", winrt::FlyoutPlacementMode::RightEdgeAlignedBottom}};
 
+static const std::unordered_map<std::string, winrt::FlyoutShowMode> showModes = {
+    {"auto", winrt::FlyoutShowMode::Auto},
+    {"standard", winrt::FlyoutShowMode::Standard},
+    {"transient", winrt::FlyoutShowMode::Transient},
+    {"transient-with-dismiss-on-pointer-move-away", winrt::FlyoutShowMode::TransientWithDismissOnPointerMoveAway}};
+
 template <>
 struct json_type_traits<winrt::FlyoutPlacementMode> {
   static winrt::FlyoutPlacementMode parseJson(const winrt::Microsoft::ReactNative::JSValue &value) {
@@ -76,6 +82,19 @@ struct json_type_traits<winrt::FlyoutPlacementMode> {
   }
 };
 
+template <>
+struct json_type_traits<winrt::FlyoutShowMode> {
+  static winrt::FlyoutShowMode parseJson(const winrt::Microsoft::ReactNative::JSValue &value) {
+    auto iter = showModes.find(value.AsString());
+
+    if (iter != showModes.end()) {
+      return iter->second;
+    }
+
+    return winrt::FlyoutShowMode::Auto;
+  }
+};
+
 namespace Microsoft::ReactNative {
 
 class FlyoutShadowNode : public ShadowNodeBase {
@@ -112,6 +131,7 @@ class FlyoutShadowNode : public ShadowNodeBase {
   float m_verticalOffset = 0;
   bool m_isFlyoutShowOptionsSupported = false;
   winrt::FlyoutShowOptions m_showOptions = nullptr;
+  bool m_autoFocus = false;
 
   std::unique_ptr<TouchEventHandler> m_touchEventHanadler;
   std::unique_ptr<PreviewKeyboardEventHandlerOnRoot> m_previewKeyboardEventHandlerOnRoot;
@@ -210,6 +230,17 @@ void FlyoutShadowNode::createView(const winrt::Microsoft::ReactNative::JSValueOb
           }
         }
 
+        if (m_autoFocus) {
+          if (const auto content = m_flyout.Content()) {
+            if (const auto elementToFocus = xaml::Input::FocusManager::FindFirstFocusableElement(content)) {
+              if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+                // NativeUIManager::focus is a no-op if the tag is not found
+                uiManager->focus(GetTag(elementToFocus));
+              }
+            }
+          }
+        }
+
         flyoutPresenter.AllowFocusOnInteraction(false);
       }
     }
@@ -327,6 +358,18 @@ void FlyoutShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValueOb
       }
 
       m_flyout.LightDismissOverlayMode(overlayMode);
+    } else if (propertyName == "autoFocus") {
+      m_autoFocus = propertyValue.AsBoolean();
+    } else if (propertyName == "showMode") {
+      const auto showMode = json_type_traits<winrt::FlyoutShowMode>::parseJson(propertyValue);
+      m_flyout.ShowMode(showMode);
+      if (m_isFlyoutShowOptionsSupported) {
+        m_showOptions.ShowMode(showMode);
+      }
+    } else if (propertyName == "shouldConstrainToRootBounds") {
+      if (propertyValue.Type() == React::JSValueType::Boolean) {
+        m_flyout.ShouldConstrainToRootBounds(propertyValue.AsBoolean());
+      }
     }
   }
 
@@ -384,7 +427,16 @@ void FlyoutShadowNode::SetTargetFrameworkElement() {
       }
     }
   } else {
-    m_targetElement = xaml::Window::Current().Content().as<xaml::FrameworkElement>();
+    if (IsXamlIsland()) {
+      // // XamlRoot added in 19H1
+      if (Is19H1OrHigher()) {
+        if (auto xamlRoot = React::XamlUIService::GetXamlRoot(GetViewManager()->GetReactContext().Properties())) {
+          m_targetElement = xamlRoot.Content().as<xaml::FrameworkElement>();
+        }
+      }
+    } else {
+      m_targetElement = xaml::Window::Current().Content().as<xaml::FrameworkElement>();
+    }
   }
 }
 
@@ -448,10 +500,13 @@ void FlyoutViewManager::GetNativeProps(const winrt::Microsoft::ReactNative::IJSV
   React::WriteProperty(writer, L"horizontalOffset", L"number");
   React::WriteProperty(writer, L"isLightDismissEnabled", L"boolean");
   React::WriteProperty(writer, L"isOpen", L"boolean");
-  React::WriteProperty(writer, L"placement", L"number");
+  React::WriteProperty(writer, L"placement", L"string");
   React::WriteProperty(writer, L"target", L"number");
   React::WriteProperty(writer, L"verticalOffset", L"number");
   React::WriteProperty(writer, L"isOverlayEnabled", L"boolean");
+  React::WriteProperty(writer, L"autoFocus", L"boolean");
+  React::WriteProperty(writer, L"showMode", L"string");
+  React::WriteProperty(writer, L"shouldConstrainToRootBounds", L"boolean");
 }
 
 void FlyoutViewManager::GetExportedCustomDirectEventTypeConstants(

package/Microsoft.ReactNative/Views/FrameworkElementTransferProperties.cpp

@@ -33,6 +33,9 @@ void TransferFrameworkElementProperties(const xaml::DependencyObject &oldView, c
   // Render Properties
   TransferProperty(oldView, newView, xaml::UIElement::OpacityProperty());
 
+  // Hit Test Properties
+  TransferProperty(oldView, newView, xaml::UIElement::IsHitTestVisibleProperty());
+
   // Layout Properties
   TransferProperty(oldView, newView, xaml::FrameworkElement::WidthProperty());
   TransferProperty(oldView, newView, xaml::FrameworkElement::HeightProperty());

package/Microsoft.ReactNative/Views/FrameworkElementViewManager.cpp

@@ -261,8 +261,13 @@ bool FrameworkElementViewManager::UpdateProperty(
       AnnounceLiveRegionChangedIfNeeded(element);
     } else if (propertyName == "accessible") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
-        if (!propertyValue.AsBoolean())
-          xaml::Automation::AutomationProperties::SetAccessibilityView(element, winrt::Peers::AccessibilityView::Raw);
+        if (propertyValue.AsBoolean()) {
+          xaml::Automation::AutomationProperties::SetAccessibilityView(element, winrt::AccessibilityView::Content);
+        } else {
+          xaml::Automation::AutomationProperties::SetAccessibilityView(element, winrt::AccessibilityView::Raw);
+        }
+      } else if (propertyValue.IsNull()) {
+        element.ClearValue(xaml::Automation::AutomationProperties::AccessibilityViewProperty());
       }
     } else if (propertyName == "accessibilityLiveRegion") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {