react-native-windows 0.82.1 → 0.83.0-preview.0

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/core/ReactCommon/TurboModule.h

@@ -36,9 +36,7 @@ enum TurboModuleMethodValueKind {
 /**
  * Determines TurboModuleMethodValueKind based on the jsi::Value type.
  */
-TurboModuleMethodValueKind getTurboModuleMethodValueKind(
-    jsi::Runtime& rt,
-    const jsi::Value* value);
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(jsi::Runtime &rt, const jsi::Value *value);
 
 class TurboCxxModule;
 class TurboModuleBinding;
@@ -55,8 +53,8 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
   // JS representation. To customize lookup of properties, override `create`.
   // Note: keep this method declared inline to avoid conflicts
   // between RTTI and non-RTTI compilation units
-  jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName)
-      override {
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &propName) override
+  {
     auto prop = create(runtime, propName);
     // If we have a JS wrapper, cache the result of this lookup
     // We don't cache misses, to allow for methodMap_ to dynamically be
@@ -64,15 +62,14 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
     // [Windows] Reenable once https://github.com/microsoft/react-native-windows/issues/14128 is fixed
 #ifndef WINAPI_FAMILY
     if (jsRepresentation_ && !prop.isUndefined()) {
-      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
-          runtime, propName, prop);
+      jsRepresentation_->lock(runtime).asObject(runtime).setProperty(runtime, propName, prop);
     }
 #endif
     return prop;
   }
 
-  std::vector<jsi::PropNameID> getPropertyNames(
-      jsi::Runtime& runtime) override {
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &runtime) override
+  {
     std::vector<jsi::PropNameID> result;
     result.reserve(methodMap_.size());
     for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
@@ -87,18 +84,14 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
 
   struct MethodMetadata {
     size_t argCount;
-    jsi::Value (*invoker)(
-        jsi::Runtime& rt,
-        TurboModule& turboModule,
-        const jsi::Value* args,
-        size_t count);
+    jsi::Value (*invoker)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t count);
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
-  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
-      eventEmitterMap_;
 
-  using ArgFactory =
-      std::function<void(jsi::Runtime& runtime, std::vector<jsi::Value>& args)>;
+  friend class TurboModuleTestFixtureInternal;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>> eventEmitterMap_;
+
+  using ArgFactory = std::function<void(jsi::Runtime &runtime, std::vector<jsi::Value> &args)>;
 
   /**
    * Calls RCTDeviceEventEmitter.emit to JavaScript, with given event name and
@@ -112,35 +105,31 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
    *      args.emplace_back(jsi::Value(42));
    *  });
    */
-  void emitDeviceEvent(
-      const std::string& eventName,
-      ArgFactory&& argFactory = nullptr);
+  void emitDeviceEvent(const std::string &eventName, ArgFactory &&argFactory = nullptr);
 
   // Backwards compatibility version
   void emitDeviceEvent(
-      jsi::Runtime& /*runtime*/,
+      jsi::Runtime & /*runtime*/,
 
-      const std::string& eventName,
-      ArgFactory&& argFactory = nullptr) {
+      const std::string &eventName,
+      ArgFactory &&argFactory = nullptr)
+  {
     emitDeviceEvent(eventName, std::move(argFactory));
   }
 
-  virtual jsi::Value create(
-      jsi::Runtime& runtime,
-      const jsi::PropNameID& propName) {
+  virtual jsi::Value create(jsi::Runtime &runtime, const jsi::PropNameID &propName)
+  {
     std::string propNameUtf8 = propName.utf8(runtime);
-    if (auto methodIter = methodMap_.find(propNameUtf8);
-        methodIter != methodMap_.end()) {
-      const MethodMetadata& meta = methodIter->second;
+    if (auto methodIter = methodMap_.find(propNameUtf8); methodIter != methodMap_.end()) {
+      const MethodMetadata &meta = methodIter->second;
       return jsi::Function::createFromHostFunction(
           runtime,
           propName,
           static_cast<unsigned int>(meta.argCount),
           [this, meta](
-              jsi::Runtime& rt,
-              [[maybe_unused]] const jsi::Value& thisVal,
-              const jsi::Value* args,
-              size_t count) { return meta.invoker(rt, *this, args, count); });
+              jsi::Runtime &rt, [[maybe_unused]] const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
+            return meta.invoker(rt, *this, args, count);
+          });
     } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
                eventEmitterIter != eventEmitterMap_.end()) {
       return eventEmitterIter->second->get(runtime, jsInvoker_);
@@ -159,7 +148,6 @@ class JSI_EXPORT TurboModule : public jsi::HostObject {
  * An app/platform-specific provider function to get an instance of a module
  * given a name.
  */
-using TurboModuleProviderFunctionType =
-    std::function<std::shared_ptr<TurboModule>(const std::string& name)>;
+using TurboModuleProviderFunctionType = std::function<std::shared_ptr<TurboModule>(const std::string &name)>;
 
 } // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/dom/NativeDOM.h

@@ -23,14 +23,11 @@
 
 namespace facebook::react {
 
-using MeasureOnSuccessCallback =
-    SyncCallback<void(double, double, double, double, double, double)>;
+using MeasureOnSuccessCallback = SyncCallback<void(double, double, double, double, double, double)>;
 
-using MeasureInWindowOnSuccessCallback =
-    SyncCallback<void(double, double, double, double)>;
+using MeasureInWindowOnSuccessCallback = SyncCallback<void(double, double, double, double)>;
 
-using MeasureLayoutOnSuccessCallback =
-    SyncCallback<void(double, double, double, double)>;
+using MeasureLayoutOnSuccessCallback = SyncCallback<void(double, double, double, double)>;
 
 class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
  public:
@@ -38,21 +35,15 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
 
 #pragma mark - Methods from the Node interface (for ReadOnlyNode).
 
-  double compareDocumentPosition(
-      jsi::Runtime& rt,
-      jsi::Value nativeNodeReference,
-      jsi::Value otherNativeNodeReference);
+  double compareDocumentPosition(jsi::Runtime &rt, jsi::Value nativeNodeReference, jsi::Value otherNativeNodeReference);
 
-  std::vector<jsi::Value> getChildNodes(
-      jsi::Runtime& rt,
-      jsi::Value nativeNodeReference);
+  std::vector<jsi::Value> getChildNodes(jsi::Runtime &rt, jsi::Value nativeNodeReference);
 
-  jsi::Value
-  getElementById(jsi::Runtime& rt, SurfaceId surfaceId, const std::string& id);
+  jsi::Value getElementById(jsi::Runtime &rt, SurfaceId surfaceId, const std::string &id);
 
-  jsi::Value getParentNode(jsi::Runtime& rt, jsi::Value nativeNodeReference);
+  jsi::Value getParentNode(jsi::Runtime &rt, jsi::Value nativeNodeReference);
 
-  bool isConnected(jsi::Runtime& rt, jsi::Value nativeNodeReference);
+  bool isConnected(jsi::Runtime &rt, jsi::Value nativeNodeReference);
 
 #pragma mark - Methods from the Element interface (for ReactNativeElement).
 
@@ -60,99 +51,70 @@ class NativeDOM : public NativeDOMCxxSpec<NativeDOM> {
       /* topWidth: */ int,
       /* rightWidth: */ int,
       /* bottomWidth: */ int,
-      /* leftWidth: */ int>
-  getBorderWidth(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode);
+      /* leftWidth: */ int> getBorderWidth(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode);
 
   std::tuple<
       /* x: */ double,
       /* y: */ double,
       /* width: */ double,
       /* height: */ double>
-  getBoundingClientRect(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      bool includeTransform);
+  getBoundingClientRect(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, bool includeTransform);
 
   std::tuple</* width: */ int, /* height: */ int> getInnerSize(
-      jsi::Runtime& rt,
+      jsi::Runtime &rt,
       std::shared_ptr<const ShadowNode> shadowNode);
 
-  std::tuple</* scrollLeft: */ double, /* scrollTop: */ double>
-  getScrollPosition(
-      jsi::Runtime& rt,
+  std::tuple</* scrollLeft: */ double, /* scrollTop: */ double> getScrollPosition(
+      jsi::Runtime &rt,
       std::shared_ptr<const ShadowNode> shadowNode);
 
   std::tuple</* scrollWidth: */ int, /* scrollHeight */ int> getScrollSize(
-      jsi::Runtime& rt,
+      jsi::Runtime &rt,
       std::shared_ptr<const ShadowNode> shadowNode);
 
-  std::string getTagName(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode);
+  std::string getTagName(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode);
 
-  std::string getTextContent(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode);
+  std::string getTextContent(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode);
 
-  bool hasPointerCapture(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      double pointerId);
+  bool hasPointerCapture(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, double pointerId);
 
-  void releasePointerCapture(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      double pointerId);
+  void releasePointerCapture(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, double pointerId);
 
-  void setPointerCapture(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      double pointerId);
+  void setPointerCapture(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, double pointerId);
 
 #pragma mark - Methods from the HTMLElement interface (for ReactNativeElement).
 
   std::tuple<
       /* offsetParent: */ jsi::Value,
       /* top: */ double,
-      /* left: */ double>
-  getOffset(jsi::Runtime& rt, std::shared_ptr<const ShadowNode> shadowNode);
+      /* left: */ double> getOffset(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode);
 
 #pragma mark - Special methods to handle the root node.
 
-  jsi::Value linkRootNode(
-      jsi::Runtime& rt,
-      SurfaceId surfaceId,
-      jsi::Value instanceHandle);
+  jsi::Value linkRootNode(jsi::Runtime &rt, SurfaceId surfaceId, jsi::Value instanceHandle);
 
 #pragma mark - Legacy layout APIs (for ReactNativeElement).
 
-  void measure(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      const MeasureOnSuccessCallback& callback);
+  void
+  measure(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, const MeasureOnSuccessCallback &callback);
 
   void measureInWindow(
-      jsi::Runtime& rt,
+      jsi::Runtime &rt,
       std::shared_ptr<const ShadowNode> shadowNode,
-      const MeasureInWindowOnSuccessCallback& callback);
+      const MeasureInWindowOnSuccessCallback &callback);
 
   void measureLayout(
-      jsi::Runtime& rt,
+      jsi::Runtime &rt,
       std::shared_ptr<const ShadowNode> shadowNode,
       std::shared_ptr<const ShadowNode> relativeToShadowNode,
       jsi::Function onFail,
-      const MeasureLayoutOnSuccessCallback& onSuccess);
+      const MeasureLayoutOnSuccessCallback &onSuccess);
 
 // [windows MSVC cant handle backtick character in a preprocessor line
 #pragma mark - Legacy direct manipulation APIs (for ReactNativeElement).
 // windows]
 
-  void setNativeProps(
-      jsi::Runtime& rt,
-      std::shared_ptr<const ShadowNode> shadowNode,
-      jsi::Value updatePayload);
+  void setNativeProps(jsi::Runtime &rt, std::shared_ptr<const ShadowNode> shadowNode, jsi::Value updatePayload);
 };
 
 } // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/nativemodule/webperformance/NativePerformance.cpp

@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996) // deprecated APIs
+#endif
+#include "NativePerformance.h"
+
+#include <memory>
+#include <unordered_map>
+#include <variant>
+
+#include <cxxreact/JSExecutor.h>
+#include <cxxreact/ReactMarker.h>
+#include <jsi/JSIDynamic.h>
+#include <jsi/instrumentation.h>
+#include <react/performance/timeline/PerformanceEntryReporter.h>
+#include <react/performance/timeline/PerformanceObserver.h>
+
+#include "NativePerformance.h"
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+#include "Plugins.h"
+#endif
+
+std::shared_ptr<facebook::react::TurboModule> NativePerformanceModuleProvider(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+  return std::make_shared<facebook::react::NativePerformance>(
+      std::move(jsInvoker));
+}
+
+namespace facebook::react {
+
+namespace {
+
+class PerformanceObserverWrapper : public jsi::NativeState {
+ public:
+  explicit PerformanceObserverWrapper(
+      const std::shared_ptr<PerformanceObserver> observer)
+      : observer(observer) {}
+
+  const std::shared_ptr<PerformanceObserver> observer;
+};
+
+void sortEntries(std::vector<PerformanceEntry>& entries) {
+  return std::stable_sort(
+      entries.begin(), entries.end(), PerformanceEntrySorter{});
+}
+
+NativePerformanceEntry toNativePerformanceEntry(const PerformanceEntry& entry) {
+  auto nativeEntry = std::visit(
+      [](const auto& entryData) -> NativePerformanceEntry {
+        return {
+            .name = entryData.name,
+            .entryType = entryData.entryType,
+            .startTime = entryData.startTime,
+            .duration = entryData.duration,
+        };
+      },
+      entry);
+
+  if (std::holds_alternative<PerformanceEventTiming>(entry)) {
+    auto eventEntry = std::get<PerformanceEventTiming>(entry);
+    nativeEntry.processingStart = eventEntry.processingStart;
+    nativeEntry.processingEnd = eventEntry.processingEnd;
+    nativeEntry.interactionId = eventEntry.interactionId;
+  }
+  if (std::holds_alternative<PerformanceResourceTiming>(entry)) {
+    auto resourceEntry = std::get<PerformanceResourceTiming>(entry);
+    nativeEntry.fetchStart = resourceEntry.fetchStart;
+    nativeEntry.requestStart = resourceEntry.requestStart;
+    nativeEntry.connectStart = resourceEntry.connectStart;
+    nativeEntry.connectEnd = resourceEntry.connectEnd;
+    nativeEntry.responseStart = resourceEntry.responseStart;
+    nativeEntry.responseEnd = resourceEntry.responseEnd;
+    nativeEntry.responseStatus = resourceEntry.responseStatus;
+    nativeEntry.contentType = resourceEntry.contentType;
+    nativeEntry.encodedBodySize = resourceEntry.encodedBodySize;
+    nativeEntry.decodedBodySize = resourceEntry.decodedBodySize;
+  }
+
+  return nativeEntry;
+}
+
+std::vector<NativePerformanceEntry> toNativePerformanceEntries(
+    std::vector<PerformanceEntry>& entries) {
+  std::vector<NativePerformanceEntry> result;
+  result.reserve(entries.size());
+
+  for (auto& entry : entries) {
+    result.emplace_back(toNativePerformanceEntry(entry));
+  }
+
+  return result;
+}
+
+const std::array<PerformanceEntryType, 2> ENTRY_TYPES_AVAILABLE_FROM_TIMELINE{
+    {PerformanceEntryType::MARK, PerformanceEntryType::MEASURE}};
+
+bool isAvailableFromTimeline(PerformanceEntryType entryType) {
+  return entryType == PerformanceEntryType::MARK ||
+      entryType == PerformanceEntryType::MEASURE;
+}
+
+std::shared_ptr<PerformanceObserver> tryGetObserver(
+    jsi::Runtime& rt,
+    jsi::Object& observerObj) {
+  if (!observerObj.hasNativeState(rt)) {
+    return nullptr;
+  }
+
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+  return observerWrapper ? observerWrapper->observer : nullptr;
+}
+
+PerformanceEntryReporter::UserTimingDetailProvider getDetailProviderFromEntry(
+    jsi::Runtime& rt,
+    jsi::Value& entry) {
+  return [&rt, &entry]() -> folly::dynamic {
+    try {
+      auto detail = entry.asObject(rt).getProperty(rt, "detail");
+      return jsi::dynamicFromValue(rt, detail);
+    } catch (jsi::JSIException&) {
+      return nullptr;
+    }
+  };
+}
+
+} // namespace
+
+NativePerformance::NativePerformance(std::shared_ptr<CallInvoker> jsInvoker)
+    : NativePerformanceCxxSpec(std::move(jsInvoker)) {}
+
+HighResTimeStamp NativePerformance::now(jsi::Runtime& /*rt*/) {
+  // This is not spec-compliant, as this is the duration from system boot to
+  // now, instead of from app startup to now.
+  // This should be carefully changed eventually.
+  return HighResTimeStamp::now();
+}
+
+HighResDuration NativePerformance::timeOrigin(jsi::Runtime& /*rt*/) {
+  // This is not spec-compliant, as this is an approximation from Unix epoch to
+  // system boot, instead of a precise duration from Unix epoch to app startup.
+  return HighResTimeStamp::unsafeOriginFromUnixTimeStamp();
+}
+
+void NativePerformance::reportMark(
+    jsi::Runtime& rt,
+    const std::string& name,
+    HighResTimeStamp startTime,
+    jsi::Value entry) {
+  PerformanceEntryReporter::getInstance()->reportMark(
+      name, startTime, getDetailProviderFromEntry(rt, entry));
+}
+
+void NativePerformance::reportMeasure(
+    jsi::Runtime& rt,
+    const std::string& name,
+    HighResTimeStamp startTime,
+    HighResDuration duration,
+    jsi::Value entry) {
+  PerformanceEntryReporter::getInstance()->reportMeasure(
+      name, startTime, duration, getDetailProviderFromEntry(rt, entry));
+}
+
+std::optional<double> NativePerformance::getMarkTime(
+    jsi::Runtime& /*rt*/,
+    const std::string& name) {
+  auto markTime = PerformanceEntryReporter::getInstance()->getMarkTime(name);
+  return markTime ? std::optional{(*markTime).toDOMHighResTimeStamp()}
+                  : std::nullopt;
+}
+
+void NativePerformance::clearMarks(
+    jsi::Runtime& /*rt*/,
+    std::optional<std::string> entryName) {
+  if (entryName) {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MARK, *entryName);
+  } else {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MARK);
+  }
+}
+
+void NativePerformance::clearMeasures(
+    jsi::Runtime& /*rt*/,
+    std::optional<std::string> entryName) {
+  if (entryName) {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MEASURE, *entryName);
+  } else {
+    PerformanceEntryReporter::getInstance()->clearEntries(
+        PerformanceEntryType::MEASURE);
+  }
+}
+
+std::vector<NativePerformanceEntry> NativePerformance::getEntries(
+    jsi::Runtime& /*rt*/) {
+  std::vector<PerformanceEntry> entries;
+
+  for (auto entryType : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
+    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
+  }
+
+  sortEntries(entries);
+
+  return toNativePerformanceEntries(entries);
+}
+
+std::vector<NativePerformanceEntry> NativePerformance::getEntriesByName(
+    jsi::Runtime& /*rt*/,
+    const std::string& entryName,
+    std::optional<PerformanceEntryType> entryType) {
+  std::vector<PerformanceEntry> entries;
+
+  if (entryType) {
+    if (isAvailableFromTimeline(*entryType)) {
+      PerformanceEntryReporter::getInstance()->getEntries(
+          entries, *entryType, entryName);
+    }
+  } else {
+    for (auto type : ENTRY_TYPES_AVAILABLE_FROM_TIMELINE) {
+      PerformanceEntryReporter::getInstance()->getEntries(
+          entries, type, entryName);
+    }
+  }
+
+  sortEntries(entries);
+
+  return toNativePerformanceEntries(entries);
+}
+
+std::vector<NativePerformanceEntry> NativePerformance::getEntriesByType(
+    jsi::Runtime& /*rt*/,
+    PerformanceEntryType entryType) {
+  std::vector<PerformanceEntry> entries;
+
+  if (isAvailableFromTimeline(entryType)) {
+    PerformanceEntryReporter::getInstance()->getEntries(entries, entryType);
+  }
+
+  sortEntries(entries);
+
+  return toNativePerformanceEntries(entries);
+}
+
+std::vector<std::pair<std::string, uint32_t>> NativePerformance::getEventCounts(
+    jsi::Runtime& /*rt*/) {
+  const auto& eventCounts =
+      PerformanceEntryReporter::getInstance()->getEventCounts();
+  return {eventCounts.begin(), eventCounts.end()};
+}
+
+std::unordered_map<std::string, double> NativePerformance::getSimpleMemoryInfo(
+    jsi::Runtime& rt) {
+  auto heapInfo = rt.instrumentation().getHeapInfo(false);
+  std::unordered_map<std::string, double> heapInfoToJs;
+  for (auto& entry : heapInfo) {
+    heapInfoToJs[entry.first] = static_cast<double>(entry.second);
+  }
+  return heapInfoToJs;
+}
+
+std::unordered_map<std::string, double>
+NativePerformance::getReactNativeStartupTiming(jsi::Runtime& /*rt*/) {
+  std::unordered_map<std::string, double> result;
+
+  ReactMarker::StartupLogger& startupLogger =
+      ReactMarker::StartupLogger::getInstance();
+  if (!std::isnan(startupLogger.getAppStartupStartTime())) {
+    result["startTime"] = startupLogger.getAppStartupStartTime();
+  } else if (!std::isnan(startupLogger.getInitReactRuntimeStartTime())) {
+    result["startTime"] = startupLogger.getInitReactRuntimeStartTime();
+  }
+
+  if (!std::isnan(startupLogger.getInitReactRuntimeStartTime())) {
+    result["initializeRuntimeStart"] =
+        startupLogger.getInitReactRuntimeStartTime();
+  }
+
+  if (!std::isnan(startupLogger.getRunJSBundleStartTime())) {
+    result["executeJavaScriptBundleEntryPointStart"] =
+        startupLogger.getRunJSBundleStartTime();
+  }
+
+  if (!std::isnan(startupLogger.getAppStartupEndTime())) {
+    result["endTime"] = startupLogger.getAppStartupEndTime();
+  }
+
+  return result;
+}
+
+jsi::Object NativePerformance::createObserver(
+    jsi::Runtime& rt,
+    NativePerformancePerformanceObserverCallback callback) {
+  // The way we dispatch performance observer callbacks is a bit different from
+  // the spec. The specification requires us to queue a single task that
+  // dispatches observer callbacks. Instead, we are queuing all callbacks as
+  // separate tasks in the scheduler.
+  PerformanceObserverCallback cb = [callback = std::move(callback)]() {
+    callback.callWithPriority(SchedulerPriority::IdlePriority);
+  };
+
+  auto& registry =
+      PerformanceEntryReporter::getInstance()->getObserverRegistry();
+
+  auto observer = PerformanceObserver::create(registry, std::move(cb));
+  auto observerWrapper = std::make_shared<PerformanceObserverWrapper>(observer);
+  jsi::Object observerObj{rt};
+  observerObj.setNativeState(rt, observerWrapper);
+  return observerObj;
+}
+
+double NativePerformance::getDroppedEntriesCount(
+    jsi::Runtime& rt,
+    jsi::Object observerObj) {
+  auto observer = tryGetObserver(rt, observerObj);
+
+  if (!observer) {
+    return 0;
+  }
+
+  return observer->getDroppedEntriesCount();
+}
+
+void NativePerformance::observe(
+    jsi::Runtime& rt,
+    jsi::Object observerObj,
+    NativePerformancePerformanceObserverObserveOptions options) {
+  auto observer = tryGetObserver(rt, observerObj);
+
+  if (!observer) {
+    return;
+  }
+
+  auto durationThreshold =
+      options.durationThreshold.value_or(HighResDuration::zero());
+
+  // observer of type multiple
+  if (options.entryTypes.has_value()) {
+    std::unordered_set<PerformanceEntryType> entryTypes;
+    auto rawTypes = options.entryTypes.value();
+
+    for (auto rawType : rawTypes) {
+      entryTypes.insert(Bridging<PerformanceEntryType>::fromJs(rt, rawType));
+    }
+
+    observer->observe(entryTypes);
+  } else { // single
+    auto buffered = options.buffered.value_or(false);
+    if (options.type.has_value()) {
+      observer->observe(
+          static_cast<PerformanceEntryType>(options.type.value()),
+          {.buffered = buffered, .durationThreshold = durationThreshold});
+    }
+  }
+}
+
+void NativePerformance::disconnect(jsi::Runtime& rt, jsi::Object observerObj) {
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+
+  if (!observerWrapper) {
+    return;
+  }
+
+  auto observer = observerWrapper->observer;
+  observer->disconnect();
+}
+
+std::vector<NativePerformanceEntry> NativePerformance::takeRecords(
+    jsi::Runtime& rt,
+    jsi::Object observerObj,
+    bool sort) {
+  auto observerWrapper = std::dynamic_pointer_cast<PerformanceObserverWrapper>(
+      observerObj.getNativeState(rt));
+
+  if (!observerWrapper) {
+    return {};
+  }
+
+  auto observer = observerWrapper->observer;
+  auto records = observer->takeRecords();
+  if (sort) {
+    sortEntries(records);
+  }
+  return toNativePerformanceEntries(records);
+}
+
+std::vector<PerformanceEntryType>
+NativePerformance::getSupportedPerformanceEntryTypes(jsi::Runtime& /*rt*/) {
+  auto supportedEntryTypes = PerformanceEntryReporter::getSupportedEntryTypes();
+  return {supportedEntryTypes.begin(), supportedEntryTypes.end()};
+}
+
+#pragma mark - Testing
+
+void NativePerformance::clearEventCountsForTesting(jsi::Runtime& /*rt*/) {
+  PerformanceEntryReporter::getInstance()->clearEventCounts();
+}
+
+} // namespace facebook::react
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif