react-native-windows 0.69.5 → 0.70.0-preview.2

package/Microsoft.ReactNative/IReactDispatcher.idl

@@ -53,5 +53,20 @@ namespace Microsoft.ReactNative
       "Generally you can use @IReactContext.JSDispatcher to get the value of this property for "
       "a specific React instance.")
     static IReactPropertyName JSDispatcherProperty { get; };
+
+    DOC_STRING(
+      "Gets the name of the `JSDispatcherTaskStartingEventName` property for the @IReactNotificationService.\n"
+      "This notification name is to be used with IReactNotificationService.")
+    static IReactPropertyName JSDispatcherTaskStartingEventName{ get; };
+
+    DOC_STRING(
+      "Gets the name of the `JSDispatcherIdleWaitStartingEventName` property for the @IReactNotificationService.\n"
+      "This notification name is to be used with IReactNotificationService.")
+    static IReactPropertyName JSDispatcherIdleWaitStartingEventName{ get; };
+
+    DOC_STRING(
+      "Gets the name of the `JSDispatcherIdleWaitCompletedEventName` property for the @IReactNotificationService.\n"
+      "This notification name is to be used with IReactNotificationService.")
+    static IReactPropertyName JSDispatcherIdleWaitCompletedEventName{ get; };
   }
 } // namespace ReactNative

package/Microsoft.ReactNative/IReactNotificationService.cpp

@@ -8,77 +8,183 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 //=============================================================================
-// ReactNotificationSubscription implementation
+// IReactNotificationSubscription implementation
 //=============================================================================
 
