react-native-windows 0.78.4 → 0.78.6

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

@@ -180,6 +180,16 @@ void UpdateUiaProperty(
       spProviderSimple.get(), propId, CComVariant(oldValue.c_str()), CComVariant(newValue.c_str()));
 }
 
+void UpdateUiaProperty(
+    winrt::IInspectable provider,
+    PROPERTYID propId,
+    const std::optional<std::string> &oldValue,
+    const std::optional<std::string> &newValue) noexcept {
+  std::string oldData = oldValue.value_or("");
+  std::string newData = newValue.value_or("");
+  UpdateUiaProperty(provider, propId, oldData, newData);
+}
+
 long GetLiveSetting(const std::string &liveRegion) noexcept {
   if (liveRegion == "polite") {
     return LiveSetting::Polite;
@@ -189,6 +199,64 @@ long GetLiveSetting(const std::string &liveRegion) noexcept {
   return LiveSetting::Off;
 }
 
+long GetAnnotationTypeId(const std::string &annotationType) noexcept {
+  if (annotationType == "Author") {
+    return AnnotationType_Author;
+  } else if (annotationType == "CircularReferenceError") {
+    return AnnotationType_CircularReferenceError;
+  } else if (annotationType == "Comment") {
+    return AnnotationType_Comment;
+  } else if (annotationType == "ConflictingChange") {
+    return AnnotationType_ConflictingChange;
+  } else if (annotationType == "DataValidationError") {
+    return AnnotationType_DataValidationError;
+  } else if (annotationType == "DeletionChange") {
+    return AnnotationType_DeletionChange;
+  } else if (annotationType == "EditingLockedChange") {
+    return AnnotationType_EditingLockedChange;
+  } else if (annotationType == "Endnote") {
+    return AnnotationType_Endnote;
+  } else if (annotationType == "ExternalChange") {
+    return AnnotationType_ExternalChange;
+  } else if (annotationType == "Footer") {
+    return AnnotationType_Footer;
+  } else if (annotationType == "Footnote") {
+    return AnnotationType_Footnote;
+  } else if (annotationType == "FormatChange") {
+    return AnnotationType_FormatChange;
+  } else if (annotationType == "FormulaError") {
+    return AnnotationType_FormulaError;
+  } else if (annotationType == "GrammarError") {
+    return AnnotationType_GrammarError;
+  } else if (annotationType == "Header") {
+    return AnnotationType_Header;
+  } else if (annotationType == "Highlighted") {
+    return AnnotationType_Highlighted;
+  } else if (annotationType == "InsertionChange") {
+    return AnnotationType_InsertionChange;
+  } else if (annotationType == "Mathematics") {
+    return AnnotationType_Mathematics;
+  } else if (annotationType == "MoveChange") {
+    return AnnotationType_MoveChange;
+  } else if (annotationType == "SpellingError") {
+    return AnnotationType_SpellingError;
+  } else if (annotationType == "TrackChanges") {
+    return AnnotationType_TrackChanges;
+  } else if (annotationType == "AdvanceProofingIssue") {
+    return AnnotationType_AdvancedProofingIssue;
+  } else if (annotationType == "UnsyncedChange") {
+    return AnnotationType_UnsyncedChange;
+  }
+  return AnnotationType_Unknown;
+}
+
+bool accessibilityAnnotationHasValue(
+    const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept {
+  return annotation.has_value() &&
+      !(annotation.value().typeID.empty() && annotation.value().typeName.empty() && annotation.value().author.empty() &&
+        annotation.value().dateTime.empty() && annotation.value().target.empty());
+}
+
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept {
   auto strongView = view.view();
 

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

@@ -31,8 +31,19 @@ void UpdateUiaProperty(
     const std::string &oldValue,
     const std::string &newValue) noexcept;
 
+void UpdateUiaProperty(
+    winrt::IInspectable provider,
+    PROPERTYID propId,
+    const std::optional<std::string> &oldValue,
+    const std::optional<std::string> &newValue) noexcept;
+
 long GetLiveSetting(const std::string &liveRegion) noexcept;
 
+long GetAnnotationTypeId(const std::string &annotationType) noexcept;
+
+bool accessibilityAnnotationHasValue(
+    const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept;
+
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -19,7 +19,6 @@
 #include <JSI/jsi.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <SchedulerSettings.h>
-#include <SynchronousEventBeat.h>
 #include <UI.Xaml.Controls.h>
 #include <react/components/rnwcore/ComponentDescriptors.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
@@ -47,7 +46,10 @@ FabicUIManagerProperty() noexcept {
 
 /*static*/ std::shared_ptr<FabricUIManager> FabricUIManager::FromProperties(
     const winrt::Microsoft::ReactNative::ReactPropertyBag &props) {
-  return props.Get(FabicUIManagerProperty()).Value();
+  auto p = props.Get(FabicUIManagerProperty());
+  if (p)
+    return p.Value();
+  return {};
 }
 
 FabricUIManager::FabricUIManager() {}
@@ -107,7 +109,6 @@ void FabricUIManager::installFabricUIManager() noexcept {
 
   m_scheduler = std::make_shared<facebook::react::Scheduler>(
       toolbox, (/*animationDriver_ ? animationDriver_.get() :*/ nullptr), this);
-  m_surfaceManager = std::make_shared<facebook::react::SurfaceManager>(*m_scheduler);
 }
 
 const IComponentViewRegistry &FabricUIManager::GetViewRegistry() const noexcept {
@@ -135,17 +136,38 @@ void FabricUIManager::startSurface(
   layoutContext.pointScaleFactor = rootView.ScaleFactor();
   layoutContext.fontSizeMultiplier = rootView.FontSizeMultiplier();
 
-  m_surfaceManager->startSurface(
-      surfaceId,
-      moduleName,
-      initialProps,
-      layoutConstraints,
-      layoutContext // layout context
-  );
+  {
+    std::unique_lock lock(m_handlerMutex);
+    auto surfaceHandler = facebook::react::SurfaceHandler{moduleName, surfaceId};
+    surfaceHandler.setContextContainer(m_scheduler->getContextContainer());
+    m_handlerRegistry.emplace(surfaceId, std::move(surfaceHandler));
+  }
+
+  visit(surfaceId, [&](const facebook::react::SurfaceHandler &surfaceHandler) {
+    surfaceHandler.setProps(initialProps);
+    surfaceHandler.constraintLayout(layoutConstraints, layoutContext);
+    m_scheduler->registerSurface(surfaceHandler);
+    surfaceHandler.start();
+  });
+}
+
+void FabricUIManager::setProps(facebook::react::SurfaceId surfaceId, const folly::dynamic &props) const noexcept {
+  visit(surfaceId, [=](const facebook::react::SurfaceHandler &surfaceHandler) { surfaceHandler.setProps(props); });
 }
 
 void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept {
-  m_surfaceManager->stopSurface(surfaceId);
+  visit(surfaceId, [&](const facebook::react::SurfaceHandler &surfaceHandler) {
+    surfaceHandler.stop();
+    m_scheduler->unregisterSurface(surfaceHandler);
+  });
+
+  {
+    std::unique_lock lock(m_handlerMutex);
+
+    auto iterator = m_handlerRegistry.find(surfaceId);
+    m_handlerRegistry.erase(iterator);
+  }
+
   auto &rootDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);
   rootDescriptor.view.as<winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView>()->stop();
   m_registry.enqueueComponentViewWithComponentHandle(
@@ -156,14 +178,36 @@ facebook::react::Size FabricUIManager::measureSurface(
     facebook::react::SurfaceId surfaceId,
     const facebook::react::LayoutConstraints &layoutConstraints,
     const facebook::react::LayoutContext &layoutContext) const noexcept {
-  return m_surfaceManager->measureSurface(surfaceId, layoutConstraints, layoutContext);
+  auto size = facebook::react::Size{};
+
+  visit(surfaceId, [&](const facebook::react::SurfaceHandler &surfaceHandler) {
+    size = surfaceHandler.measure(layoutConstraints, layoutContext);
+  });
+
+  return size;
 }
 
 void FabricUIManager::constraintSurfaceLayout(
     facebook::react::SurfaceId surfaceId,
     const facebook::react::LayoutConstraints &layoutConstraints,
     const facebook::react::LayoutContext &layoutContext) const noexcept {
-  m_surfaceManager->constraintSurfaceLayout(surfaceId, layoutConstraints, layoutContext);
+  visit(surfaceId, [=](const facebook::react::SurfaceHandler &surfaceHandler) {
+    surfaceHandler.constraintLayout(layoutConstraints, layoutContext);
+  });
+}
+
+void FabricUIManager::visit(
+    facebook::react::SurfaceId surfaceId,
+    const std::function<void(const facebook::react::SurfaceHandler &surfaceHandler)> &callback) const noexcept {
+  std::shared_lock lock(m_handlerMutex);
+
+  auto iterator = m_handlerRegistry.find(surfaceId);
+
+  if (iterator == m_handlerRegistry.end()) {
+    return;
+  }
+
+  callback(iterator->second);
 }
 
 winrt::Microsoft::ReactNative::ReactNotificationId<facebook::react::SurfaceId>
@@ -429,6 +473,19 @@ void FabricUIManager::Initialize(winrt::Microsoft::ReactNative::ReactContext con
 
   m_context.Properties().Set(FabicUIManagerProperty(), shared_from_this());
 
+  auto destroyInstanceNotificationId{
+      winrt::Microsoft::ReactNative::ReactNotificationId<winrt::Microsoft::ReactNative::InstanceDestroyedEventArgs>{
+          L"ReactNative.InstanceSettings", L"InstanceDestroyed"}};
+  reactContext.Notifications().Subscribe(
+      destroyInstanceNotificationId,
+      [reactContext](
+          winrt::Windows::Foundation::IInspectable const & /*sender*/,
+          winrt::Microsoft::ReactNative::ReactNotificationArgs<
+              winrt::Microsoft::ReactNative::InstanceDestroyedEventArgs> const &args) noexcept {
+        reactContext.Properties().Remove(FabicUIManagerProperty());
+        args.Subscription().Unsubscribe(); // Unsubscribe after we handle the notification.
+      });
+
   /*
   EventBeatManager eventBeatManager = new EventBeatManager(mReactApplicationContext);
   UIManagerModule nativeModule =

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -6,13 +6,13 @@
 #include <NativeModules.h>
 #include <React.h>
 #include <react/renderer/scheduler/SchedulerDelegate.h>
-#include <react/renderer/scheduler/SurfaceManager.h>
 #include <winrt/Windows.UI.Composition.h>
 #include "Composition/ComponentViewRegistry.h"
 
 namespace facebook::react {
 class Scheduler;
 class ReactNativeConfig;
+class SurfaceHandler;
 } // namespace facebook::react
 
 namespace Microsoft::ReactNative {
@@ -47,6 +47,8 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
       const facebook::react::LayoutConstraints &layoutConstraints,
       const facebook::react::LayoutContext &layoutContext) const noexcept;
 
+  void setProps(facebook::react::SurfaceId surfaceId, const folly::dynamic &props) const noexcept;
+
   const IComponentViewRegistry &GetViewRegistry() const noexcept;
 
   static winrt::Microsoft::ReactNative::ReactNotificationId<facebook::react::SurfaceId> NotifyMountedId() noexcept;
@@ -62,10 +64,13 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
       facebook::react::SurfaceId surfaceId);
   void didMountComponentsWithRootTag(facebook::react::SurfaceId surfaceId) noexcept;
 
+  void visit(
+      facebook::react::SurfaceId surfaceId,
+      const std::function<void(const facebook::react::SurfaceHandler &surfaceHandler)> &callback) const noexcept;
+
   winrt::Microsoft::ReactNative::ReactContext m_context;
   winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext m_compContext;
   std::shared_ptr<facebook::react::Scheduler> m_scheduler;
-  std::shared_ptr<facebook::react::SurfaceManager> m_surfaceManager;
   std::mutex m_schedulerMutex; // Protect m_scheduler
   bool m_transactionInFlight{false};
   bool m_followUpTransactionRequired{false};
@@ -77,6 +82,9 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
 
   std::unordered_map<facebook::react::SurfaceId, SurfaceInfo> m_surfaceRegistry;
 
+  std::unordered_map<facebook::react::SurfaceId, facebook::react::SurfaceHandler> m_handlerRegistry{};
+  mutable std::shared_mutex m_handlerMutex;
+
   // Inherited via SchedulerDelegate
   virtual void schedulerDidFinishTransaction(
       const std::shared_ptr<const facebook::react::MountingCoordinator> &mountingCoordinator) override;

package/Microsoft.ReactNative/Fabric/ImageManager.cpp

@@ -24,11 +24,11 @@ ImageRequest ImageManager::requestImage(const ImageSource &imageSource, SurfaceI
 
 ImageRequest ImageManager::requestImage(
     const ImageSource &imageSource,
-    SurfaceId /*surfaceId*/,
-    const ImageRequestParams & /*imageRequestParams*/,
-    Tag /*tag*/) const {
-  // Not implemented.
-  return {imageSource, nullptr, {}};
+    SurfaceId surfaceId,
+    const ImageRequestParams &imageRequestParams,
+    Tag tag) const {
+  return ((Microsoft::ReactNative::WindowsImageManager *)self_)
+      ->requestImage(imageSource, surfaceId, imageRequestParams, tag);
 }
 
 } // namespace react

package/Microsoft.ReactNative/Fabric/ImageRequestParams.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/graphics/Float.h>
+
+namespace facebook::react {
+
+class ImageRequestParams {
+ public:
+  ImageRequestParams() = default;
+  explicit ImageRequestParams(Float blurRadius) : blurRadius(blurRadius) {}
+
+  Float blurRadius{};
+
+  bool operator==(const ImageRequestParams &rhs) const {
+    return this->blurRadius == rhs.blurRadius;
+  }
+
+  bool operator!=(const ImageRequestParams &rhs) const {
+    return !(*this == rhs);
+  }
+};
+
+} // namespace facebook::react

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -78,7 +78,9 @@ wicBitmapSourceFromStream(const winrt::Windows::Storage::Streams::IRandomAccessS
 }
 
 winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
-WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) const {
+WindowsImageManager::GetImageRandomAccessStreamAsync(
+    ReactImageSource source,
+    std::function<void(uint64_t loaded, uint64_t total)> progressCallback) const {
   co_await winrt::resume_background();
 
   winrt::Windows::Foundation::Uri uri(winrt::to_hstring(source.uri));
@@ -123,6 +125,12 @@ WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) co
     }
   }
 
+  if (!source.body.empty()) {
+    auto bodyContent = winrt::Windows::Web::Http::HttpStringContent(
+        winrt::to_hstring(source.body), winrt::Windows::Storage::Streams::UnicodeEncoding::Utf8, L"application/json");
+    request.Content(bodyContent);
+  }
+
   winrt::Windows::Web::Http::HttpResponseMessage response(co_await m_httpClient.SendRequestAsync(request));
 
   if (!response.IsSuccessStatusCode()) {
@@ -130,8 +138,29 @@ WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) co
         response.ReasonPhrase(), response.StatusCode(), response.Headers());
   }
 
+  auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
+  auto contentLengthRef = response.Content().Headers().ContentLength();
+  uint64_t total = contentLengthRef ? contentLengthRef.GetUInt64() : 0;
+  uint64_t loaded = 0;
+
   winrt::Windows::Storage::Streams::InMemoryRandomAccessStream memoryStream;
-  co_await response.Content().WriteToStreamAsync(memoryStream);
+  winrt::Windows::Storage::Streams::DataReader reader(inputStream);
+  constexpr uint32_t bufferSize = 16 * 1024;
+
+  while (true) {
+    uint32_t loadedBuffer = co_await reader.LoadAsync(bufferSize);
+    if (loadedBuffer == 0)
+      break;
+
+    auto buffer = reader.ReadBuffer(loadedBuffer);
+    co_await memoryStream.WriteAsync(buffer);
+    loaded += loadedBuffer;
+
+    if (progressCallback) {
+      progressCallback(loaded, total);
+    }
+  }
+
   memoryStream.Seek(0);
 
   co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(memoryStream.CloneStream());
@@ -159,8 +188,15 @@ facebook::react::ImageRequest WindowsImageManager::requestImage(
     source.height = imageSource.size.height;
     source.width = imageSource.size.width;
     source.sourceType = ImageSourceType::Download;
+    source.body = imageSource.body;
 
-    imageResponseTask = GetImageRandomAccessStreamAsync(source);
+    auto progressCallback = [weakObserverCoordinator](int64_t loaded, int64_t total) {
+      if (auto observerCoordinator = weakObserverCoordinator.lock()) {
+        float progress = total > 0 ? static_cast<float>(loaded) / static_cast<float>(total) : 1.0f;
+        observerCoordinator->nativeImageResponseProgress(progress, loaded, total);
+      }
+    };
+    imageResponseTask = GetImageRandomAccessStreamAsync(source, progressCallback);
   }
 
   imageResponseTask.Completed([weakObserverCoordinator](auto asyncOp, auto status) {
@@ -195,16 +231,19 @@ facebook::react::ImageRequest WindowsImageManager::requestImage(
         observerCoordinator->nativeImageResponseFailed(facebook::react::ImageLoadError(errorInfo));
         break;
       }
-      case winrt::Windows::Foundation::AsyncStatus::Started: {
-        // TODO progress? - Can we register for progress off the download task?
-        // observerCoordinator->nativeImageResponseProgress(0.0/*progress*/, 0/*completed*/, 0/*total*/);
-        break;
-      }
     }
   });
   return imageRequest;
 }
 
+facebook::react::ImageRequest WindowsImageManager::requestImage(
+    const facebook::react::ImageSource &imageSource,
+    facebook::react::SurfaceId surfaceId,
+    const facebook::react::ImageRequestParams & /* imageRequestParams */,
+    facebook::react::Tag /* tag */) const {
+  return requestImage(imageSource, surfaceId);
+}
+
 } // namespace Microsoft::ReactNative
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {

package/Microsoft.ReactNative/Fabric/WindowsImageManager.h

@@ -4,6 +4,7 @@
 #include "pch.h"
 
 #include <react/renderer/imagemanager/ImageRequest.h>
+#include <react/renderer/imagemanager/ImageRequestParams.h>
 
 #include <Fabric/Composition/UriImageManager.h>
 #include <ReactContext.h>
@@ -20,9 +21,17 @@ struct WindowsImageManager {
       const facebook::react::ImageSource &imageSource,
       facebook::react::SurfaceId surfaceId) const;
 
+  facebook::react::ImageRequest requestImage(
+      const facebook::react::ImageSource &imageSource,
+      facebook::react::SurfaceId surfaceId,
+      const facebook::react::ImageRequestParams & /* imageRequestParams */,
+      facebook::react::Tag /* tag */) const;
+
  private:
   winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
-  GetImageRandomAccessStreamAsync(ReactImageSource source) const;
+  GetImageRandomAccessStreamAsync(
+      ReactImageSource source,
+      std::function<void(uint64_t loaded, uint64_t total)> progressCallback) const;
 
   winrt::Windows::Web::Http::HttpClient m_httpClient;
   winrt::Microsoft::ReactNative::ReactContext m_reactContext;

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

@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include <optional>
+#include <unordered_map>
+
+namespace facebook::react {
+struct AccessibilityAnnotation {
+  std::string typeID{};
+  std::string typeName{};
+  std::string author{};
+  std::string dateTime{};
+  std::string target{};
+};
+
+constexpr bool operator==(const AccessibilityAnnotation &lhs, const AccessibilityAnnotation &rhs) {
+  return lhs.typeID == rhs.typeID && lhs.typeName == rhs.typeName && lhs.author == rhs.author &&
+      lhs.dateTime == rhs.dateTime && lhs.target == rhs.target;
+}
+
+constexpr bool operator!=(const AccessibilityAnnotation &lhs, const AccessibilityAnnotation &rhs) {
+  return !(rhs == lhs);
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, AccessibilityAnnotation &result) {
+  auto map = (std::unordered_map<std::string, RawValue>)value;
+
+  auto typeID = map.find("typeID");
+  if (typeID != map.end()) {
+    if (typeID->second.hasType<std::string>()) {
+      result.typeID = (std::string)typeID->second;
+    }
+  }
+
+  auto typeName = map.find("typeName");
+  if (typeName != map.end()) {
+    if (typeName->second.hasType<std::string>()) {
+      result.typeName = (std::string)typeName->second;
+    }
+  }
+
+  auto author = map.find("author");
+  if (author != map.end()) {
+    if (author->second.hasType<std::string>()) {
+      result.author = (std::string)author->second;
+    }
+  }
+
+  auto dateTime = map.find("dateTime");
+  if (dateTime != map.end()) {
+    if (dateTime->second.hasType<std::string>()) {
+      result.dateTime = (std::string)dateTime->second;
+    }
+  }
+
+  auto target = map.find("target");
+  if (target != map.end()) {
+    if (target->second.hasType<std::string>()) {
+      result.target = (std::string)target->second;
+    }
+  }
+}
+} // namespace facebook::react

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

@@ -38,12 +38,30 @@ void HostPlatformViewEventEmitter::onBlur() const {
 
 #pragma mark - Mouse Events
 
-void HostPlatformViewEventEmitter::onMouseEnter(PointerEvent const &pointerEvent) const {
-  dispatchEvent("mouseEnter", std::make_shared<PointerEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
+void HostPlatformViewEventEmitter::onMouseEnter(MouseEvent const &pointerEvent) const {
+  dispatchEvent("mouseEnter", std::make_shared<MouseEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
 }
 
-void HostPlatformViewEventEmitter::onMouseLeave(PointerEvent const &pointerEvent) const {
-  dispatchEvent("mouseLeave", std::make_shared<PointerEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
+void HostPlatformViewEventEmitter::onMouseLeave(MouseEvent const &pointerEvent) const {
+  dispatchEvent("mouseLeave", std::make_shared<MouseEvent>(pointerEvent), RawEvent::Category::ContinuousStart);
+}
+
+#pragma mark - Touch Events
+
+void HostPlatformViewEventEmitter::onPressIn(PressEvent event) const {
+  dispatchEvent("pressIn", [event](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    auto nativeEvent = jsi::Object(runtime);
+    nativeEvent.setProperty(runtime, "target", static_cast<double>(event.target));
+    nativeEvent.setProperty(runtime, "pageX", event.pagePoint.x);
+    nativeEvent.setProperty(runtime, "pageY", event.pagePoint.y);
+    nativeEvent.setProperty(runtime, "locationX", event.offsetPoint.x);
+    nativeEvent.setProperty(runtime, "locationY", event.offsetPoint.y);
+    nativeEvent.setProperty(runtime, "timestamp", event.timestamp);
+    nativeEvent.setProperty(runtime, "identifier", event.identifier);
+    payload.setProperty(runtime, "nativeEvent", nativeEvent);
+    return payload;
+  });
 }
 
 } // namespace facebook::react

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

@@ -5,9 +5,18 @@
 
 #include <react/renderer/components/view/BaseViewEventEmitter.h>
 #include "KeyEvent.h"
+#include "MouseEvent.h"
 
 namespace facebook::react {
 
+struct PressEvent {
+  Tag target;
+  Point pagePoint;
+  Point offsetPoint;
+  double timestamp;
+  int identifier;
+};
+
 class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
  public:
   using BaseViewEventEmitter::BaseViewEventEmitter;
@@ -24,8 +33,12 @@ class HostPlatformViewEventEmitter : public BaseViewEventEmitter {
 
 #pragma mark - Mouse Events
 
-  void onMouseEnter(PointerEvent const &pointerEvent) const;
-  void onMouseLeave(PointerEvent const &pointerEvent) const;
+  void onMouseEnter(MouseEvent const &pointerEvent) const;
+  void onMouseLeave(MouseEvent const &pointerEvent) const;
+
+#pragma mark - Touch Events
+
+  virtual void onPressIn(PressEvent event) const;
 };
 
 } // namespace facebook::react

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

@@ -20,6 +20,10 @@ HostPlatformViewProps::HostPlatformViewProps(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.windowsEvents
               : convertRawProp(context, rawProps, sourceProps.windowsEvents, {})),
+      accessibilityAnnotation(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.accessibilityAnnotation
+              : convertRawProp(context, rawProps, "accessibilityAnnotation", sourceProps.accessibilityAnnotation, {})),
       enableFocusRing(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.enableFocusRing
@@ -40,6 +44,18 @@ HostPlatformViewProps::HostPlatformViewProps(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
               ? sourceProps.accessibilitySetSize
               : convertRawProp(context, rawProps, "accessibilitySetSize", sourceProps.accessibilitySetSize, 0)),
+      accessibilityLevel(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.accessibilityLevel
+              : convertRawProp(context, rawProps, "accessibilityLevel", sourceProps.accessibilityLevel, 0)),
+      accessibilityItemType(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.accessibilityItemType
+              : convertRawProp(context, rawProps, "accessibilityItemType", sourceProps.accessibilityItemType, {})),
+      accessibilityAccessKey(
+          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
+              ? sourceProps.accessibilityAccessKey
+              : convertRawProp(context, rawProps, "accessibilityAccessKey", sourceProps.accessibilityAccessKey, {})),
       accessibilityLiveRegion(
           ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.accessibilityLiveRegion
                                                                   : convertRawProp(
@@ -81,9 +97,13 @@ void HostPlatformViewProps::setProp(
     WINDOWS_VIEW_EVENT_CASE(MouseEnter);
     WINDOWS_VIEW_EVENT_CASE(MouseLeave);
     RAW_SET_PROP_SWITCH_CASE_BASIC(enableFocusRing);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityAnnotation);
     RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityPosInSet);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilitySetSize);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLevel);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityItemType);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityAccessKey);
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLiveRegion);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);

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

@@ -5,6 +5,7 @@
 
 #include <react/renderer/components/view/BaseViewProps.h>
 #include <react/renderer/core/PropsParserContext.h>
+#include "CompositionAccessibilityProps.h"
 #include "KeyEvent.h"
 #include "WindowsViewEvents.h"
 
@@ -27,6 +28,10 @@ class HostPlatformViewProps : public BaseViewProps {
   int accessibilityPosInSet{0};
   int accessibilitySetSize{0};
   std::string accessibilityLiveRegion{"none"};
+  int accessibilityLevel{0};
+  std::optional<AccessibilityAnnotation> accessibilityAnnotation{};
+  std::optional<std::string> accessibilityItemType{};
+  std::optional<std::string> accessibilityAccessKey{};
 
   // std::optional<std::string> overflowAnchor{};
   std::optional<std::string> tooltip{};

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

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <react/renderer/components/view/PointerEvent.h>
+
+namespace facebook::react {
+
+struct MouseEvent : public PointerEvent {
+  MouseEvent(PointerEvent &event) : PointerEvent(event){};
+
+  // We override the type so that it is not recorded as a PointerType,
+  // otherwise PointerEventsProcessor gets confused by the Windows specific MouseEvents
+  EventPayloadType getType() const override {
+    return static_cast<EventPayloadType>(-1);
+  };
+};
+
+} // namespace facebook::react