react-native-windows 0.69.6 → 0.70.0-preview.1

package/Microsoft.ReactNative/ReactHost/JSCallInvokerScheduler.cpp

@@ -12,6 +12,7 @@ namespace Mso {
 struct JSCallInvokerScheduler
     : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDispatchQueueScheduler, IJSCallInvokerQueueScheduler> {
   JSCallInvokerScheduler(
+      const Mso::DispatchQueueSettings &settings,
       std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
       Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
       Mso::Promise<void> &&whenQuit) noexcept;
@@ -45,12 +46,13 @@ std::shared_ptr<facebook::react::MessageQueueThread> JSCallInvokerScheduler::Get
 //=============================================================================
 
 JSCallInvokerScheduler::JSCallInvokerScheduler(
+    const Mso::DispatchQueueSettings &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit) noexcept
     : m_callInvoker(callInvoker) {
   m_jsMessageThread = std::make_shared<Mso::React::MessageDispatchQueue>(
-      Mso::DispatchQueue::MakeLooperQueue(), std::move(errorHandler), std::move(whenQuit));
+      Mso::DispatchQueue::MakeLooperQueue(settings), std::move(errorHandler), std::move(whenQuit));
 }
 
 JSCallInvokerScheduler::~JSCallInvokerScheduler() noexcept {
@@ -91,11 +93,12 @@ void JSCallInvokerScheduler::AwaitTermination() noexcept {
 }
 
 Mso::CntPtr<IDispatchQueueScheduler> MakeJSCallInvokerScheduler(
+    const Mso::DispatchQueueSettings &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit) noexcept {
   return Mso::Make<JSCallInvokerScheduler, IDispatchQueueScheduler>(
-      std::move(callInvoker), std::move(errorHandler), std::move(whenQuit));
+      settings, std::move(callInvoker), std::move(errorHandler), std::move(whenQuit));
 }
 
 } // namespace Mso

package/Microsoft.ReactNative/ReactHost/JSCallInvokerScheduler.h

@@ -19,6 +19,7 @@ struct IJSCallInvokerQueueScheduler : IUnknown {
 };
 
 Mso::CntPtr<IDispatchQueueScheduler> MakeJSCallInvokerScheduler(
+    Mso::DispatchQueueSettings const &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit = nullptr) noexcept;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -5,12 +5,12 @@
 #include "MoveOnCopy.h"
 #include "MsoUtils.h"
 
+#include <AppModelHelpers.h>
 #include <Base/CoreNativeModules.h>
 #include <Threading/MessageDispatchQueue.h>
 #include <Threading/MessageQueueThreadFactory.h>
 #include <appModel.h>
 #include <comUtil/qiCast.h>
-
 #ifndef CORE_ABI
 #include <XamlUIService.h>
 #endif
