react-native-windows 0.78.4 → 0.78.6

package/Microsoft.ReactNative/Base/FollyIncludes.h

@@ -24,3 +24,4 @@
 #include <folly/Optional.h>
 #include <folly/dynamic.h>
 #include <folly/json.h>
+#include <folly/json/dynamic.h>

package/Microsoft.ReactNative/CallInvoker.cpp

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "CallInvoker.h"
+
+#include "CallInvoker.g.cpp"
+#include "JsiApi.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+static const ReactPropertyId<winrt::Microsoft::ReactNative::CallInvoker> &CallInvokerPropertyId() noexcept {
+  static const ReactPropertyId<winrt::Microsoft::ReactNative::CallInvoker> prop{L"ReactNative", L"CallInvoker"};
+  return prop;
+}
+
+CallInvoker::CallInvoker(
+    Mso::React::IReactContext &reactContext,
+    std::shared_ptr<facebook::react::CallInvoker> callInvoker) noexcept
+    : m_callInvoker(callInvoker), m_context(&reactContext) {}
+
+void CallInvoker::InvokeAsync(CallFunc func) noexcept {
+  m_callInvoker->invokeAsync(
+      [reactContext = m_context, func](facebook::jsi::Runtime & /*runtime*/) { func(reactContext->JsiRuntime()); });
+}
+
+void CallInvoker::InvokeSync(CallFunc func) noexcept {
+  m_callInvoker->invokeSync(
+      [reactContext = m_context, func](facebook::jsi::Runtime & /*runtime*/) { func(reactContext->JsiRuntime()); });
+}
+
+winrt::Microsoft::ReactNative::CallInvoker CallInvoker::FromProperties(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept {
+  return properties.Get(CallInvokerPropertyId());
+}
+
+void CallInvoker::SetProperties(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    winrt::Microsoft::ReactNative::CallInvoker invoker) noexcept {
+  properties.Set(CallInvokerPropertyId(), invoker);
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/CallInvoker.h

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <ReactHost/MsoReactContext.h>
+#include <ReactPropertyBag.h>
+#include "ReactHost/React.h"
+#include "winrt/Microsoft.ReactNative.h"
+
+#include "CallInvoker.g.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+struct CallInvoker : CallInvokerT<CallInvoker> {
+  CallInvoker(
+      Mso::React::IReactContext &reactContext,
+      std::shared_ptr<facebook::react::CallInvoker> callInvoker) noexcept;
+
+  void InvokeAsync(CallFunc func) noexcept;
+  void InvokeSync(CallFunc func) noexcept;
+
+  static winrt::Microsoft::ReactNative::CallInvoker FromProperties(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept;
+  static void SetProperties(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+      winrt::Microsoft::ReactNative::CallInvoker invoker) noexcept;
+
+ private:
+  Mso::CntPtr<Mso::React::IReactContext> m_context;
+  std::shared_ptr<facebook::react::CallInvoker> m_callInvoker;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/{JSDispatcherWriter.cpp → CallInvokerWriter.cpp}

@@ -2,47 +2,33 @@
 // Licensed under the MIT License.
 
 #include "pch.h"
-#include "JSDispatcherWriter.h"
+#include "CallInvokerWriter.h"
 #include <JSI/JSIDynamic.h>
 #include <crash/verifyElseCrash.h>
 
 namespace winrt::Microsoft::ReactNative {
 
-// Special IJSValueWriter that does nothing.
-// We use it instead of JsiWriter when JSI runtime is not available anymore.
-struct JSNoopWriter : winrt::implements<JSNoopWriter, IJSValueWriter> {
- public: // IJSValueWriter
-  void WriteNull() noexcept;
-  void WriteBoolean(bool value) noexcept;
-  void WriteInt64(int64_t value) noexcept;
-  void WriteDouble(double value) noexcept;
-  void WriteString(const winrt::hstring &value) noexcept;
-  void WriteObjectBegin() noexcept;
-  void WritePropertyName(const winrt::hstring &name) noexcept;
-  void WriteObjectEnd() noexcept;
-  void WriteArrayBegin() noexcept;
-  void WriteArrayEnd() noexcept;
-};
-
 //===========================================================================
-// JSDispatcherWriter implementation
+// CallInvokerWriter implementation
 //===========================================================================
 
-JSDispatcherWriter::JSDispatcherWriter(
-    IReactDispatcher const &jsDispatcher,
+CallInvokerWriter::CallInvokerWriter(
+    const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
     std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept
-    : m_jsDispatcher(jsDispatcher), m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)) {}
+    : m_callInvoker(jsInvoker),
+      m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)),
+      m_threadId(std::this_thread::get_id()) {}
 
-JSDispatcherWriter::~JSDispatcherWriter() {
+CallInvokerWriter::~CallInvokerWriter() {
   if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
     jsiRuntimeHolder->allowRelease();
   }
 }
 
-void JSDispatcherWriter::WithResultArgs(
+void CallInvokerWriter::WithResultArgs(
     Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
         handler) noexcept {
-  if (m_jsDispatcher.HasThreadAccess()) {
+  if (m_threadId == std::this_thread::get_id() && m_fastPath) {
     VerifyElseCrash(!m_dynamicWriter);
     if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
       const facebook::jsi::Value *args{nullptr};
@@ -55,64 +41,62 @@ void JSDispatcherWriter::WithResultArgs(
     VerifyElseCrash(!m_jsiWriter);
     folly::dynamic dynValue = m_dynamicWriter->TakeValue();
     VerifyElseCrash(dynValue.isArray());
-    m_jsDispatcher.Post(
-        [handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder, self = get_strong()]() {
-          if (auto jsiRuntimeHolder = weakJsiRuntimeHolder.lock()) {
-            std::vector<facebook::jsi::Value> args;
-            args.reserve(dynValue.size());
-            auto &runtime = jsiRuntimeHolder->Runtime();
-            for (auto const &item : dynValue) {
-              args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
-            }
-            handler(runtime, args.data(), args.size());
+    m_callInvoker->invokeAsync(
+        [handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder, self = get_strong()](
+            facebook::jsi::Runtime &runtime) {
+          std::vector<facebook::jsi::Value> args;
+          args.reserve(dynValue.size());
+          for (auto const &item : dynValue) {
+            args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
           }
+          handler(runtime, args.data(), args.size());
         });
   }
 }
 
-void JSDispatcherWriter::WriteNull() noexcept {
+void CallInvokerWriter::WriteNull() noexcept {
   GetWriter().WriteNull();
 }
 
-void JSDispatcherWriter::WriteBoolean(bool value) noexcept {
+void CallInvokerWriter::WriteBoolean(bool value) noexcept {
   GetWriter().WriteBoolean(value);
 }
 
-void JSDispatcherWriter::WriteInt64(int64_t value) noexcept {
+void CallInvokerWriter::WriteInt64(int64_t value) noexcept {
   GetWriter().WriteInt64(value);
 }
 
-void JSDispatcherWriter::WriteDouble(double value) noexcept {
+void CallInvokerWriter::WriteDouble(double value) noexcept {
   GetWriter().WriteDouble(value);
 }
 
-void JSDispatcherWriter::WriteString(const winrt::hstring &value) noexcept {
+void CallInvokerWriter::WriteString(const winrt::hstring &value) noexcept {
   GetWriter().WriteString(value);
 }
 
-void JSDispatcherWriter::WriteObjectBegin() noexcept {
+void CallInvokerWriter::WriteObjectBegin() noexcept {
   GetWriter().WriteObjectBegin();
 }
 
-void JSDispatcherWriter::WritePropertyName(const winrt::hstring &name) noexcept {
+void CallInvokerWriter::WritePropertyName(const winrt::hstring &name) noexcept {
   GetWriter().WritePropertyName(name);
 }
 
-void JSDispatcherWriter::WriteObjectEnd() noexcept {
+void CallInvokerWriter::WriteObjectEnd() noexcept {
   GetWriter().WriteObjectEnd();
 }
 
-void JSDispatcherWriter::WriteArrayBegin() noexcept {
+void CallInvokerWriter::WriteArrayBegin() noexcept {
   GetWriter().WriteArrayBegin();
 }
 
-void JSDispatcherWriter::WriteArrayEnd() noexcept {
+void CallInvokerWriter::WriteArrayEnd() noexcept {
   GetWriter().WriteArrayEnd();
 }
 
-IJSValueWriter JSDispatcherWriter::GetWriter() noexcept {
+IJSValueWriter CallInvokerWriter::GetWriter() noexcept {
   if (!m_writer) {
-    if (m_jsDispatcher.HasThreadAccess()) {
+    if (m_threadId == std::this_thread::get_id() && m_fastPath) {
       if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
         m_jsiWriter = winrt::make_self<JsiWriter>(jsiRuntimeHolder->Runtime());
         m_writer = m_jsiWriter.as<IJSValueWriter>();
@@ -124,10 +108,14 @@ IJSValueWriter JSDispatcherWriter::GetWriter() noexcept {
       m_writer = m_dynamicWriter.as<IJSValueWriter>();
     }
   }
-  Debug(VerifyElseCrash(m_dynamicWriter != nullptr || m_jsDispatcher.HasThreadAccess()));
+  Debug(VerifyElseCrash(m_dynamicWriter != nullptr || (m_threadId == std::this_thread::get_id() && m_fastPath)));
   return m_writer;
 }
 
+void CallInvokerWriter::ExitCurrentCallInvokeScope() noexcept {
+  m_fastPath = false;
+}
+
 //===========================================================================
 // JSNoopWriter implementation
 //===========================================================================

package/Microsoft.ReactNative/CallInvokerWriter.h

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include <JSI/LongLivedJsiValue.h>
+#include <ReactCommon/CallInvoker.h>
+#include <functional/functor.h>
+#include "DynamicWriter.h"
+#include "JsiWriter.h"
+#include "winrt/Microsoft.ReactNative.h"
+
+namespace winrt::Microsoft::ReactNative {
+
+// IJSValueWriter to ensure that JsiWriter is always used from a RuntimeExecutor.
+// In case if writing is done outside of RuntimeExecutor, it uses DynamicWriter to create
+// folly::dynamic which then is written to JsiWriter in RuntimeExecutor.
+struct CallInvokerWriter : winrt::implements<CallInvokerWriter, IJSValueWriter> {
+  ~CallInvokerWriter();
+  CallInvokerWriter(
+      const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
+      std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept;
+  void WithResultArgs(Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
+                          handler) noexcept;
+
+ public: // IJSValueWriter
+  void WriteNull() noexcept;
+  void WriteBoolean(bool value) noexcept;
+  void WriteInt64(int64_t value) noexcept;
+  void WriteDouble(double value) noexcept;
+  void WriteString(const winrt::hstring &value) noexcept;
+  void WriteObjectBegin() noexcept;
+  void WritePropertyName(const winrt::hstring &name) noexcept;
+  void WriteObjectEnd() noexcept;
+  void WriteArrayBegin() noexcept;
+  void WriteArrayEnd() noexcept;
+
+  // This should be called before the code flow exits the scope of the CallInvoker,
+  // thus requiring the CallInokerWriter to call m_callInvoker->invokeAsync to call back into JS.
+  void ExitCurrentCallInvokeScope() noexcept;
+
+ private:
+  IJSValueWriter GetWriter() noexcept;
+
+ private:
+  const std::shared_ptr<facebook::react::CallInvoker> m_callInvoker;
+  std::weak_ptr<LongLivedJsiRuntime> m_jsiRuntimeHolder;
+  winrt::com_ptr<DynamicWriter> m_dynamicWriter;
+  winrt::com_ptr<JsiWriter> m_jsiWriter;
+  IJSValueWriter m_writer;
+
+  // If a callback is invoked synchronously we can call the JS callback directly.
+  // However, if we post to another thread, or call the callback on the same thread but after we exit the current
+  // RuntimeExecutor callback, then we need to save the callback args in a dynamic and post it back to the CallInvoker
+  bool m_fastPath{true};
+  const std::thread::id m_threadId;
+};
+
+// Special IJSValueWriter that does nothing.
+// We use it instead of JsiWriter when JSI runtime is not available anymore.
+struct JSNoopWriter : winrt::implements<JSNoopWriter, IJSValueWriter> {
+ public: // IJSValueWriter
+  void WriteNull() noexcept;
+  void WriteBoolean(bool value) noexcept;
+  void WriteInt64(int64_t value) noexcept;
+  void WriteDouble(double value) noexcept;
+  void WriteString(const winrt::hstring &value) noexcept;
+  void WriteObjectBegin() noexcept;
+  void WritePropertyName(const winrt::hstring &name) noexcept;
+  void WriteObjectEnd() noexcept;
+  void WriteArrayBegin() noexcept;
+  void WriteArrayEnd() noexcept;
+};
+
+} // namespace winrt::Microsoft::ReactNative

package/Microsoft.ReactNative/CompositionComponentView.idl

@@ -89,11 +89,6 @@ namespace Microsoft.ReactNative.Composition
     Microsoft.ReactNative.ViewProps ViewProps { get; };
   };
 
-  // Some other interfaces we could consider implementing/exposing
-  // Use ifdef USE_EXPERIMENTAL_WINUI3 to add these
-  // Microsoft.UI.Content.IContentLink // Use ifdef USE_EXPERIMENTAL_WINUI3
-  // Microsoft.UI.Content.IContentSiteBridge 
-  // Microsoft.UI.Content.IContentSiteBridge2 // Use ifdef USE_EXPERIMENTAL_WINUI3
   [experimental]
   [webhosthidden]
   runtimeclass ContentIslandComponentView : ViewComponentView { 

package/Microsoft.ReactNative/CompositionSwitcher.idl

@@ -109,11 +109,16 @@ namespace Microsoft.ReactNative.Composition.Experimental
     void Brush(IBrush brush);
     void ScrollEnabled(Boolean isScrollEnabled);
     event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollPositionChanged;
+    event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollBeginDrag;
+	  event Windows.Foundation.EventHandler<IScrollPositionChangedArgs> ScrollEndDrag;
     void ContentSize(Windows.Foundation.Numerics.Vector2 size);
     Windows.Foundation.Numerics.Vector3 ScrollPosition { get; };
     void ScrollBy(Windows.Foundation.Numerics.Vector3 offset, Boolean animate);
     void TryUpdatePosition(Windows.Foundation.Numerics.Vector3 position, Boolean animate);
     void OnPointerPressed(Microsoft.ReactNative.Composition.Input.PointerRoutedEventArgs args);
+    void SetDecelerationRate(Windows.Foundation.Numerics.Vector3 decelerationRate);
+    void SetMaximumZoomScale(Single maximumZoomScale);
+    void SetMinimumZoomScale(Single minimumZoomScale);
     Boolean Horizontal;
   }
 
@@ -123,6 +128,8 @@ namespace Microsoft.ReactNative.Composition.Experimental
   {
     void Size(Single value);
     void Brush(IBrush brush);
+    void StartAnimation();
+    void StopAnimation();
   }
 
   [webhosthidden]

package/Microsoft.ReactNative/Fabric/AbiViewProps.cpp

@@ -77,14 +77,12 @@ winrt::Microsoft::ReactNative::Color Color::ReadValue(
   switch (reader.ValueType()) {
     case JSValueType::Int64: {
       auto argb = reader.GetInt64();
-      return winrt::make<Color>(facebook::react::Color{
-          /*m_isDefined*/ true,
-          /*color*/
-          {static_cast<uint8_t>((argb >> 24) & 0xFF),
-           static_cast<uint8_t>((argb >> 16) & 0xFF),
-           static_cast<uint8_t>((argb >> 8) & 0xFF),
-           static_cast<uint8_t>(argb & 0xFF)},
-          {}});
+      return winrt::make<Color>(facebook::react::Color{/*color*/
+                                                       {static_cast<uint8_t>((argb >> 24) & 0xFF),
+                                                        static_cast<uint8_t>((argb >> 16) & 0xFF),
+                                                        static_cast<uint8_t>((argb >> 8) & 0xFF),
+                                                        static_cast<uint8_t>(argb & 0xFF)},
+                                                       {}});
     }
     case JSValueType::Object: {
       std::vector<std::string> platformColors;
@@ -96,10 +94,10 @@ winrt::Microsoft::ReactNative::Color Color::ReadValue(
           SkipValue<JSValue>(reader); // Skip this property
         }
       }
-      return winrt::make<Color>(facebook::react::Color{/*m_isDefined*/ true, /*color*/ {}, std::move(platformColors)});
+      return winrt::make<Color>(facebook::react::Color{/*color*/ {}, std::move(platformColors)});
     }
     default:
-      return winrt::make<Color>(facebook::react::Color{/*m_isDefined*/ false, /*color*/ {0, 0, 0, 0}, {}});
+      return winrt::make<Color>(facebook::react::Color{/*color*/ {0, 0, 0, 0}, {}});
   }
 }
 

package/Microsoft.ReactNative/Fabric/ComponentView.cpp

@@ -279,7 +279,10 @@ void ComponentView::parent(const winrt::Microsoft::ReactNative::ComponentView &p
     m_parent = parent;
     if (!parent) {
       if (oldRootView && oldRootView->GetFocusedComponent() == *this) {
-        oldRootView->TrySetFocusedComponent(oldParent, winrt::Microsoft::ReactNative::FocusNavigationDirection::None);
+        oldRootView->TrySetFocusedComponent(
+            oldParent,
+            winrt::Microsoft::ReactNative::FocusNavigationDirection::None,
+            true /*forceNoSelectionIfCannotMove*/);
       }
     }
     if (parent) {

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

@@ -67,8 +67,18 @@ void ActivityIndicatorComponentView::updateProps(
     updateProgressColor(newViewProps->color);
   }
 
-  if (newViewProps->animating != oldViewProps->animating) {
-    m_ActivityIndicatorVisual.IsVisible(newViewProps->animating);
+  if (newViewProps->animating != oldViewProps->animating ||
+      newViewProps->hidesWhenStopped != oldViewProps->hidesWhenStopped) {
+    bool setHidden = (newViewProps->hidesWhenStopped && !newViewProps->animating);
+    m_ActivityIndicatorVisual.IsVisible(!setHidden);
+
+    if (!newViewProps->animating && !newViewProps->hidesWhenStopped) {
+      m_animationStopped = true;
+      m_ActivityIndicatorVisual.StopAnimation();
+    } else if (m_animationStopped) {
+      m_ActivityIndicatorVisual.StartAnimation();
+      m_animationStopped = false;
+    }
   }
 }
 

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

@@ -53,6 +53,8 @@ struct ActivityIndicatorComponentView
   void updateVisualSize() noexcept;
   void updateProgressColor(const facebook::react::SharedColor &color) noexcept;
 
+  bool m_animationStopped{false};
+
   winrt::Microsoft::ReactNative::Composition::Experimental::IActivityVisual m_ActivityIndicatorVisual{nullptr};
 };
 

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

@@ -0,0 +1,100 @@
+#include "pch.h"
+#include "CompositionAnnotationProvider.h"
+#include <Fabric/ComponentView.h>
+#include <Unicode.h>
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionAnnotationProvider::CompositionAnnotationProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    : m_view{componentView} {
+  m_parentProvider.copy_from(parentProvider);
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_AnnotationTypeId(int *retVal) {
+  if (retVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (props->accessibilityAnnotation.value().typeID.empty()) {
+    return E_FAIL;
+  }
+  *retVal = static_cast<int>(GetAnnotationTypeId(props->accessibilityAnnotation.value().typeID));
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_AnnotationTypeName(BSTR *retVal) {
+  if (retVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (props->accessibilityAnnotation.value().typeName.empty()) {
+    return E_FAIL;
+  }
+  auto typeName = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().typeName);
+  *retVal = SysAllocString(typeName.c_str());
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_Author(BSTR *retVal) {
+  if (retVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (props->accessibilityAnnotation.value().author.empty()) {
+    return E_FAIL;
+  }
+  auto author = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().author);
+  *retVal = SysAllocString(author.c_str());
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_DateTime(BSTR *retVal) {
+  if (retVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (props->accessibilityAnnotation.value().dateTime.empty()) {
+    return E_FAIL;
+  }
+  auto dateTime = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().dateTime);
+  *retVal = SysAllocString(dateTime.c_str());
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionAnnotationProvider::get_Target(IRawElementProviderSimple **retVal) {
+  // no-opt
+  return E_NOTIMPL;
+}
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+#include <inspectable.h>
+#include <uiautomationcore.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+class CompositionAnnotationProvider : public winrt::implements<CompositionAnnotationProvider, IAnnotationProvider> {
+ public:
+  CompositionAnnotationProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+
+  // inherited via IAnnotationProvider
+  virtual HRESULT __stdcall get_AnnotationTypeId(int *retVal) override;
+  virtual HRESULT __stdcall get_AnnotationTypeName(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_Author(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_DateTime(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_Target(IRawElementProviderSimple **retVal) override;
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<IAnnotationProvider> m_annotationProvider;
+  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation