react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactCommon/react/nativemodule/samples/platform/android/CMakeLists.txt

@@ -6,14 +6,7 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DFOLLY_NO_CONFIG=1
-        -DLOG_TAG=\"ReactNative\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB sampleturbomodule_SRC CONFIGURE_DEPENDS ReactCommon/*.cpp)
 add_library(sampleturbomodule STATIC ${sampleturbomodule_SRC})
@@ -25,3 +18,6 @@ target_link_libraries(sampleturbomodule
         jsi
         reactnative
 )
+
+target_compile_reactnative_options(sampleturbomodule PRIVATE "ReactNative")
+target_compile_options(sampleturbomodule PRIVATE -Wpedantic)

package/ReactCommon/react/nativemodule/samples/platform/android/NativeSampleTurboModuleSpec.java

@@ -141,4 +141,7 @@ public abstract class NativeSampleTurboModuleSpec extends ReactContextBaseJavaMo
 
   @ReactMethod
   public void promiseAssert(Promise promise) {}
+
+  @ReactMethod
+  public void getImageUrl(Promise promise) {}
 }

package/ReactCommon/react/nativemodule/samples/platform/android/ReactCommon/SampleTurboModuleSpec.cpp

@@ -310,6 +310,24 @@ __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert(
           cachedMethodId);
 }
 
+static facebook::jsi::Value
+__hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl(
+    facebook::jsi::Runtime& rt,
+    TurboModule& turboModule,
+    const facebook::jsi::Value* args,
+    size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule&>(turboModule)
+      .invokeJavaMethod(
+          rt,
+          PromiseKind,
+          "getImageUrl",
+          "(Lcom/facebook/react/bridge/Promise;)V",
+          args,
+          count,
+          cachedMethodId);
+}
+
 NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(
     const JavaTurboModule::InitParams& params)
     : JavaTurboModule(params) {
@@ -351,6 +369,8 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(
       1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
   methodMap_["promiseAssert"] = MethodMetadata{
       0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
+  methodMap_["getImageUrl"] = MethodMetadata{
+      0, __hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl};
   eventEmitterMap_["onPress"] =
       std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   eventEmitterMap_["onClick"] =
@@ -359,7 +379,7 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(
       std::make_shared<AsyncEventEmitter<folly::dynamic>>();
   eventEmitterMap_["onSubmit"] =
       std::make_shared<AsyncEventEmitter<folly::dynamic>>();
-  setEventEmitterCallback(params.instance);
+  configureEventEmitterCallback();
 }
 
 std::shared_ptr<TurboModule> SampleTurboModuleSpec_ModuleProvider(

package/ReactCommon/react/nativemodule/samples/platform/android/SampleTurboModule.kt

@@ -7,9 +7,12 @@
 
 package com.facebook.fbreact.specs
 
+import android.net.Uri
 import android.os.Build
 import android.util.DisplayMetrics
 import android.widget.Toast
+import androidx.activity.ComponentActivity
+import androidx.activity.result.contract.ActivityResultContracts
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
@@ -24,6 +27,7 @@ import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
 import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+import java.util.UUID
 
 @DoNotStrip
 @ReactModule(name = SampleTurboModule.NAME)
@@ -172,7 +176,7 @@ public class SampleTurboModule(private val context: ReactApplicationContext) :
 
   @DoNotStrip
   @Suppress("unused")
-  override fun getValueWithPromise(error: Boolean, promise: Promise?) {
+  override fun getValueWithPromise(error: Boolean, promise: Promise) {
     if (error) {
       promise?.reject(
           "code 1", "intentional promise rejection", Throwable("promise intentionally rejected"))
@@ -189,13 +193,13 @@ public class SampleTurboModule(private val context: ReactApplicationContext) :
 
   @DoNotStrip
   @Suppress("unused")
-  override fun getObjectThrows(arg: ReadableMap?): WritableMap? {
+  override fun getObjectThrows(arg: ReadableMap): WritableMap {
     error("Intentional exception from JVM getObjectThrows with $arg")
   }
 
   @DoNotStrip
   @Suppress("unused")
-  override fun promiseThrows(promise: Promise?) {
+  override fun promiseThrows(promise: Promise) {
     error("Intentional exception from JVM promiseThrows")
   }
 
@@ -207,17 +211,40 @@ public class SampleTurboModule(private val context: ReactApplicationContext) :
 
   @DoNotStrip
   @Suppress("unused")
-  override fun getObjectAssert(arg: ReadableMap?): WritableMap? {
+  override fun getObjectAssert(arg: ReadableMap): WritableMap? {
     assert(false) { "Intentional assert from JVM getObjectAssert with $arg" }
     return null
   }
 
   @DoNotStrip
   @Suppress("unused")
-  override fun promiseAssert(promise: Promise?) {
+  override fun promiseAssert(promise: Promise) {
     assert(false) { "Intentional assert from JVM promiseAssert" }
   }
 
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getImageUrl(promise: Promise) {
+    val activity = context.getCurrentActivity() as? ComponentActivity
+    if (activity != null) {
+      val key = UUID.randomUUID().toString()
+      activity.activityResultRegistry
+          .register(
+              key,
+              ActivityResultContracts.GetContent(),
+              { uri: Uri? ->
+                if (uri != null) {
+                  promise.resolve(uri.toString())
+                } else {
+                  promise.resolve(null)
+                }
+              })
+          .launch("image/*")
+    } else {
+      promise.reject("error", "Unable to obtain an image uri without current activity")
+    }
+  }
+
   private fun log(method: String, input: Any?, output: Any?) {
     toast?.cancel()
     val message = StringBuilder("Method :")

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleLegacyModule.mm

@@ -39,16 +39,11 @@ RCT_EXPORT_MODULE()
 
 - (NSDictionary *)getConstants
 {
-  __block NSDictionary *constants;
-  RCTUnsafeExecuteOnMainQueueSync(^{
-    constants = @{
-      @"const1" : @YES,
-      @"const2" : @(390),
-      @"const3" : @"something",
-    };
-  });
-
-  return constants;
+  return @{
+    @"const1" : @YES,
+    @"const2" : @(390),
+    @"const3" : @"something",
+  };
 }
 
 // TODO: Remove once fully migrated to TurboModule.

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.mm

@@ -9,16 +9,19 @@
 #import "RCTSampleTurboModulePlugin.h"
 
 #import <React/RCTAssert.h>
+#import <React/RCTInitializing.h>
 #import <React/RCTUtils.h>
 #import <ReactCommon/RCTTurboModuleWithJSIBindings.h>
 #import <UIKit/UIKit.h>
 
 using namespace facebook::react;
 
-@interface RCTSampleTurboModule () <RCTTurboModuleWithJSIBindings>
+@interface RCTSampleTurboModule () <RCTTurboModuleWithJSIBindings, RCTInitializing>
 @end
 
-@implementation RCTSampleTurboModule
+@implementation RCTSampleTurboModule {
+  NSDictionary *_constants;
+}
 
 // Backward-compatible export
 RCT_EXPORT_MODULE()
@@ -29,6 +32,18 @@ RCT_EXPORT_MODULE()
   return YES;
 }
 
+- (void)initialize
+{
+  UIScreen *mainScreen = UIScreen.mainScreen;
+  CGSize screenSize = mainScreen.bounds.size;
+
+  _constants = @{
+    @"const1" : @YES,
+    @"const2" : @(screenSize.width),
+    @"const3" : @"something",
+  };
+}
+
 - (dispatch_queue_t)methodQueue
 {
   return dispatch_get_main_queue();
@@ -49,19 +64,7 @@ RCT_EXPORT_MODULE()
 
 - (NSDictionary *)getConstants
 {
-  __block NSDictionary *constants;
-  RCTUnsafeExecuteOnMainQueueSync(^{
-    UIScreen *mainScreen = UIScreen.mainScreen;
-    CGSize screenSize = mainScreen.bounds.size;
-
-    constants = @{
-      @"const1" : @YES,
-      @"const2" : @(screenSize.width),
-      @"const3" : @"something",
-    };
-  });
-
-  return constants;
+  return _constants;
 }
 
 // TODO: Remove once fully migrated to TurboModule.

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

@@ -8,8 +8,8 @@
 #include "NativePerformance.h"
 
 #include <memory>
-#include <mutex>
 #include <unordered_map>
+#include <variant>
 
 #include <cxxreact/JSExecutor.h>
 #include <cxxreact/ReactMarker.h>
@@ -47,6 +47,50 @@ void sortEntries(std::vector<PerformanceEntry>& entries) {
       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;
+  }
+
+  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}};
 
@@ -122,7 +166,7 @@ void NativePerformance::clearMeasures(
   }
 }
 
-std::vector<PerformanceEntry> NativePerformance::getEntries(
+std::vector<NativePerformanceEntry> NativePerformance::getEntries(
     jsi::Runtime& /*rt*/) {
   std::vector<PerformanceEntry> entries;
 
@@ -132,10 +176,10 @@ std::vector<PerformanceEntry> NativePerformance::getEntries(
 
   sortEntries(entries);
 
-  return entries;
+  return toNativePerformanceEntries(entries);
 }
 
-std::vector<PerformanceEntry> NativePerformance::getEntriesByName(
+std::vector<NativePerformanceEntry> NativePerformance::getEntriesByName(
     jsi::Runtime& /*rt*/,
     std::string entryName,
     std::optional<PerformanceEntryType> entryType) {
@@ -155,10 +199,10 @@ std::vector<PerformanceEntry> NativePerformance::getEntriesByName(
 
   sortEntries(entries);
 
-  return entries;
+  return toNativePerformanceEntries(entries);
 }
 
-std::vector<PerformanceEntry> NativePerformance::getEntriesByType(
+std::vector<NativePerformanceEntry> NativePerformance::getEntriesByType(
     jsi::Runtime& /*rt*/,
     PerformanceEntryType entryType) {
   std::vector<PerformanceEntry> entries;
@@ -169,7 +213,7 @@ std::vector<PerformanceEntry> NativePerformance::getEntriesByType(
 
   sortEntries(entries);
 
-  return entries;
+  return toNativePerformanceEntries(entries);
 }
 
 std::vector<std::pair<std::string, uint32_t>> NativePerformance::getEventCounts(
@@ -304,7 +348,7 @@ void NativePerformance::disconnect(jsi::Runtime& rt, jsi::Object observerObj) {
   observer->disconnect();
 }
 
-std::vector<PerformanceEntry> NativePerformance::takeRecords(
+std::vector<NativePerformanceEntry> NativePerformance::takeRecords(
     jsi::Runtime& rt,
     jsi::Object observerObj,
     bool sort) {
@@ -320,7 +364,7 @@ std::vector<PerformanceEntry> NativePerformance::takeRecords(
   if (sort) {
     sortEntries(records);
   }
-  return records;
+  return toNativePerformanceEntries(records);
 }
 
 std::vector<PerformanceEntryType>

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.h

@@ -49,9 +49,32 @@ struct Bridging<PerformanceEntryType> {
   }
 };
 
+// Our Native Module codegen does not support JS type unions, so we use a
+// flattened object here as an intermediate format.
+struct NativePerformanceEntry {
+  std::string name;
+  PerformanceEntryType entryType;
+  DOMHighResTimeStamp startTime;
+  DOMHighResTimeStamp duration;
+
+  // For PerformanceEventTiming only
+  std::optional<DOMHighResTimeStamp> processingStart;
+  std::optional<DOMHighResTimeStamp> processingEnd;
+  std::optional<PerformanceEntryInteractionId> interactionId;
+
+  // For PerformanceResourceTiming only
+  std::optional<DOMHighResTimeStamp> fetchStart;
+  std::optional<DOMHighResTimeStamp> requestStart;
+  std::optional<DOMHighResTimeStamp> connectStart;
+  std::optional<DOMHighResTimeStamp> connectEnd;
+  std::optional<DOMHighResTimeStamp> responseStart;
+  std::optional<DOMHighResTimeStamp> responseEnd;
+  std::optional<int> responseStatus;
+};
+
 template <>
-struct Bridging<PerformanceEntry>
-    : NativePerformanceRawPerformanceEntryBridging<PerformanceEntry> {};
+struct Bridging<NativePerformanceEntry>
+    : NativePerformanceRawPerformanceEntryBridging<NativePerformanceEntry> {};
 
 template <>
 struct Bridging<NativePerformancePerformanceObserverObserveOptions>
@@ -98,15 +121,15 @@ class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
 #pragma mark - Performance Timeline (https://w3c.github.io/performance-timeline/#performance-timeline)
 
   // https://www.w3.org/TR/performance-timeline/#getentries-method
-  std::vector<PerformanceEntry> getEntries(jsi::Runtime& rt);
+  std::vector<NativePerformanceEntry> getEntries(jsi::Runtime& rt);
 
   // https://www.w3.org/TR/performance-timeline/#getentriesbytype-method
-  std::vector<PerformanceEntry> getEntriesByType(
+  std::vector<NativePerformanceEntry> getEntriesByType(
       jsi::Runtime& rt,
       PerformanceEntryType entryType);
 
   // https://www.w3.org/TR/performance-timeline/#getentriesbyname-method
-  std::vector<PerformanceEntry> getEntriesByName(
+  std::vector<NativePerformanceEntry> getEntriesByName(
       jsi::Runtime& rt,
       std::string entryName,
       std::optional<PerformanceEntryType> entryType = std::nullopt);
@@ -125,7 +148,7 @@ class NativePerformance : public NativePerformanceCxxSpec<NativePerformance> {
       jsi::Object observer,
       NativePerformancePerformanceObserverObserveOptions options);
   void disconnect(jsi::Runtime& rt, jsi::Object observer);
-  std::vector<PerformanceEntry> takeRecords(
+  std::vector<NativePerformanceEntry> takeRecords(
       jsi::Runtime& rt,
       jsi::Object observerObj,
       // When called via `observer.takeRecords` it should be in insertion order.

package/ReactCommon/react/performance/timeline/CMakeLists.txt

@@ -6,20 +6,16 @@
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-add_compile_options(
-        -fexceptions
-        -frtti
-        -std=c++20
-        -Wall
-        -Wpedantic
-        -DLOG_TAG=\"ReactNative\")
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
 
 file(GLOB react_performance_timeline_SRC CONFIGURE_DEPENDS *.cpp)
 add_library(react_performance_timeline OBJECT ${react_performance_timeline_SRC})
 
+target_compile_reactnative_options(react_performance_timeline PRIVATE "ReactNative")
+target_compile_options(react_performance_timeline PRIVATE -Wpedantic)
+
 target_include_directories(react_performance_timeline PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_performance_timeline
         jsinspector_tracing
         reactperflogger
-        react_timing
-        react_cxxreact)
+        react_timing)

package/ReactCommon/react/performance/timeline/CircularBuffer.h

@@ -10,7 +10,6 @@
 #include <algorithm>
 #include <functional>
 #include <vector>
-#include "PerformanceEntry.h"
 
 namespace facebook::react {
 

package/ReactCommon/react/performance/timeline/PerformanceEntry.h

@@ -10,7 +10,7 @@
 #include <react/timing/primitives.h>
 #include <optional>
 #include <string>
-#include <unordered_set>
+#include <variant>
 
 namespace facebook::react {
 
@@ -22,31 +22,69 @@ enum class PerformanceEntryType {
   MEASURE = 2,
   EVENT = 3,
   LONGTASK = 4,
-  _NEXT = 5,
+  RESOURCE = 5,
+  _NEXT = 6,
 };
 
-struct PerformanceEntry {
+struct AbstractPerformanceEntry {
   std::string name;
-  PerformanceEntryType entryType;
   DOMHighResTimeStamp startTime;
   DOMHighResTimeStamp duration = 0;
+};
+
+struct PerformanceMark : AbstractPerformanceEntry {
+  static constexpr PerformanceEntryType entryType = PerformanceEntryType::MARK;
+};
+
+struct PerformanceMeasure : AbstractPerformanceEntry {
+  static constexpr PerformanceEntryType entryType =
+      PerformanceEntryType::MEASURE;
+};
+
+struct PerformanceEventTiming : AbstractPerformanceEntry {
+  static constexpr PerformanceEntryType entryType = PerformanceEntryType::EVENT;
+  DOMHighResTimeStamp processingStart;
+  DOMHighResTimeStamp processingEnd;
+  PerformanceEntryInteractionId interactionId;
+};
+
+struct PerformanceLongTaskTiming : AbstractPerformanceEntry {
+  static constexpr PerformanceEntryType entryType =
+      PerformanceEntryType::LONGTASK;
+};
 
-  // For "event" entries only:
-  std::optional<DOMHighResTimeStamp> processingStart;
-  std::optional<DOMHighResTimeStamp> processingEnd;
-  std::optional<PerformanceEntryInteractionId> interactionId;
+struct PerformanceResourceTiming : AbstractPerformanceEntry {
+  static constexpr PerformanceEntryType entryType =
+      PerformanceEntryType::RESOURCE;
+  /** Aligns with `startTime`. */
+  std::optional<DOMHighResTimeStamp> fetchStart;
+  std::optional<DOMHighResTimeStamp> requestStart;
+  std::optional<DOMHighResTimeStamp> connectStart;
+  std::optional<DOMHighResTimeStamp> connectEnd;
+  std::optional<DOMHighResTimeStamp> responseStart;
+  /** Aligns with `duration`. */
+  std::optional<DOMHighResTimeStamp> responseEnd;
+  std::optional<int> responseStatus;
 };
 
-constexpr size_t NUM_PERFORMANCE_ENTRY_TYPES =
-    (size_t)PerformanceEntryType::_NEXT - 1; // Valid types start from 1.
+using PerformanceEntry = std::variant<
+    PerformanceMark,
+    PerformanceMeasure,
+    PerformanceEventTiming,
+    PerformanceLongTaskTiming,
+    PerformanceResourceTiming>;
 
 struct PerformanceEntrySorter {
   bool operator()(const PerformanceEntry& lhs, const PerformanceEntry& rhs) {
-    if (lhs.startTime != rhs.startTime) {
-      return lhs.startTime < rhs.startTime;
-    } else {
-      return lhs.duration < rhs.duration;
-    }
+    return std::visit(
+        [](const auto& left, const auto& right) {
+          if (left.startTime != right.startTime) {
+            return left.startTime < right.startTime;
+          }
+          return left.duration < right.duration;
+        },
+        lhs,
+        rhs);
   }
 };
 

package/ReactCommon/react/performance/timeline/PerformanceEntryCircularBuffer.cpp

@@ -7,6 +7,8 @@
 
 #include "PerformanceEntryCircularBuffer.h"
 
+#include <variant>
+
 namespace facebook::react {
 
 void PerformanceEntryCircularBuffer::add(const PerformanceEntry& entry) {
@@ -23,8 +25,11 @@ void PerformanceEntryCircularBuffer::getEntries(
 void PerformanceEntryCircularBuffer::getEntries(
     std::vector<PerformanceEntry>& target,
     const std::string& name) const {
-  buffer_.getEntries(
-      target, [&](const PerformanceEntry& e) { return e.name == name; });
+  buffer_.getEntries(target, [&](const PerformanceEntry& entry) {
+    return std::visit(
+        [&name](const auto& entryData) { return entryData.name == name; },
+        entry);
+  });
 }
 
 void PerformanceEntryCircularBuffer::clear() {
@@ -32,7 +37,11 @@ void PerformanceEntryCircularBuffer::clear() {
 }
 
 void PerformanceEntryCircularBuffer::clear(const std::string& name) {
-  buffer_.clear([&](const PerformanceEntry& e) { return e.name == name; });
+  buffer_.clear([&](const PerformanceEntry& entry) {
+    return std::visit(
+        [&name](const auto& entryData) { return entryData.name == name; },
+        entry);
+  });
 }
 
 } // namespace facebook::react

package/ReactCommon/react/performance/timeline/PerformanceEntryKeyedBuffer.cpp

@@ -11,12 +11,15 @@
 namespace facebook::react {
 
 void PerformanceEntryKeyedBuffer::add(const PerformanceEntry& entry) {
-  auto node = entryMap_.find(entry.name);
+  auto name =
+      std::visit([](const auto& entryData) { return entryData.name; }, entry);
+
+  auto node = entryMap_.find(name);
 
   if (node != entryMap_.end()) {
     node->second.push_back(entry);
   } else {
-    entryMap_.emplace(entry.name, std::vector<PerformanceEntry>{entry});
+    entryMap_.emplace(name, std::vector<PerformanceEntry>{entry});
   }
 }
 

package/ReactCommon/react/performance/timeline/PerformanceEntryKeyedBuffer.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <optional>
-#include <string_view>
 #include <unordered_map>
 #include <vector>
 #include "PerformanceEntryBuffer.h"