@@ -132,7 +132,8 @@ struct BridgeUIBatchInstanceCallback final : public facebook::react::InstanceCal
   virtual ~BridgeUIBatchInstanceCallback() = default;
   void onBatchComplete() override {
     if (auto instance = m_wkInstance.GetStrongPtr()) {
-      if (instance->IsLoaded()) {
+      auto state = instance->State();
+      if (state != ReactInstanceState::HasError && state != ReactInstanceState::Unloaded) {
         if (instance->UseWebDebugger()) {
           // While using a CxxModule for UIManager (which we do when running under webdebugger)
           // We need to post the batch complete to the NativeQueue to ensure that the UIManager
@@ -469,8 +470,7 @@ void ReactInstanceWin::Initialize() noexcept {
             case JSIEngine::V8:
 #if defined(USE_V8)
             {
-              uint32_t length{0};
-              if (GetCurrentPackageFullName(&length, nullptr) != APPMODEL_ERROR_NO_PACKAGE) {
+              if (Microsoft::ReactNative::HasPackageIdentity()) {
                 preparedScriptStore =
                     std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationTempFolder());
               } else {
@@ -679,7 +679,26 @@ ReactInstanceState ReactInstanceWin::State() const noexcept {
 void ReactInstanceWin::InitJSMessageThread() noexcept {
   m_instance.Exchange(std::make_shared<facebook::react::Instance>());
 
+  winrt::Microsoft::ReactNative::IReactNotificationService service = m_reactContext->Notifications();
+  Mso::DispatchQueueSettings queueSettings{};
+  queueSettings.TaskStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherTaskStartingEventName(), nullptr, nullptr);
+  };
+  queueSettings.IdleWaitStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitStartingEventName(),
+        nullptr,
+        nullptr);
+  };
+  queueSettings.IdleWaitCompleted = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitCompletedEventName(),
+        nullptr,
+        nullptr);
+  };
   auto scheduler = Mso::MakeJSCallInvokerScheduler(
+      queueSettings,
       m_instance.Load()->getJSCallInvoker(),
       Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
       Mso::Copy(m_whenDestroyed));

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -153,7 +153,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   const bool m_useDirectDebugger : 1;
   const bool m_useWebDebugger : 1;
 
-  const Mso::CntPtr<ReactContext> m_reactContext;
+  const Mso::CntPtr<::Mso::React::ReactContext> m_reactContext;
 
   std::atomic<bool> m_isLoaded{false};
   std::atomic<bool> m_isDestroyed{false};

package/Microsoft.ReactNative/ReactPointerEventArgs.cpp

@@ -16,8 +16,18 @@ PointerEventKind ReactPointerEventArgs::Kind() const noexcept {
 }
 
 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);
+  // The only event type transitions that are supported are:
+  // 1. PointerEventKind::CaptureLost to PointerEventKind::End to support cases
+  //    where XAML firing the CaptureLost event should be treated as a gesture
+  //    completion event, e.g., for pointer events in selectable text that do
+  //    not result in text selection.
+  // 2. PointerEventKind::End to PointerEventKind::Cancel to support cases
+  //    where a custom view manager implementing `IViewManagerWithPointerEvents`
+  //    wants to cancel a gesture, e.g., for a custom drag handle where the end
+  //    of the gesture should not be treated as a completed press event.
+  assert(
+      (kind == PointerEventKind::End && m_kind == PointerEventKind::CaptureLost) ||
+      (kind == PointerEventKind::Cancel && m_kind == PointerEventKind::End));
   m_kind = kind;
 }
 

package/Microsoft.ReactNative/Utils/BatchingEventEmitter.cpp

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "BatchingEventEmitter.h"
+#include <UI.Xaml.Media.h>
 #include "DynamicWriter.h"
 #include "JSValueWriter.h"
 

package/Microsoft.ReactNative/Utils/Helpers.cpp

@@ -31,7 +31,7 @@ namespace Microsoft::ReactNative {
 // Instead of deduce view id directly from FrameworkElement.Tag, this do
 // additional check by uimanager.
 ReactId getViewId(const Mso::React::IReactContext &context, xaml::FrameworkElement const &fe) {
-  ReactId reactId;
+  ReactId reactId{};
   if (auto uiManager = Microsoft::ReactNative::GetNativeUIManager(context).lock()) {
     if (auto peer = uiManager->reactPeerOrContainerFrom(fe)) {
       reactId.isValid = true;

package/Microsoft.ReactNative/Utils/Helpers.h

@@ -18,7 +18,7 @@ struct ReactId {
 };
 
 template <typename T>
-inline typename T asEnum(winrt::Microsoft::ReactNative::JSValue const &obj) {
+inline T asEnum(winrt::Microsoft::ReactNative::JSValue const &obj) {
   return static_cast<T>(obj.AsInt64());
 }
 

package/Microsoft.ReactNative/Utils/PropertyUtils.h

@@ -149,10 +149,10 @@ bool TryUpdateForeground(
       }
     } else if (propertyValue.IsNull()) {
       element.ClearValue(T::ForegroundProperty());
-      UpdateControlForegroundResourceBrushes(element, nullptr);
       if (uielement) {
         uielement.HighContrastAdjustment(xaml::ElementHighContrastAdjustment::Application);
       }
+      UpdateControlForegroundResourceBrushes(element, nullptr);
     }
 
     return true;

package/Microsoft.ReactNative/Utils/TransformableText.h

@@ -24,7 +24,7 @@ struct TransformableText final {
         dwMapFlags |= LCMAP_TITLECASE;
         break;
       default:
-        nyi();
+        assert(false);
         return originalText;
     }
 

package/Microsoft.ReactNative/Utils/ValueUtils.cpp

@@ -133,7 +133,6 @@ struct BrushCache {
 
     assert(false && "Resource is not a Color or Brush");
     return xaml::Media::SolidColorBrush(winrt::Colors::Transparent());
-    ;
   }
 
   xaml::Media::Brush RegisterBrush(winrt::hstring resourceName, const xaml::Media::Brush &brush) {

package/Microsoft.ReactNative/Views/DynamicAutomationPeer.cpp

@@ -312,13 +312,15 @@ winrt::hstring DynamicAutomationPeer::GetContentName() const {
 
   try {
     if (auto const &viewControl = Owner().try_as<winrt::Microsoft::ReactNative::ViewControl>()) {
-      auto viewPanel = viewControl.GetPanel();
-
-      for (auto const &child : viewPanel.Children()) {
-        if (auto const &textBlock = child.try_as<winrt::TextBlock>()) {
-          name = name.empty() ? textBlock.Text() : (L" " + name + textBlock.Text());
-        } else if (auto const &stringableName = child.try_as<winrt::IStringable>()) {
-          name = (name.empty() ? L"" : L" ") + name + stringableName.ToString();
+      // It's possible that the ViewPanel is null, perhaps when this is invoked around the same time
+      // that a View is being unmounted, causing a fast fail for EXCEPTION_ACCESS_VIOLATION_READ.
+      if (auto viewPanel = viewControl.GetPanel()) {
+        for (auto const &child : viewPanel.Children()) {
+          if (auto const &textBlock = child.try_as<winrt::TextBlock>()) {
+            name = name.empty() ? textBlock.Text() : (L" " + name + textBlock.Text());
+          } else if (auto const &stringableName = child.try_as<winrt::IStringable>()) {
+            name = (name.empty() ? L"" : L" ") + name + stringableName.ToString();
+          }
         }
       }
     }

package/Microsoft.ReactNative/Views/DynamicAutomationProperties.cpp

@@ -179,7 +179,7 @@ xaml::DependencyProperty DynamicAutomationProperties::AccessibilityValueMinPrope
       L"AccessibilityValueMin",
       winrt::xaml_typename<double>(),
       dynamicAutomationTypeName,
-      winrt::PropertyMetadata(winrt::box_value(0)));
+      winrt::PropertyMetadata(winrt::box_value(0.0)));
 
   return s_AccessibilityValueMinProperty;
 }
@@ -197,7 +197,7 @@ xaml::DependencyProperty DynamicAutomationProperties::AccessibilityValueMaxPrope
       L"AccessibilityValueMax",
       winrt::xaml_typename<double>(),
       dynamicAutomationTypeName,
-      winrt::PropertyMetadata(winrt::box_value(0)));
+      winrt::PropertyMetadata(winrt::box_value(0.0)));
 
   return s_AccessibilityValueMaxProperty;
 }
@@ -215,7 +215,7 @@ xaml::DependencyProperty DynamicAutomationProperties::AccessibilityValueNowPrope
       L"AccessibilityValueNow",
       winrt::xaml_typename<double>(),
       dynamicAutomationTypeName,
-      winrt::PropertyMetadata(winrt::box_value(0)));
+      winrt::PropertyMetadata(winrt::box_value(0.0)));
 
   return s_AccessibilityValueNowProperty;
 }

package/Microsoft.ReactNative/Views/FlyoutViewManager.cpp

@@ -122,6 +122,7 @@ class FlyoutShadowNode : public ShadowNodeBase {
   winrt::Popup GetFlyoutParentPopup() const;
   winrt::FlyoutPresenter GetFlyoutPresenter() const;
   void OnShowFlyout();
+  void LogErrorAndClose(const string &error);
   xaml::FrameworkElement m_targetElement = nullptr;
   winrt::Flyout m_flyout = nullptr;
   bool m_isLightDismissEnabled = true;
@@ -404,7 +405,13 @@ winrt::Flyout FlyoutShadowNode::GetFlyout() {
 void FlyoutShadowNode::OnShowFlyout() {
   AdjustDefaultFlyoutStyle(50000, 50000);
   if (m_isFlyoutShowOptionsSupported) {
-    m_flyout.ShowAt(m_targetElement, m_showOptions);
+    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()) {
+      LogErrorAndClose("The target view window lost focus before flyout could be shown.");
+    } else {
+      m_flyout.ShowAt(m_targetElement, m_showOptions);
+    }
   } else {
     winrt::FlyoutBase::ShowAttachedFlyout(m_targetElement);
   }
@@ -414,6 +421,11 @@ void FlyoutShadowNode::OnShowFlyout() {
   }
 }
 
+void FlyoutShadowNode::LogErrorAndClose(const std::string &error) {
+  GetViewManager()->GetReactContext().CallJSFunction("RCTLog", "logToConsole", folly::dynamic::array("error", error));
+  OnFlyoutClosed(GetViewManager()->GetReactContext(), m_tag, false);
+}
+
 void FlyoutShadowNode::SetTargetFrameworkElement() {
   if (m_targetTag > 0) {
     if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {

package/Microsoft.ReactNative/Views/FrameworkElementTransferProperties.cpp

@@ -17,7 +17,7 @@ void TransferProperty(
     xaml::DependencyProperty oldViewDP,
     xaml::DependencyProperty newViewDP) {
   auto oldValue = oldView.ReadLocalValue(oldViewDP);
-  if (oldValue != nullptr) {
+  if (oldValue != xaml::DependencyProperty::UnsetValue()) {
     oldView.ClearValue(oldViewDP);
     newView.SetValue(newViewDP, oldValue);
   }

package/Microsoft.ReactNative/Views/FrameworkElementViewManager.cpp

@@ -93,8 +93,8 @@ static void GetAccessibilityStateProps(const winrt::Microsoft::ReactNative::IJSV
 
 static void GetAccessibilityValueProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) {
   writer.WriteObjectBegin();
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"min", L"boolean");
-  winrt::Microsoft::ReactNative::WriteProperty(writer, L"max", L"boolean");
+  winrt::Microsoft::ReactNative::WriteProperty(writer, L"min", L"number");
+  winrt::Microsoft::ReactNative::WriteProperty(writer, L"max", L"number");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"now", L"number");
   winrt::Microsoft::ReactNative::WriteProperty(writer, L"text", L"string");
   writer.WriteObjectEnd();
@@ -235,12 +235,12 @@ bool FrameworkElementViewManager::UpdateProperty(
                 MultiplyInto(
                     transformMatrix,
                     winrt::Windows::Foundation::Numerics::float4x4(
-                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(innerValue.AsSingle(), 0.f)));
+                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(ToRadians(innerValue), 0.f)));
               } else if (transformType == "skewY") {
                 MultiplyInto(
                     transformMatrix,
                     winrt::Windows::Foundation::Numerics::float4x4(
-                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(0.f, innerValue.AsSingle())));
+                        winrt::Windows::Foundation::Numerics::make_float3x2_skew(0.f, ToRadians(innerValue))));
               }
             }
           }
@@ -526,29 +526,79 @@ bool FrameworkElementViewManager::UpdateProperty(
       DynamicAutomationProperties::SetAccessibilityStateCollapsed(
           element, states[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityStates::Collapsed)]);
     } else if (propertyName == "accessibilityValue") {
+      winrt::hstring textValue;
+      const int numericValuesCount = 3;
+      double numericValues[numericValuesCount] = {};
+
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Object) {
         for (const auto &pair : propertyValue.AsObject()) {
           const std::string &innerName = pair.first;
           const auto &innerValue = pair.second;
 
+          auto peer = xaml::Automation::Peers::FrameworkElementAutomationPeer::FromElement(element);
+
           if (innerName == "min" &&
               (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
                innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
-            DynamicAutomationProperties::SetAccessibilityValueMin(element, innerValue.AsDouble());
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Min)] =
+                innerValue.AsDouble();
+
+            const auto prevMinValue = DynamicAutomationProperties::GetAccessibilityValueMin(element);
+            if (peer != nullptr && prevMinValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::MinimumProperty(),
+                  winrt::box_value(prevMinValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (
-              innerName == "max" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-              innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-            DynamicAutomationProperties::SetAccessibilityValueMax(element, innerValue.AsDouble());
+              innerName == "max" &&
+              (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
+               innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Max)] =
+                innerValue.AsDouble();
+
+            const auto prevMaxValue = DynamicAutomationProperties::GetAccessibilityValueMax(element);
+            if (peer != nullptr && prevMaxValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::MaximumProperty(),
+                  winrt::box_value(prevMaxValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (
-              innerName == "now" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-              innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-            DynamicAutomationProperties::SetAccessibilityValueNow(element, innerValue.AsDouble());
+              innerName == "now" &&
+              (innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
+               innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64)) {
+            numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Now)] =
+                innerValue.AsDouble();
+
+            const auto prevNowValue = DynamicAutomationProperties::GetAccessibilityValueNow(element);
+            if (peer != nullptr && prevNowValue != innerValue.AsDouble()) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::RangeValuePatternIdentifiers::ValueProperty(),
+                  winrt::box_value(prevNowValue),
+                  winrt::box_value(innerValue.AsDouble()));
+            }
           } else if (innerName == "text" && innerValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
-            auto value = asHstring(innerValue);
-            DynamicAutomationProperties::SetAccessibilityValueText(element, value);
+            textValue = asHstring(innerValue);
+
+            const auto prevTextValue = DynamicAutomationProperties::GetAccessibilityValueText(element);
+            if (peer != nullptr && prevTextValue != textValue) {
+              peer.RaisePropertyChangedEvent(
+                  winrt::ValuePatternIdentifiers::ValueProperty(),
+                  winrt::box_value(prevTextValue),
+                  winrt::box_value(textValue));
+            }
           }
         }
       }
+
+      DynamicAutomationProperties::SetAccessibilityValueMin(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Min)]);
+      DynamicAutomationProperties::SetAccessibilityValueMax(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Max)]);
+      DynamicAutomationProperties::SetAccessibilityValueNow(
+          element, numericValues[static_cast<int32_t>(winrt::Microsoft::ReactNative::AccessibilityValue::Now)]);
+      DynamicAutomationProperties::SetAccessibilityValueText(element, textValue);
     } else if (propertyName == "testID") {
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
         auto value = asHstring(propertyValue);

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

@@ -14,8 +14,8 @@
 #include <IReactInstance.h>
 #include <Utils/PropertyHandlerUtils.h>
 #include <Utils/PropertyUtils.h>
+#include <Views/DynamicAutomationProperties.h>
 #include <Views/ShadowNodeBase.h>
-#include "DynamicAutomationProperties.h"
 #include "ReactImage.h"
 
 namespace winrt {

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

@@ -13,7 +13,7 @@
 #include <winrt/Windows.Web.Http.h>
 
 #include <Utils/ValueUtils.h>
-#include "DynamicAutomationPeer.h"
+#include <Views/DynamicAutomationPeer.h>
 #include "Unicode.h"
 #include "XamlView.h"
 #include "cdebug.h"
@@ -171,8 +171,7 @@ void ReactImage::Source(ReactImageSource source) {
   }
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> ReactImage::GetImageMemoryStreamAsync(
-    ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> ReactImage::GetImageMemoryStreamAsync(ReactImageSource source) {
   switch (source.sourceType) {
     case ImageSourceType::Download:
       co_return co_await GetImageStreamAsync(source);
@@ -223,7 +222,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   const bool fromStream{
       source.sourceType == ImageSourceType::Download || source.sourceType == ImageSourceType::InlineData};
 
-  winrt::InMemoryRandomAccessStream memoryStream{nullptr};
+  winrt::IRandomAccessStream memoryStream{nullptr};
 
   // get weak reference before any co_await calls
   auto weak_this{get_weak()};
@@ -443,7 +442,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
   }
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
   try {
     co_await winrt::resume_background();
 
@@ -480,7 +479,7 @@ winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageStreamAsync(Re
   co_return nullptr;
 }
 
-winrt::IAsyncOperation<winrt::InMemoryRandomAccessStream> GetImageInlineDataAsync(ReactImageSource source) {
+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;

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

@@ -69,7 +69,7 @@ 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::InMemoryRandomAccessStream>
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
   GetImageMemoryStreamAsync(ReactImageSource source);
   winrt::fire_and_forget SetBackground(bool fireLoadEndEvent);
 
@@ -91,8 +91,8 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
 };
 
 // Helper functions
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::InMemoryRandomAccessStream>
-GetImageStreamAsync(ReactImageSource source);
-winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::InMemoryRandomAccessStream>
+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/Text/TextTransformParentVisitor.h

@@ -12,7 +12,7 @@ class TextTransformParentVisitor : public TextParentVisitor {
   using Super = TextParentVisitor;
 
  public:
-  TextTransform textTransform;
+  TextTransform textTransform{TextTransform::Undefined};
 
  protected:
   void VisitText(ShadowNodeBase *node) override;

package/Microsoft.ReactNative/Views/TextInputViewManager.cpp

@@ -513,6 +513,13 @@ void TextInputShadowNode::updateProperties(winrt::Microsoft::ReactNative::JSValu
         m_hideCaret = propertyValue.AsBoolean();
         HideCaretIfNeeded();
       }
+    } else if (propertyName == "focusable") {
+      // parent class also sets isTabStop
+      if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
+        control.IsEnabled(propertyValue.AsBoolean());
+      } else if (propertyValue.IsNull()) {
+        control.ClearValue(xaml::Controls::Control::IsEnabledProperty());
+      }
     } else if (propertyName == "secureTextEntry") {
       markDirty = true;
       if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
@@ -887,7 +894,13 @@ void TextInputViewManager::TransferProperties(const XamlView &oldView, const Xam
           xaml::Controls::TextBox::SelectionHighlightColorProperty(),
           xaml::Controls::PasswordBox::SelectionHighlightColorProperty());
       newView.as<xaml::Controls::PasswordBox>().Password(oldView.as<xaml::Controls::TextBox>().Text());
-      newView.as<xaml::Controls::PasswordBox>().IsEnabled(!oldView.as<xaml::Controls::TextBox>().IsReadOnly());
+      // Since both focasable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
+      // check isReadOnly
+      if (oldView.as<xaml::Controls::TextBox>().IsEnabled()) {
+        newView.as<xaml::Controls::PasswordBox>().IsEnabled(!oldView.as<xaml::Controls::TextBox>().IsReadOnly());
+      } else {
+        newView.as<xaml::Controls::PasswordBox>().IsEnabled(oldView.as<xaml::Controls::TextBox>().IsEnabled());
+      }
     } else {
       TransferProperty(
           oldView,
@@ -905,7 +918,13 @@ void TextInputViewManager::TransferProperties(const XamlView &oldView, const Xam
           xaml::Controls::PasswordBox::SelectionHighlightColorProperty(),
           xaml::Controls::TextBox::SelectionHighlightColorProperty());
       newView.as<xaml::Controls::TextBox>().Text(oldView.as<xaml::Controls::PasswordBox>().Password());
-      newView.as<xaml::Controls::TextBox>().IsReadOnly(!oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      // Since both focasable/editable affect isEnabled for PasswordBox, if the oldView is enabled we still need to
+      // check isReadOnly
+      if (oldView.as<xaml::Controls::PasswordBox>().IsEnabled()) {
+        newView.as<xaml::Controls::TextBox>().IsReadOnly(!oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      } else {
+        newView.as<xaml::Controls::TextBox>().IsEnabled(oldView.as<xaml::Controls::PasswordBox>().IsEnabled());
+      }
     }
 
     TransferInputScope(oldView, newView, copyToPasswordBox);

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -67,7 +67,8 @@ class TextShadowNode final : public ShadowNodeBase {
     }
 
     auto addInline = true;
-    if (index == 0) {
+    // Only convert to fast text when exactly one child is attached to the root Text node
+    if (index == 0 && m_children.size() == 1) {
       auto run = childNode.GetView().try_as<winrt::Run>();
       if (run != nullptr) {
         m_firstChildNode = &child;
@@ -75,7 +76,8 @@ class TextShadowNode final : public ShadowNodeBase {
         textBlock.Text(run.Text());
         addInline = false;
       }
-    } else if (index == 1 && m_firstChildNode != nullptr) {
+    } else if (m_firstChildNode != nullptr) {
+      assert(m_children.size() == 2);
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
       Super::AddView(*m_firstChildNode, 0);
@@ -101,7 +103,8 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
-    if (indexToRemove == 0 && m_firstChildNode) {
+    if (m_firstChildNode) {
+      assert(indexToRemove == 0);
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
       m_firstChildNode = nullptr;

package/Microsoft.ReactNative/Views/TouchEventHandler.cpp

@@ -240,7 +240,7 @@ TouchEventHandler::ReactPointer TouchEventHandler::CreateReactPointer(
   auto point = args.GetCurrentPoint(sourceElement);
   auto props = point.Properties();
 
-  ReactPointer pointer;
+  ReactPointer pointer{};
   pointer.target = tag;
   pointer.identifier = m_touchId++;
   pointer.pointerId = point.PointerId();

package/Microsoft.ReactNative/Views/ViewManagerBase.cpp

@@ -19,11 +19,14 @@
 #include <Utils/PropertyUtils.h>
 #include <Views/ExpressionAnimationStore.h>
 #include <Views/ShadowNodeBase.h>
+#include <cxxreact/SystraceSection.h>
 
 namespace winrt {
 using namespace xaml;
 }
 
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 static const std::unordered_map<std::string, PointerEventsKind> pointerEventsMap = {
@@ -248,7 +251,10 @@ void ViewManagerBase::UpdateProperties(
     }
   }
 
-  OnPropertiesUpdated(nodeToUpdate);
+  {
+    SystraceSection s("ViewManagerBase::OnPropertiesUpdated");
+    OnPropertiesUpdated(nodeToUpdate);
+  }
 }
 
 bool ViewManagerBase::UpdateProperty(

package/Microsoft.ReactNative/Views/ViewPanel.cpp

@@ -9,6 +9,7 @@
 #include <UI.Xaml.Media.h>
 #include <Utils/PropertyUtils.h>
 #include <Utils/ResourceBrushUtils.h>
+#include <cxxreact/SystraceSection.h>
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.UI.Xaml.Interop.h>
 
@@ -28,6 +29,8 @@ using namespace xaml::Media;
 using namespace Windows::Foundation;
 } // namespace winrt
 
+using namespace facebook::react;
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 const winrt::TypeName viewPanelTypeName{winrt::hstring{L"ViewPanel"}, winrt::TypeKind::Metadata};
@@ -227,6 +230,7 @@ void ViewPanel::ClipChildren(bool value) {
 }
 
 void ViewPanel::FinalizeProperties() {
+  SystraceSection s("ViewPanel::FinalizeProperties");
   if (!m_propertiesChanged)
     return;