-ReactNotificationSubscription::ReactNotificationSubscription(
-    IReactNotificationSubscription const &parentSubscription,
-    weak_ref<ReactNotificationService> &&notificationService,
-    IReactPropertyName const &notificationName,
-    IReactDispatcher const &dispatcher) noexcept
-    : m_parentSubscription{parentSubscription},
-      m_notificationService{std::move(notificationService)},
-      m_notificationName{notificationName},
-      m_dispatcher{dispatcher} {}
-
-ReactNotificationSubscription::ReactNotificationSubscription(
-    weak_ref<ReactNotificationService> &&notificationService,
-    IReactPropertyName const &notificationName,
-    IReactDispatcher const &dispatcher,
-    ReactNotificationHandler const &handler) noexcept
-    : m_notificationService{std::move(notificationService)},
-      m_notificationName{notificationName},
-      m_dispatcher{dispatcher},
-      m_handler{handler} {}
-
-ReactNotificationSubscription::~ReactNotificationSubscription() noexcept {
-  Unsubscribe();
-}
+// Common interface to share functionality between ReactNotificationSubscription and ReactNotificationSubscriptionView
+MSO_GUID(IReactNotificationSubscriptionPrivate, "09437980-3508-4690-930c-7c310e205e6b")
+struct IReactNotificationSubscriptionPrivate : ::IUnknown {
+  virtual void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept = 0;
+  virtual void CallHandler(
+      Windows::Foundation::IInspectable const &sender,
+      Windows::Foundation::IInspectable const &data) noexcept = 0;
+};
+
+// The Notification subscription class.
+// Instances of this class are stored in the "child" notification services.
+struct ReactNotificationSubscription
+    : implements<ReactNotificationSubscription, IReactNotificationSubscription, IReactNotificationSubscriptionPrivate> {
+  ReactNotificationSubscription(
+      Mso::RefCountedPtr<std::mutex> const &mutex,
+      weak_ref<ReactNotificationService> &&notificationService,
+      IReactPropertyName const &notificationName,
+      IReactDispatcher const &dispatcher,
+      ReactNotificationHandler const &handler) noexcept
+      : m_mutex{mutex},
+        m_notificationService{std::move(notificationService)},
+        m_notificationName{notificationName},
+        m_dispatcher{dispatcher},
+        m_handler{handler} {}
+
+  ~ReactNotificationSubscription() noexcept {
+    Unsubscribe();
+  }
 
-IReactNotificationService ReactNotificationSubscription::NotificationService() const noexcept {
-  return m_notificationService.get().as<IReactNotificationService>();
-}
+ public: // IReactNotificationSubscription implementation
+  IReactNotificationService NotificationService() const noexcept {
+    return m_notificationService.get().as<IReactNotificationService>();
+  }
 
-IReactPropertyName ReactNotificationSubscription::NotificationName() const noexcept {
-  return m_notificationName;
-}
+  IReactPropertyName NotificationName() const noexcept {
+    return m_notificationName;
+  }
 
-IReactDispatcher ReactNotificationSubscription::Dispatcher() const noexcept {
-  return m_dispatcher;
-}
+  IReactDispatcher Dispatcher() const noexcept {
+    return m_dispatcher;
+  }
 
-bool ReactNotificationSubscription::IsSubscribed() const noexcept {
-  return m_isSubscribed;
-}
+  bool IsSubscribed() const noexcept {
+    return GetHandler() != nullptr;
+  }
 
-void ReactNotificationSubscription::Unsubscribe() noexcept {
-  if (m_parentSubscription) {
-    m_parentSubscription.Unsubscribe();
+  void Unsubscribe() noexcept {
+    if (m_parentSubscription) {
+      m_parentSubscription.Unsubscribe();
+    }
+
+    bool isSubscribed{false};
+    {
+      std::scoped_lock lock{*m_mutex};
+      if (m_handler) {
+        isSubscribed = true;
+        // Remove handler to free any objects captured by it.
+        m_handler = nullptr;
+      }
+    }
+
+    if (isSubscribed) {
+      if (auto notificationService = m_notificationService.get()) {
+        notificationService->Unsubscribe(*this);
+      }
+    }
+  }
+
+ public: // IReactNotificationSubscriptionPrivate implementation
+  void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept override {
+    m_parentSubscription = parentSubscription;
   }
 
-  if (m_isSubscribed.exchange(false)) {
-    if (auto notificationService = m_notificationService.get()) {
-      notificationService->Unsubscribe(*this);
+  void CallHandler(IInspectable const &sender, IInspectable const &data) noexcept override {
+    auto args = make<ReactNotificationArgs>(*this, data);
+    if (auto handler = GetHandler()) {
+      if (m_dispatcher) {
+        m_dispatcher.Post([thisPtr = get_strong(), sender, args]() noexcept {
+          if (auto handler = thisPtr->GetHandler()) {
+            handler(sender, args);
+          }
+        });
+      } else {
+        handler(sender, args);
+      }
     }
   }
-}
 
-void ReactNotificationSubscription::CallHandler(
-    IInspectable const &sender,
-    IReactNotificationArgs const &args) noexcept {
-  VerifyElseCrashSz(!m_parentSubscription, "CallHandler must not be called on the child subscription.");
-  if (IsSubscribed()) {
-    if (m_dispatcher) {
-      m_dispatcher.Post([thisPtr = get_strong(), sender, args]() noexcept {
-        if (thisPtr->IsSubscribed()) {
-          thisPtr->m_handler(sender, args);
-        }
-      });
+ private:
+  ReactNotificationHandler GetHandler() const noexcept {
+    std::scoped_lock lock{*m_mutex};
+    return m_handler;
+  }
+
+ private:
+  Mso::RefCountedPtr<std::mutex> m_mutex;
+  IReactNotificationSubscription m_parentSubscription{nullptr};
+  const weak_ref<ReactNotificationService> m_notificationService{nullptr};
+  const IReactPropertyName m_notificationName{nullptr};
+  const IReactDispatcher m_dispatcher{nullptr};
+  ReactNotificationHandler m_handler{nullptr};
+};
+
+// The notification subscription view to wrap up child notification service.
+// Instances of this class are stored in the parent notification services.
+struct ReactNotificationSubscriptionView : implements<
+                                               ReactNotificationSubscriptionView,
+                                               IReactNotificationSubscription,
+                                               IReactNotificationSubscriptionPrivate> {
+  ReactNotificationSubscriptionView(
+      weak_ref<ReactNotificationService> &&notificationService,
+      IReactNotificationSubscription const &childSubscription) noexcept
+      : m_notificationService{std::move(notificationService)}, m_childSubscription{weak_ref(childSubscription)} {
+    childSubscription.as<IReactNotificationSubscriptionPrivate>()->SetParent(*this);
+  }
+
+  ~ReactNotificationSubscriptionView() noexcept {
+    Unsubscribe();
+  }
+
+ public: // IReactNotificationSubscription implementation
+  IReactNotificationService NotificationService() const noexcept {
+    return m_notificationService.get().as<IReactNotificationService>();
+  }
+
+  IReactPropertyName NotificationName() const noexcept {
+    if (auto childSubscription = m_childSubscription.get()) {
+      return childSubscription.NotificationName();
     } else {
-      m_handler(sender, args);
+      return IReactPropertyName{nullptr};
     }
   }
-}
+
+  IReactDispatcher Dispatcher() const noexcept {
+    if (auto childSubscription = m_childSubscription.get()) {
+      return childSubscription.Dispatcher();
+    } else {
+      return IReactDispatcher{nullptr};
+    }
+  }
+
+  bool IsSubscribed() const noexcept {
+    return m_isSubscribed;
+  }
+
+  void Unsubscribe() noexcept {
+    if (m_parentSubscription) {
+      m_parentSubscription.Unsubscribe();
+    }
+
+    if (m_isSubscribed.exchange(false)) {
+      if (auto notificationService = m_notificationService.get()) {
+        notificationService->Unsubscribe(*this);
+      }
+    }
+  }
+
+ public: // IReactNotificationSubscriptionPrivate implementation
+  void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept override {
+    m_parentSubscription = parentSubscription;
+  }
+
+  void CallHandler(IInspectable const &sender, IInspectable const &data) noexcept override {
+    if (auto childSubscription = m_childSubscription.get()) {
+      childSubscription.as<IReactNotificationSubscriptionPrivate>()->CallHandler(sender, data);
+    }
+  }
+
+ private:
+  IReactNotificationSubscription m_parentSubscription{nullptr};
+  const weak_ref<IReactNotificationSubscription> m_childSubscription{nullptr};
+  const weak_ref<ReactNotificationService> m_notificationService{nullptr};
+  std::atomic_bool m_isSubscribed{true};
+};
 
 //=============================================================================
 // ReactNotificationService implementation
@@ -99,7 +205,7 @@ void ReactNotificationService::ModifySubscriptions(
   // Get the current snapshot under the lock
   SubscriptionSnapshotPtr currentSnapshotPtr;
   {
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     auto it = m_subscriptions.find(notificationName);
     if (it != m_subscriptions.end()) {
       currentSnapshotPtr = it->second;
@@ -113,7 +219,7 @@ void ReactNotificationService::ModifySubscriptions(
 
     // Try to set the new snapshot under the lock
     SubscriptionSnapshotPtr snapshotPtr;
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     auto it = m_subscriptions.find(notificationName);
     if (it != m_subscriptions.end()) {
       snapshotPtr = it->second;
@@ -146,20 +252,42 @@ IReactNotificationSubscription ReactNotificationService::Subscribe(
     IReactPropertyName const &notificationName,
     IReactDispatcher const &dispatcher,
     ReactNotificationHandler const &handler) noexcept {
-  // Make sure that parent notification service also subscribes to this notification.
-  auto parentSubscription = m_parentNotificationService
-      ? m_parentNotificationService.Subscribe(notificationName, dispatcher, handler)
-      : IReactNotificationSubscription{nullptr};
-  auto subscription = parentSubscription
-      ? make<ReactNotificationSubscription>(parentSubscription, get_weak(), notificationName, dispatcher)
-      : make<ReactNotificationSubscription>(get_weak(), notificationName, dispatcher, handler);
+  VerifyElseCrashSz(notificationName, "notificationName must be not null");
+  VerifyElseCrashSz(handler, "handler must be not null");
+
+  IReactNotificationSubscription subscription =
+      make<ReactNotificationSubscription>(m_mutex, get_weak(), notificationName, dispatcher, handler);
+  AddSubscription(notificationName, subscription);
+  AddSubscriptionToParent(notificationName, subscription);
+  return subscription;
+}
+
+void ReactNotificationService::AddSubscription(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &subscription) noexcept {
   ModifySubscriptions(
       notificationName, [&subscription](std::vector<IReactNotificationSubscription> const &snapshot) noexcept {
         auto newSnapshot = std::vector<IReactNotificationSubscription>(snapshot);
         newSnapshot.push_back(subscription);
         return newSnapshot;
       });
-  return subscription;
+}
+
+void ReactNotificationService::AddSubscriptionToParent(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &subscription) noexcept {
+  if (m_parentNotificationService) {
+    get_self<ReactNotificationService>(m_parentNotificationService)
+        ->AddSubscriptionFromChild(notificationName, subscription);
+  }
+}
+
+void ReactNotificationService::AddSubscriptionFromChild(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &childSubscription) noexcept {
+  auto subscription = make<ReactNotificationSubscriptionView>(get_weak(), childSubscription);
+  AddSubscription(notificationName, subscription);
+  AddSubscriptionToParent(notificationName, subscription);
 }
 
 void ReactNotificationService::Unsubscribe(IReactNotificationSubscription const &subscription) noexcept {
@@ -180,7 +308,7 @@ void ReactNotificationService::UnsubscribeAll() noexcept {
   // The subscription will call the parent Unsubscribe on its own.
   decltype(m_subscriptions) subscriptions;
   {
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     subscriptions = std::move(m_subscriptions);
   }
 
@@ -203,7 +331,7 @@ void ReactNotificationService::SendNotification(
     SubscriptionSnapshotPtr currentSnapshotPtr;
 
     {
-      std::scoped_lock lock{m_mutex};
+      std::scoped_lock lock{*m_mutex};
       auto it = m_subscriptions.find(notificationName);
       if (it != m_subscriptions.end()) {
         currentSnapshotPtr = it->second;
@@ -213,8 +341,7 @@ void ReactNotificationService::SendNotification(
     // Call notification handlers outside of lock.
     if (currentSnapshotPtr) {
       for (auto &subscription : *currentSnapshotPtr) {
-        auto args = make<ReactNotificationArgs>(subscription, data);
-        get_self<ReactNotificationSubscription>(subscription)->CallHandler(sender, args);
+        subscription.as<IReactNotificationSubscriptionPrivate>()->CallHandler(sender, data);
       }
     }
   }

package/Microsoft.ReactNative/IReactNotificationService.h

@@ -91,9 +91,19 @@ struct ReactNotificationService : implements<ReactNotificationService, IReactNot
       IReactPropertyName const &notificationName,
       Mso::FunctorRef<SubscriptionSnapshot(SubscriptionSnapshot const &)> const &modifySnapshot);
 
+  void AddSubscription(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &subscription) noexcept;
+  void AddSubscriptionToParent(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &subscription) noexcept;
+  void AddSubscriptionFromChild(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &childSubscription) noexcept;
+
  private:
   const IReactNotificationService m_parentNotificationService;
-  std::mutex m_mutex;
+  Mso::RefCountedPtr<std::mutex> m_mutex{Mso::Make_RefCounted<std::mutex>()};
   std::unordered_map<IReactPropertyName, SubscriptionSnapshotPtr> m_subscriptions;
 };
 
@@ -103,35 +113,6 @@ struct ReactNotificationServiceHelper {
   static IReactNotificationService CreateNotificationService() noexcept;
 };
 
-struct ReactNotificationSubscription : implements<ReactNotificationSubscription, IReactNotificationSubscription> {
-  ReactNotificationSubscription(
-      IReactNotificationSubscription const &parentSubscription,
-      weak_ref<ReactNotificationService> &&notificationService,
-      IReactPropertyName const &notificationName,
-      IReactDispatcher const &dispatcher) noexcept;
-  ReactNotificationSubscription(
-      weak_ref<ReactNotificationService> &&notificationService,
-      IReactPropertyName const &notificationName,
-      IReactDispatcher const &dispatcher,
-      ReactNotificationHandler const &handler) noexcept;
-  ~ReactNotificationSubscription() noexcept;
-
-  IReactNotificationService NotificationService() const noexcept;
-  IReactPropertyName NotificationName() const noexcept;
-  IReactDispatcher Dispatcher() const noexcept;
-  bool IsSubscribed() const noexcept;
-  void Unsubscribe() noexcept;
-  void CallHandler(IInspectable const &sender, IReactNotificationArgs const &args) noexcept;
-
- private:
-  const IReactNotificationSubscription m_parentSubscription{nullptr};
-  const weak_ref<ReactNotificationService> m_notificationService;
-  const IReactPropertyName m_notificationName;
-  const IReactDispatcher m_dispatcher;
-  const ReactNotificationHandler m_handler;
-  std::atomic_bool m_isSubscribed{true};
-};
-
 } // namespace winrt::Microsoft::ReactNative::implementation
 
 namespace winrt::Microsoft::ReactNative::factory_implementation {

package/Microsoft.ReactNative/IReactPropertyBag.cpp

@@ -191,6 +191,15 @@ IInspectable ReactPropertyBag::Set(IReactPropertyName const &propertyName, IInsp
   return result;
 }
 
+void ReactPropertyBag::CopyFrom(IReactPropertyBag const &other) noexcept {
+  std::scoped_lock lock{m_mutex};
+  auto otherImpl = winrt::get_self<ReactPropertyBag>(other);
+  std::scoped_lock otherLock{otherImpl->m_mutex};
+  for (auto const &entry : otherImpl->m_entries) {
+    m_entries.emplace(entry);
+  }
+}
+
 /*static*/ IReactPropertyNamespace ReactPropertyBagHelper::GlobalNamespace() noexcept {
   return ReactPropertyNamespace::GlobalNamespace().as<IReactPropertyNamespace>();
 }

package/Microsoft.ReactNative/IReactPropertyBag.h

@@ -3,6 +3,7 @@
 
 #pragma once
 #include "ReactPropertyBagHelper.g.h"
+#include <winrt/Windows.Foundation.Collections.h>
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -13,6 +14,8 @@ struct ReactPropertyBag : implements<ReactPropertyBag, IReactPropertyBag> {
   IInspectable GetOrCreate(IReactPropertyName const &name, ReactCreatePropertyValue const &createValue) noexcept;
   IInspectable Set(IReactPropertyName const &name, IInspectable const &value) noexcept;
 
+  void CopyFrom(IReactPropertyBag const &) noexcept;
+
  private:
   std::mutex m_mutex;
   std::map<IReactPropertyName, IInspectable> m_entries;

package/Microsoft.ReactNative/IReactPropertyBag.idl

@@ -62,6 +62,9 @@ namespace Microsoft.ReactNative
       "It returns null if the property did not exist.\n"
       "If the new value is null, then the property is removed.")
     Object Set(IReactPropertyName name, Object value);
+
+    DOC_STRING("Copies the properties from another property bag")
+    void CopyFrom(IReactPropertyBag other);
   }
 
   [webhosthidden]

package/Microsoft.ReactNative/JsiApi.cpp

@@ -63,6 +63,11 @@ struct PointerAccessor : facebook::jsi::Pointer {
     return {reinterpret_cast<uint64_t>(std::exchange(accessor.ptr_, nullptr))};
   }
 
+  static JsiBigIntRef MakeJsiBigIntData(facebook::jsi::BigInt &&bigInt) {
+    auto &&accessor = AsPointerAccessor(std::move(bigInt));
+    return {reinterpret_cast<uint64_t>(std::exchange(accessor.ptr_, nullptr))};
+  }
+
   static JsiStringRef MakeJsiStringData(facebook::jsi::String &&str) {
     auto &&accessor = AsPointerAccessor(std::move(str));
     return {reinterpret_cast<uint64_t>(std::exchange(accessor.ptr_, nullptr))};
@@ -101,6 +106,7 @@ struct PointerAccessor : facebook::jsi::Pointer {
 struct ValueAccessor {
   static JsiValueRef ToJsiValueData(facebook::jsi::Value const &value) noexcept {
     ValueAccessor const &accessor = reinterpret_cast<ValueAccessor const &>(value);
+    // TODO: JSIVALUECONVERSION - Use JsiValueKindHelper::ToJsiValueKind
     return {
         static_cast<JsiValueKind>(static_cast<int32_t>(accessor.m_kind)),
         *reinterpret_cast<uint64_t const *>(&accessor.m_data)};
@@ -108,12 +114,14 @@ struct ValueAccessor {
 
   static JsiValueRef MakeJsiValueData(facebook::jsi::Value &&value) {
     ValueAccessor &&accessor = reinterpret_cast<ValueAccessor &&>(value);
+    // TODO: JSIVALUECONVERSION - Use JsiValueKindHelper::ToJsiValueKind
     return {
         static_cast<JsiValueKind>(static_cast<int32_t>(std::exchange(accessor.m_kind, UndefinedKind))),
         *reinterpret_cast<uint64_t *>(&accessor.m_data)};
   }
 
  private:
+  // TODO: JSIVALUECONVERSION - Use FacebookJsiValueKind enum
   enum ValueKind { UndefinedKind } m_kind;
   double m_data;
 
@@ -133,6 +141,7 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
 
   using facebook::jsi::Runtime::call;
   using facebook::jsi::Runtime::callAsConstructor;
+  using facebook::jsi::Runtime::cloneBigInt;
   using facebook::jsi::Runtime::cloneObject;
   using facebook::jsi::Runtime::clonePropNameID;
   using facebook::jsi::Runtime::cloneString;
@@ -182,6 +191,10 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
     return *reinterpret_cast<facebook::jsi::Symbol const *>(ptr);
   }
 
+  static facebook::jsi::BigInt const &AsBigInt(facebook::jsi::Runtime::PointerValue const **ptr) noexcept {
+    return *reinterpret_cast<facebook::jsi::BigInt const *>(ptr);
+  }
+
   static facebook::jsi::String const &AsString(facebook::jsi::Runtime::PointerValue const **ptr) noexcept {
     return *reinterpret_cast<facebook::jsi::String const *>(ptr);
   }
@@ -207,6 +220,7 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
   }
 
   static facebook::jsi::Value const *AsValue(JsiValueRef const &data) noexcept {
+    // TODO: JSIVALUECONVERSION
     return reinterpret_cast<facebook::jsi::Value const *>(&data);
   }
 
@@ -214,6 +228,10 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
     return {reinterpret_cast<uint64_t>(pointerValue)};
   }
 
+  static JsiBigIntRef MakeJsiBigIntData(facebook::jsi::Runtime::PointerValue *pointerValue) {
+    return {reinterpret_cast<uint64_t>(pointerValue)};
+  }
+
   static JsiStringRef MakeJsiStringData(facebook::jsi::Runtime::PointerValue *pointerValue) {
     return {reinterpret_cast<uint64_t>(pointerValue)};
   }
@@ -232,10 +250,12 @@ struct RuntimeAccessor : facebook::jsi::Runtime {
   }
 
   static JsiValueRef const *AsJsiValueData(facebook::jsi::Value const *value) noexcept {
-    return reinterpret_cast<Microsoft::ReactNative::JsiValueRef const *>(value);
+    auto ref = ValueAccessor::ToJsiValueData(*value);
+    return &ref;
   }
 
   static facebook::jsi::Value &&ToValue(JsiValueRef &&value) noexcept {
+    // TODO: JSIVALUECONVERSION
     return reinterpret_cast<facebook::jsi::Value &&>(value);
   }
 
@@ -522,6 +542,13 @@ JsiSymbolRef JsiRuntime::CloneSymbol(JsiSymbolRef symbol) try {
   throw;
 }
 
+JsiBigIntRef JsiRuntime::CloneBigInt(JsiBigIntRef bigInt) try {
+  return PointerAccessor::MakeJsiBigIntData(m_runtimeAccessor->make<facebook::jsi::BigInt>(
+      m_runtimeAccessor->cloneBigInt(RuntimeAccessor::AsPointerValue(bigInt))));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
 JsiStringRef JsiRuntime::CloneString(JsiStringRef str) try {
   return PointerAccessor::MakeJsiStringData(m_runtimeAccessor->make<facebook::jsi::String>(
       m_runtimeAccessor->cloneString(RuntimeAccessor::AsPointerValue(str))));
@@ -920,6 +947,14 @@ bool JsiRuntime::SymbolStrictEquals(JsiSymbolRef left, JsiSymbolRef right) try {
   throw;
 }
 
+bool JsiRuntime::BigIntStrictEquals(JsiBigIntRef left, JsiBigIntRef right) try {
+  auto leftPtr = RuntimeAccessor::AsPointerValue(left);
+  auto rightPtr = RuntimeAccessor::AsPointerValue(right);
+  return m_runtimeAccessor->strictEquals(RuntimeAccessor::AsBigInt(&leftPtr), RuntimeAccessor::AsBigInt(&rightPtr));
+} catch (JSI_SET_ERROR) {
+  throw;
+}
+
 bool JsiRuntime::StringStrictEquals(JsiStringRef left, JsiStringRef right) try {
   auto leftPtr = RuntimeAccessor::AsPointerValue(left);
   auto rightPtr = RuntimeAccessor::AsPointerValue(right);
@@ -949,6 +984,11 @@ void JsiRuntime::ReleaseSymbol(JsiSymbolRef const &symbolData) {
       RuntimeAccessor::make<facebook::jsi::Symbol>(reinterpret_cast<RuntimeAccessor::PointerValue *>(symbolData.Data));
 }
 
+void JsiRuntime::ReleaseBigInt(JsiBigIntRef const &bigIntData) {
+  auto bigInt =
+      RuntimeAccessor::make<facebook::jsi::BigInt>(reinterpret_cast<RuntimeAccessor::PointerValue *>(bigIntData.Data));
+}
+
 void JsiRuntime::ReleaseString(JsiStringRef const &stringData) {
   auto str =
       RuntimeAccessor::make<facebook::jsi::String>(reinterpret_cast<RuntimeAccessor::PointerValue *>(stringData.Data));

package/Microsoft.ReactNative/JsiApi.h

@@ -82,6 +82,7 @@ struct JsiRuntime : JsiRuntimeT<JsiRuntime> {
   bool IsInspectable();
 
   JsiSymbolRef CloneSymbol(JsiSymbolRef symbol);
+  JsiBigIntRef CloneBigInt(JsiBigIntRef bigInt);
   JsiStringRef CloneString(JsiStringRef str);
   JsiObjectRef CloneObject(JsiObjectRef obj);
   JsiPropertyIdRef ClonePropertyId(JsiPropertyIdRef propertyId);
@@ -142,11 +143,13 @@ struct JsiRuntime : JsiRuntimeT<JsiRuntime> {
   void PopScope(JsiScopeState scopeState);
 
   bool SymbolStrictEquals(JsiSymbolRef left, JsiSymbolRef right);
+  bool BigIntStrictEquals(JsiBigIntRef left, JsiBigIntRef right);
   bool StringStrictEquals(JsiStringRef left, JsiStringRef right);
   bool ObjectStrictEquals(JsiObjectRef left, JsiObjectRef right);
   bool InstanceOf(JsiObjectRef obj, JsiObjectRef constructor);
 
   void ReleaseSymbol(JsiSymbolRef const &symbol);
+  void ReleaseBigInt(JsiBigIntRef const &bigInt);
   void ReleaseString(JsiStringRef const &str);
   void ReleaseObject(JsiObjectRef const &obj);
   void ReleasePropertyId(JsiPropertyIdRef const &propertyId);

package/Microsoft.ReactNative/JsiApi.idl

@@ -50,7 +50,7 @@ namespace Microsoft.ReactNative
     void GetData(JsiByteArrayUser useBytes);
   };
 
-  // Type of the JavaScript value. It is currently matching the full JavaScript set of types except for the BigInt type.
+  // Type of the JavaScript value. It is currently matching the full JavaScript set of types.
   [experimental]
   DOC_STRING(
     "An experimental API. Do not use it directly. "
@@ -65,8 +65,10 @@ namespace Microsoft.ReactNative
     Boolean,
     Number,
     Symbol,
+    BigInt, // TODO: JSIVALUECONVERSION - This is where RN wants to put the new enum
     String,
     Object,
+    // BigInt, // TODO: JSIVALUECONVERSION - This is where we WANT to put the new enum
   };
 
   [experimental, webhosthidden]
@@ -94,6 +96,19 @@ namespace Microsoft.ReactNative
     UInt64 Data;
   };
 
+  [experimental]
+  DOC_STRING(
+    "An experimental API. Do not use it directly. "
+    "It may be removed or changed in a future version. Instead, use the JSI API that uses this API internally.\n"
+    "See the `ExecuteJsi` method in `JsiApiContext.h` of the `Microsoft.ReactNative.Cxx` shared project, "
+    "or the examples of the JSI-based TurboModules in the `Microsoft.ReactNative.IntegrationTests` project.\n"
+    "Note that the JSI is defined only for C++ code. We plan to add the .Net support in future.")
+  struct JsiBigIntRef
+  {
+    UInt64 Data;
+  };
+
+
   [experimental]
   DOC_STRING(
     "An experimental API. Do not use it directly. "
@@ -238,6 +253,7 @@ namespace Microsoft.ReactNative
     Boolean IsInspectable { get; };
 
     JsiSymbolRef CloneSymbol(JsiSymbolRef symbol);
+    JsiBigIntRef CloneBigInt (JsiBigIntRef bigInt);
     JsiStringRef CloneString(JsiStringRef str);
     JsiObjectRef CloneObject(JsiObjectRef obj);
     JsiPropertyIdRef ClonePropertyId(JsiPropertyIdRef propertyId);
@@ -297,12 +313,14 @@ namespace Microsoft.ReactNative
     void PopScope(JsiScopeState scopeState);
 
     Boolean SymbolStrictEquals(JsiSymbolRef left, JsiSymbolRef right);
+    Boolean BigIntStrictEquals(JsiBigIntRef left, JsiBigIntRef right);
     Boolean StringStrictEquals(JsiStringRef left, JsiStringRef right);
     Boolean ObjectStrictEquals(JsiObjectRef left, JsiObjectRef right);
 
     Boolean InstanceOf(JsiObjectRef obj, JsiObjectRef constructor);
 
     void ReleaseSymbol(JsiSymbolRef symbol);
+    void ReleaseBigInt(JsiBigIntRef bigInt);
     void ReleaseString(JsiStringRef str);
     void ReleaseObject(JsiObjectRef obj);
     void ReleasePropertyId(JsiPropertyIdRef propertyId);