react-native-windows 0.82.0-preview.4 → 0.82.0-preview.5

package/Libraries/Animated/nodes/AnimatedValue.js

@@ -18,7 +18,6 @@ import type {AnimatedNodeConfig} from './AnimatedNode';
 import type AnimatedTracking from './AnimatedTracking';
 
 import NativeAnimatedHelper from '../../../src/private/animated/NativeAnimatedHelper';
-import InteractionManager from '../../Interaction/InteractionManager';
 import AnimatedInterpolation from './AnimatedInterpolation';
 import AnimatedWithChildren from './AnimatedWithChildren';
 
@@ -312,10 +311,6 @@ export default class AnimatedValue extends AnimatedWithChildren {
    * See https://reactnative.dev/docs/animatedvalue#animate
    */
   animate(animation: Animation, callback: ?EndCallback): void {
-    let handle = null;
-    if (animation.__isInteraction) {
-      handle = InteractionManager.createInteractionHandle();
-    }
     const previousAnimation = this._animation;
     this._animation && this._animation.stop();
     this._animation = animation;
@@ -328,9 +323,6 @@ export default class AnimatedValue extends AnimatedWithChildren {
       },
       result => {
         this._animation = null;
-        if (handle !== null) {
-          InteractionManager.clearInteractionHandle(handle);
-        }
         callback && callback(result);
       },
       previousAnimation,

package/Libraries/BatchedBridge/BatchedBridge.js

@@ -6,6 +6,7 @@
  *
  * @flow strict
  * @format
+ * @deprecated
  */
 
 'use strict';

package/Libraries/BatchedBridge/MessageQueue.js

@@ -6,6 +6,7 @@
  *
  * @flow strict
  * @format
+ * @deprecated
  */
 
 'use strict';

package/Libraries/Components/Switch/Switch.js

@@ -264,7 +264,7 @@ const Switch: component(
       disabled,
       onTintColor: trackColorForTrue,
       style: StyleSheet.compose(
-        {height: 31, width: 51},
+        {alignSelf: 'flex-start' as const},
         StyleSheet.compose(
           style,
           ios_backgroundColor == null

package/Libraries/Components/Switch/Switch.windows.js

@@ -272,7 +272,7 @@ const Switch: component(
       disabled,
       onTintColor: trackColorForTrue,
       style: StyleSheet.compose(
-        {height: 31, width: 51},
+        {alignSelf: 'flex-start' as const},
         StyleSheet.compose(
           style,
           ios_backgroundColor == null

package/Libraries/Core/ReactNativeVersion.js

@@ -28,8 +28,8 @@
 export default class ReactNativeVersion {
   static major: number = 0;
   static minor: number = 82;
-  static patch: number = 0;
-  static prerelease: string | null = 'rc.0';
+  static patch: number = 1;
+  static prerelease: string | null = null;
 
   static getVersionString(): string {
     return `${this.major}.${this.minor}.${this.patch}${this.prerelease != null ? `-${this.prerelease}` : ''}`;

package/Libraries/Core/Timers/JSTimers.js

@@ -6,6 +6,7 @@
  *
  * @flow
  * @format
+ * @deprecated
  */
 
 import NativeTiming from './NativeTiming';

package/Libraries/Core/Timers/NativeTiming.js

@@ -6,6 +6,7 @@
  *
  * @flow strict
  * @format
+ * @deprecated
  */
 
 export * from '../../../src/private/specs_DEPRECATED/modules/NativeTiming';

package/Libraries/Core/Timers/immediateShim.js

@@ -6,6 +6,7 @@
  *
  * @flow
  * @format
+ * @deprecated
  */
 
 'use strict';

package/Libraries/Core/setUpPerformance.js

@@ -4,19 +4,17 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 
+import setUpPerformanceModern from '../../src/private/setup/setUpPerformanceModern';
 import NativePerformance from '../../src/private/webapis/performance/specs/NativePerformance';
 
 // In case if the native implementation of the Performance API is available, use it,
 // otherwise fall back to the legacy/default one, which only defines 'Performance.now()'
 if (NativePerformance) {
-  const Performance =
-    require('../../src/private/webapis/performance/Performance').default;
-  // $FlowExpectedError[cannot-write]
-  global.performance = new Performance();
+  setUpPerformanceModern();
 } else {
   if (!global.performance) {
     // $FlowExpectedError[cannot-write]

package/Libraries/Interaction/PanResponder.js

@@ -12,7 +12,6 @@
 
 import type {GestureResponderEvent} from '../Types/CoreEventTypes';
 
-const InteractionManager = require('./InteractionManager').default;
 const TouchHistoryMath = require('./TouchHistoryMath').default;
 
 const currentCentroidXOfTouchesChangedAfter =
@@ -31,9 +30,6 @@ const currentCentroidY = TouchHistoryMath.currentCentroidY;
  * single-touch gestures resilient to extra touches, and can be used to
  * recognize simple multi-touch gestures.
  *
- * By default, `PanResponder` holds an `InteractionManager` handle to block
- * long-running JS events from interrupting active gestures.
- *
  * It provides a predictable wrapper of the responder handlers provided by the
  * [gesture responder system](docs/gesture-responder-system.html).
  * For each handler, it provides a new `gestureState` object alongside the
@@ -405,9 +401,6 @@ const PanResponder = {
     getInteractionHandle: () => ?number,
     panHandlers: GestureResponderHandlerMethods,
   } {
-    const interactionState = {
-      handle: (null: ?number),
-    };
     const gestureState: PanResponderGestureState = {
       // Useful for debugging
       stateID: Math.random(),
@@ -464,10 +457,6 @@ const PanResponder = {
       },
 
       onResponderGrant(event: GestureResponderEvent): boolean {
-        if (!interactionState.handle) {
-          interactionState.handle =
-            InteractionManager.createInteractionHandle();
-        }
         gestureState.x0 = currentCentroidX(event.touchHistory);
         gestureState.y0 = currentCentroidY(event.touchHistory);
         gestureState.dx = 0;
@@ -482,21 +471,11 @@ const PanResponder = {
       },
 
       onResponderReject(event: GestureResponderEvent): void {
-        clearInteractionHandle(
-          interactionState,
-          config.onPanResponderReject,
-          event,
-          gestureState,
-        );
+        config.onPanResponderReject?.call(undefined, event, gestureState);
       },
 
       onResponderRelease(event: GestureResponderEvent): void {
-        clearInteractionHandle(
-          interactionState,
-          config.onPanResponderRelease,
-          event,
-          gestureState,
-        );
+        config.onPanResponderRelease?.call(undefined, event, gestureState);
         PanResponder._initializeGestureState(gestureState);
       },
 
@@ -529,21 +508,11 @@ const PanResponder = {
       onResponderEnd(event: GestureResponderEvent): void {
         const touchHistory = event.touchHistory;
         gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
-        clearInteractionHandle(
-          interactionState,
-          config.onPanResponderEnd,
-          event,
-          gestureState,
-        );
+        config.onPanResponderEnd?.call(undefined, event, gestureState);
       },
 
       onResponderTerminate(event: GestureResponderEvent): void {
-        clearInteractionHandle(
-          interactionState,
-          config.onPanResponderTerminate,
-          event,
-          gestureState,
-        );
+        config.onPanResponderTerminate?.call(undefined, event, gestureState);
         PanResponder._initializeGestureState(gestureState);
       },
 
@@ -556,27 +525,13 @@ const PanResponder = {
     return {
       panHandlers,
       getInteractionHandle(): ?number {
-        return interactionState.handle;
+        // TODO: Deprecate and delete this method.
+        return null;
       },
     };
   },
 };
 
-function clearInteractionHandle(
-  interactionState: {handle: ?number, ...},
-  callback: ?(ActiveCallback | PassiveCallback),
-  event: GestureResponderEvent,
-  gestureState: PanResponderGestureState,
-) {
-  if (interactionState.handle) {
-    InteractionManager.clearInteractionHandle(interactionState.handle);
-    interactionState.handle = null;
-  }
-  if (callback) {
-    callback(event, gestureState);
-  }
-}
-
 export type PanResponderInstance = ReturnType<(typeof PanResponder)['create']>;
 
 export default PanResponder;

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

@@ -171,6 +171,26 @@ void ParagraphComponentView::updateTextAlignment(
   m_textLayout = nullptr;
 }
 
+facebook::react::Tag ParagraphComponentView::hitTest(
+    facebook::react::Point pt,
+    facebook::react::Point &localPt,
+    bool ignorePointerEvents) const noexcept {
+  facebook::react::Point ptLocal{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+  const auto &props = paragraphProps();
+  const auto &vProps = *viewProps();
+
+  if (props.isSelectable && ptLocal.x >= 0 && ptLocal.x <= m_layoutMetrics.frame.size.width && ptLocal.y >= 0 &&
+      ptLocal.y <= m_layoutMetrics.frame.size.height) {
+    // claims if pointer events are enabled for this component
+    if (ignorePointerEvents || vProps.pointerEvents == facebook::react::PointerEventsMode::Auto ||
+        vProps.pointerEvents == facebook::react::PointerEventsMode::BoxOnly) {
+      localPt = ptLocal;
+      return Tag();
+    }
+  }
+  return Super::hitTest(pt, localPt, ignorePointerEvents);
+}
+
 bool ParagraphComponentView::IsTextSelectableAtPoint(facebook::react::Point pt) noexcept {
   // paragraph-level selectable prop is enabled
   const auto &props = paragraphProps();
@@ -543,7 +563,8 @@ void ParagraphComponentView::OnPointerPressed(
     return;
   }
 
-  auto pp = args.GetCurrentPoint(-1);
+  // Use Tag() to get coordinates in component's local space
+  auto pp = args.GetCurrentPoint(static_cast<int32_t>(Tag()));
 
   // Ignores right-click
   if (pp.Properties().PointerUpdateKind() ==
@@ -554,8 +575,8 @@ void ParagraphComponentView::OnPointerPressed(
 
   auto position = pp.Position();
 
-  facebook::react::Point localPt{
-      position.X - m_layoutMetrics.frame.origin.x, position.Y - m_layoutMetrics.frame.origin.y};
+  // GetCurrentPoint(Tag()) returns position relative to component origin
+  facebook::react::Point localPt{position.X, position.Y};
 
   std::optional<int32_t> charPosition = GetTextPositionAtPoint(localPt);
 
@@ -629,7 +650,7 @@ void ParagraphComponentView::OnPointerMoved(
 void ParagraphComponentView::OnPointerReleased(
     const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
   // Check for right-click to show context menu
-  auto pp = args.GetCurrentPoint(-1);
+  auto pp = args.GetCurrentPoint(static_cast<int32_t>(Tag()));
   if (pp.Properties().PointerUpdateKind() ==
       winrt::Microsoft::ReactNative::Composition::Input::PointerUpdateKind::RightButtonReleased) {
     const auto &props = paragraphProps();

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

@@ -49,6 +49,11 @@ struct ParagraphComponentView : ParagraphComponentViewT<ParagraphComponentView,
   static facebook::react::SharedViewProps defaultProps() noexcept;
   const facebook::react::ParagraphProps &paragraphProps() const noexcept;
 
+  facebook::react::Tag hitTest(
+      facebook::react::Point pt,
+      facebook::react::Point &localPt,
+      bool ignorePointerEvents = false) const noexcept override;
+
   // Returns true when text is selectable
   bool focusable() const noexcept override;
 

package/Microsoft.ReactNative.Cxx/ReactCommon/react/timing/primitives.h

@@ -201,6 +201,11 @@ class HighResTimeStamp {
     return HighResTimeStamp(chronoNow());
   }
 
+  static HighResDuration unsafeOriginFromUnixTimeStamp() noexcept {
+    static auto origin = computeUnsafeOriginFromUnixTimeStamp();
+    return origin;
+  }
+
   static constexpr HighResTimeStamp min() noexcept {
     return HighResTimeStamp(std::chrono::steady_clock::time_point::min());
   }
@@ -285,6 +290,13 @@ class HighResTimeStamp {
 
   std::chrono::steady_clock::time_point chronoTimePoint_;
 
+  static HighResDuration computeUnsafeOriginFromUnixTimeStamp() noexcept {
+    auto systemNow = std::chrono::system_clock::now();
+    auto steadyNow = std::chrono::steady_clock::now();
+    return HighResDuration(
+        systemNow.time_since_epoch() - steadyNow.time_since_epoch());
+  }
+
 #ifdef REACT_NATIVE_DEBUG
   static std::function<std::chrono::steady_clock::time_point()>&
   getTimeStampProvider() {

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.82.0-preview.4</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.82.0-preview.5</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>82</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>d0841de690130ed16982e9ba6a944a73e67f85d6</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>9486be369921a08663e2b5227dda13cbc7ad5388</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Shared.vcxitems

@@ -444,6 +444,7 @@
     <CLCompile Include="$(ReactNativeDir)\ReactCommon\react\nativemodule\featureflags\NativeReactNativeFeatureFlags.cpp" />
     <CLCompile Include="$(ReactNativeDir)\ReactCommon\react\nativemodule\dom\NativeDOM.cpp" DisableSpecificWarnings="4715;%(DisableSpecificWarnings)" />
     <CLCompile Include="$(ReactNativeDir)\ReactCommon\react\nativemodule\idlecallbacks\NativeIdleCallbacks.cpp" />
+    <CLCompile Include="$(ReactNativeDir)\ReactCommon\react\nativemodule\webperformance\NativePerformance.cpp" DisableSpecificWarnings="4996;%(DisableSpecificWarnings)" />
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\react\renderer\attributedstring\AttributedString.cpp" />
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\react\renderer\attributedstring\AttributedStringBox.cpp" DisableSpecificWarnings="4715;%(DisableSpecificWarnings)" />
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\react\renderer\components\view\BaseViewProps.cpp" DisableSpecificWarnings="4459;4715;%(DisableSpecificWarnings)" />

package/codegen/NativePerformanceSpec.g.h

@@ -94,24 +94,25 @@ inline winrt::Microsoft::ReactNative::FieldMap GetStructInfo(PerformanceSpec_Rea
 struct PerformanceSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       SyncMethod<double() noexcept>{0, L"now"},
-      Method<void(std::string, double, ) noexcept>{1, L"reportMark"},
-      Method<void(std::string, double, double, ) noexcept>{2, L"reportMeasure"},
-      SyncMethod<std::optional<double>(std::string) noexcept>{3, L"getMarkTime"},
-      Method<void(std::string) noexcept>{4, L"clearMarks"},
-      Method<void(std::string) noexcept>{5, L"clearMeasures"},
-      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>() noexcept>{6, L"getEntries"},
-      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(std::string, std::optional<double>) noexcept>{7, L"getEntriesByName"},
-      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(double) noexcept>{8, L"getEntriesByType"},
-      SyncMethod<::React::JSValueArray() noexcept>{9, L"getEventCounts"},
-      SyncMethod<::React::JSValue() noexcept>{10, L"getSimpleMemoryInfo"},
-      SyncMethod<::React::JSValue() noexcept>{11, L"getReactNativeStartupTiming"},
-      SyncMethod<(Callback<>) noexcept>{12, L"createObserver"},
-      SyncMethod<double() noexcept>{13, L"getDroppedEntriesCount"},
-      Method<void(, PerformanceSpec_PerformanceObserverInit) noexcept>{14, L"observe"},
-      Method<void() noexcept>{15, L"disconnect"},
-      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(, bool) noexcept>{16, L"takeRecords"},
-      SyncMethod<std::vector<double>() noexcept>{17, L"getSupportedPerformanceEntryTypes"},
-      Method<void() noexcept>{18, L"clearEventCountsForTesting"},
+      SyncMethod<double() noexcept>{1, L"timeOrigin"},
+      Method<void(std::string, double, ) noexcept>{2, L"reportMark"},
+      Method<void(std::string, double, double, ) noexcept>{3, L"reportMeasure"},
+      SyncMethod<std::optional<double>(std::string) noexcept>{4, L"getMarkTime"},
+      Method<void(std::string) noexcept>{5, L"clearMarks"},
+      Method<void(std::string) noexcept>{6, L"clearMeasures"},
+      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>() noexcept>{7, L"getEntries"},
+      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(std::string, std::optional<double>) noexcept>{8, L"getEntriesByName"},
+      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(double) noexcept>{9, L"getEntriesByType"},
+      SyncMethod<::React::JSValueArray() noexcept>{10, L"getEventCounts"},
+      SyncMethod<::React::JSValue() noexcept>{11, L"getSimpleMemoryInfo"},
+      SyncMethod<::React::JSValue() noexcept>{12, L"getReactNativeStartupTiming"},
+      SyncMethod<(Callback<>) noexcept>{13, L"createObserver"},
+      SyncMethod<double() noexcept>{14, L"getDroppedEntriesCount"},
+      Method<void(, PerformanceSpec_PerformanceObserverInit) noexcept>{15, L"observe"},
+      Method<void() noexcept>{16, L"disconnect"},
+      SyncMethod<std::vector<PerformanceSpec_RawPerformanceEntry>(, bool) noexcept>{17, L"takeRecords"},
+      SyncMethod<std::vector<double>() noexcept>{18, L"getSupportedPerformanceEntryTypes"},
+      Method<void() noexcept>{19, L"clearEventCountsForTesting"},
   };
 
   template <class TModule>
@@ -125,91 +126,96 @@ struct PerformanceSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
           "    REACT_SYNC_METHOD(now) static double now() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
+          "timeOrigin",
+          "    REACT_SYNC_METHOD(timeOrigin) double timeOrigin() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(timeOrigin) static double timeOrigin() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
           "reportMark",
           "    REACT_METHOD(reportMark) void reportMark(std::string name, double startTime,  entry) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(reportMark) static void reportMark(std::string name, double startTime,  entry) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          2,
+          3,
           "reportMeasure",
           "    REACT_METHOD(reportMeasure) void reportMeasure(std::string name, double startTime, double duration,  entry) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(reportMeasure) static void reportMeasure(std::string name, double startTime, double duration,  entry) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          3,
+          4,
           "getMarkTime",
           "    REACT_SYNC_METHOD(getMarkTime) std::optional<double> getMarkTime(std::string name) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getMarkTime) static std::optional<double> getMarkTime(std::string name) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          4,
+          5,
           "clearMarks",
           "    REACT_METHOD(clearMarks) void clearMarks(std::string entryName) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(clearMarks) static void clearMarks(std::string entryName) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          5,
+          6,
           "clearMeasures",
           "    REACT_METHOD(clearMeasures) void clearMeasures(std::string entryName) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(clearMeasures) static void clearMeasures(std::string entryName) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          6,
+          7,
           "getEntries",
           "    REACT_SYNC_METHOD(getEntries) std::vector<PerformanceSpec_RawPerformanceEntry> getEntries() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getEntries) static std::vector<PerformanceSpec_RawPerformanceEntry> getEntries() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          7,
+          8,
           "getEntriesByName",
           "    REACT_SYNC_METHOD(getEntriesByName) std::vector<PerformanceSpec_RawPerformanceEntry> getEntriesByName(std::string entryName, std::optional<double> entryType) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getEntriesByName) static std::vector<PerformanceSpec_RawPerformanceEntry> getEntriesByName(std::string entryName, std::optional<double> entryType) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          8,
+          9,
           "getEntriesByType",
           "    REACT_SYNC_METHOD(getEntriesByType) std::vector<PerformanceSpec_RawPerformanceEntry> getEntriesByType(double entryType) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getEntriesByType) static std::vector<PerformanceSpec_RawPerformanceEntry> getEntriesByType(double entryType) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          9,
+          10,
           "getEventCounts",
           "    REACT_SYNC_METHOD(getEventCounts) ::React::JSValueArray getEventCounts() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getEventCounts) static ::React::JSValueArray getEventCounts() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          10,
+          11,
           "getSimpleMemoryInfo",
           "    REACT_SYNC_METHOD(getSimpleMemoryInfo) ::React::JSValue getSimpleMemoryInfo() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getSimpleMemoryInfo) static ::React::JSValue getSimpleMemoryInfo() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          11,
+          12,
           "getReactNativeStartupTiming",
           "    REACT_SYNC_METHOD(getReactNativeStartupTiming) ::React::JSValue getReactNativeStartupTiming() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getReactNativeStartupTiming) static ::React::JSValue getReactNativeStartupTiming() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          12,
+          13,
           "createObserver",
           "    REACT_SYNC_METHOD(createObserver)  createObserver(std::function<void()> const & callback) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(createObserver) static  createObserver(std::function<void()> const & callback) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          13,
+          14,
           "getDroppedEntriesCount",
           "    REACT_SYNC_METHOD(getDroppedEntriesCount) double getDroppedEntriesCount( observer) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getDroppedEntriesCount) static double getDroppedEntriesCount( observer) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          14,
+          15,
           "observe",
           "    REACT_METHOD(observe) void observe( observer, PerformanceSpec_PerformanceObserverInit && options) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(observe) static void observe( observer, PerformanceSpec_PerformanceObserverInit && options) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          15,
+          16,
           "disconnect",
           "    REACT_METHOD(disconnect) void disconnect( observer) noexcept { /* implementation */ }\n"
           "    REACT_METHOD(disconnect) static void disconnect( observer) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          16,
+          17,
           "takeRecords",
           "    REACT_SYNC_METHOD(takeRecords) std::vector<PerformanceSpec_RawPerformanceEntry> takeRecords( observer, bool sort) noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(takeRecords) static std::vector<PerformanceSpec_RawPerformanceEntry> takeRecords( observer, bool sort) noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          17,
+          18,
           "getSupportedPerformanceEntryTypes",
           "    REACT_SYNC_METHOD(getSupportedPerformanceEntryTypes) std::vector<double> getSupportedPerformanceEntryTypes() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(getSupportedPerformanceEntryTypes) static std::vector<double> getSupportedPerformanceEntryTypes() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          18,
+          19,
           "clearEventCountsForTesting",
           "    REACT_METHOD(clearEventCountsForTesting) void clearEventCountsForTesting() noexcept { /* implementation */ }\n"
           "    REACT_METHOD(clearEventCountsForTesting) static void clearEventCountsForTesting() noexcept { /* implementation */ }\n");