react-native-tvos 0.81.3-0 → 0.82.0-0

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.cpp

@@ -70,7 +70,7 @@ bool FuseboxTracer::stopTracing(
 
   for (auto& event : savedBuffer) {
     // For events with a custom track name, register track
-    if (event.track.length() && !trackIdMap.contains(event.track)) {
+    if (!event.track.empty() && !trackIdMap.contains(event.track)) {
       auto trackId = nextTrack++;
       trackIdMap[event.track] = trackId;
       traceEvents.push_back(folly::dynamic::object(
@@ -94,7 +94,7 @@ bool FuseboxTracer::stopTracing(
     }
   }
 
-  if (traceEvents.size() >= 1) {
+  if (!traceEvents.empty()) {
     resultCallback(traceEvents);
   }
   return true;

package/ReactCommon/reactperflogger/fusebox/FuseboxTracer.h

@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include "folly/dynamic.h"
+#include "folly/json/dynamic.h"
 
 #include <functional>
 #include <optional>

package/ReactCommon/reactperflogger/reactperflogger/FuseboxPerfettoDataSource.cpp

@@ -7,7 +7,9 @@
 
 #ifdef WITH_PERFETTO
 
+#if defined(__ANDROID__)
 #include <android/log.h>
+#endif // __ANDROID__
 #include <folly/json.h>
 #include <hermes/hermes.h>
 #include <perfetto.h>
@@ -25,8 +27,7 @@ const std::string JS_SAMPLING_TRACK = "JS Sampling";
 
 const int SAMPLING_HZ = 1000;
 
-using perfetto::TrackEvent;
-
+#if defined(__ANDROID__)
 std::string getApplicationId() {
   pid_t pid = getpid();
   char path[64] = {0};
@@ -40,6 +41,7 @@ std::string getApplicationId() {
   }
   return "";
 }
+#endif // __ANDROID__
 
 uint64_t hermesToPerfettoTime(int64_t hermesTs) {
   return (hermesTs / 1000);
@@ -130,6 +132,7 @@ void FuseboxPerfettoDataSource::OnStop(const StopArgs& a) {
   std::string trace = stream.str();
   logHermesProfileToFusebox(trace);
 
+#if defined(__ANDROID__)
   // XXX: Adjust the package ID. Writing to other global tmp directories
   // seems to fail.
   std::string appId = getApplicationId();
@@ -137,6 +140,7 @@ void FuseboxPerfettoDataSource::OnStop(const StopArgs& a) {
       ANDROID_LOG_INFO, "FuseboxTracer", "Application ID: %s", appId.c_str());
   FuseboxTracer::getFuseboxTracer().stopTracingAndWriteToFile(
       "/data/data/" + appId + "/cache/hermes_trace.json");
+#endif // __ANDROID__
 }
 
 } // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/HermesPerfettoDataSource.cpp

@@ -23,8 +23,6 @@ const int SAMPLING_HZ = 100;
 
 int64_t hermesDeltaTime = 0;
 
-using perfetto::TrackEvent;
-
 uint64_t hermesToPerfettoTime(int64_t hermesTs) {
   if (hermesDeltaTime == 0) {
     hermesDeltaTime = TrackEvent::GetTraceTimeNs() -
@@ -113,7 +111,7 @@ void HermesPerfettoDataSource::OnStart(const StartArgs&) {
       "react-native",
       perfetto::DynamicString{"Profiling Started"},
       getPerfettoWebPerfTrackSync("JS Sampling"),
-      perfetto::TrackEvent::GetTraceTimeNs());
+      TrackEvent::GetTraceTimeNs());
 }
 
 void HermesPerfettoDataSource::OnFlush(const FlushArgs&) {

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfetto.cpp

@@ -29,7 +29,7 @@ void initializePerfetto() {
     args.backends |= perfetto::kSystemBackend;
     args.use_monotonic_clock = true;
     perfetto::Tracing::Initialize(args);
-    perfetto::TrackEvent::Register();
+    TrackEvent::Register();
   });
 
   HermesPerfettoDataSource::RegisterDataSource();
@@ -42,7 +42,7 @@ static perfetto::Track createTrack(const std::string& trackName) {
   auto track = perfetto::Track(trackId++);
   auto desc = track.Serialize();
   desc.set_name(trackName);
-  perfetto::TrackEvent::SetTrackDescriptor(track, desc);
+  TrackEvent::SetTrackDescriptor(track, desc);
   return track;
 }
 
@@ -88,9 +88,7 @@ uint64_t highResTimeStampToPerfettoTraceTime(HighResTimeStamp timestamp) {
   auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(
       chronoDurationSinceSteadyClockEpoch);
 
-  return std::chrono::duration_cast<std::chrono::duration<std::uint64_t>>(
-             nanoseconds)
-      .count();
+  return static_cast<uint64_t>(nanoseconds.count());
 }
 
 } // namespace facebook::react

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfettoCategories.cpp

@@ -9,6 +9,7 @@
 
 #include "ReactPerfettoCategories.h"
 
-PERFETTO_TRACK_EVENT_STATIC_STORAGE();
+PERFETTO_TRACK_EVENT_STATIC_STORAGE_IN_NAMESPACE(facebook::react);
+PERFETTO_USE_CATEGORIES_FROM_NAMESPACE(facebook::react);
 
 #endif

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfettoCategories.h

@@ -11,7 +11,8 @@
 
 #include <perfetto.h>
 
-PERFETTO_DEFINE_CATEGORIES(
+PERFETTO_DEFINE_CATEGORIES_IN_NAMESPACE(
+    facebook::react,
     perfetto::Category("react-native")
         .SetDescription("User timing events from React Native"));
 

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfettoLogger.cpp

@@ -18,14 +18,31 @@ namespace facebook::react {
 namespace {
 
 #if defined(WITH_PERFETTO)
+const HighResTimeStamp PROGRAM_INIT_TIME = HighResTimeStamp::now();
 const std::string PERFETTO_DEFAULT_TRACK_NAME = "# Web Performance";
 const std::string PERFETTO_TRACK_NAME_PREFIX = "# Web Performance: ";
 
 std::string toPerfettoTrackName(
-    const std::optional<std::string_view>& trackName) {
-  return trackName.has_value()
-      ? PERFETTO_TRACK_NAME_PREFIX + std::string(trackName.value())
-      : PERFETTO_DEFAULT_TRACK_NAME;
+    const std::optional<std::string_view>& trackName,
+    const std::optional<std::string_view>& trackGroup) {
+  std::string perfettoTrackName = PERFETTO_DEFAULT_TRACK_NAME;
+
+  if (trackName || trackGroup) {
+    perfettoTrackName += ": ";
+
+    if (trackGroup) {
+      perfettoTrackName += *trackGroup;
+      if (trackName) {
+        perfettoTrackName += " | ";
+      }
+    }
+
+    if (trackName) {
+      perfettoTrackName += *trackName;
+    }
+  }
+
+  return perfettoTrackName;
 }
 #elif defined(WITH_FBSYSTRACE)
 int64_t getDeltaNanos(HighResTimeStamp jsTime) {
@@ -50,10 +67,16 @@ int64_t getDeltaNanos(HighResTimeStamp jsTime) {
     const std::string_view& eventName,
     HighResTimeStamp startTime,
     HighResTimeStamp endTime,
-    const std::optional<std::string_view>& trackName) {
+    const std::optional<std::string_view>& trackName,
+    const std::optional<std::string_view>& trackGroup) {
 #if defined(WITH_PERFETTO)
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
-    auto track = getPerfettoWebPerfTrackAsync(toPerfettoTrackName(trackName));
+    if (startTime < PROGRAM_INIT_TIME || endTime < PROGRAM_INIT_TIME) {
+      return;
+    }
+
+    auto track = getPerfettoWebPerfTrackAsync(
+        toPerfettoTrackName(trackName, trackGroup));
     TRACE_EVENT_BEGIN(
         "react-native",
         perfetto::DynamicString(eventName.data(), eventName.size()),
@@ -75,13 +98,14 @@ int64_t getDeltaNanos(HighResTimeStamp jsTime) {
 /* static */ void ReactPerfettoLogger::mark(
     const std::string_view& eventName,
     HighResTimeStamp startTime,
-    const std::optional<std::string_view>& trackName) {
+    const std::optional<std::string_view>& trackName,
+    const std::optional<std::string_view>& trackGroup) {
 #if defined(WITH_PERFETTO)
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
     TRACE_EVENT_INSTANT(
         "react-native",
         perfetto::DynamicString(eventName.data(), eventName.size()),
-        getPerfettoWebPerfTrackSync(toPerfettoTrackName(trackName)),
+        getPerfettoWebPerfTrackSync(toPerfettoTrackName(trackName, trackGroup)),
         highResTimeStampToPerfettoTraceTime(startTime));
   }
 #elif defined(WITH_FBSYSTRACE)

package/ReactCommon/reactperflogger/reactperflogger/ReactPerfettoLogger.h

@@ -11,7 +11,7 @@
 #include <reactperflogger/ReactPerfettoCategories.h>
 
 #include <optional>
-#include <string>
+#include <string_view>
 
 namespace facebook::react {
 
@@ -26,13 +26,15 @@ class ReactPerfettoLogger {
   static void mark(
       const std::string_view& eventName,
       HighResTimeStamp startTime,
-      const std::optional<std::string_view>& trackName);
+      const std::optional<std::string_view>& trackName = std::nullopt,
+      const std::optional<std::string_view>& trackGroup = std::nullopt);
 
   static void measure(
       const std::string_view& eventName,
       HighResTimeStamp startTime,
       HighResTimeStamp endTime,
-      const std::optional<std::string_view>& trackName);
+      const std::optional<std::string_view>& trackName = std::nullopt,
+      const std::optional<std::string_view>& trackGroup = std::nullopt);
 };
 
 } // namespace facebook::react

package/ReactCommon/yoga/yoga/Yoga.h

@@ -11,11 +11,11 @@
  * `#include <yoga/Yoga.h>` includes all of Yoga's public headers.
  */
 
-#include <yoga/YGConfig.h>
-#include <yoga/YGEnums.h>
-#include <yoga/YGMacros.h>
-#include <yoga/YGNode.h>
-#include <yoga/YGNodeLayout.h>
-#include <yoga/YGNodeStyle.h>
-#include <yoga/YGPixelGrid.h>
-#include <yoga/YGValue.h>
+#include <yoga/YGConfig.h> // IWYU pragma: export
+#include <yoga/YGEnums.h> // IWYU pragma: export
+#include <yoga/YGMacros.h> // IWYU pragma: export
+#include <yoga/YGNode.h> // IWYU pragma: export
+#include <yoga/YGNodeLayout.h> // IWYU pragma: export
+#include <yoga/YGNodeStyle.h> // IWYU pragma: export
+#include <yoga/YGPixelGrid.h> // IWYU pragma: export
+#include <yoga/YGValue.h> // IWYU pragma: export

package/cli.js

@@ -33,7 +33,7 @@ function findCommunityCli(startDir /*: string */ = process.cwd()) {
   // With isolated node_modules (eg pnpm), we won't be able to find
   // `@react-native-community/cli` starting from the `react-native` directory.
   // Instead, we should use the project root, which we assume to be the cwd.
-  const options = {paths: [startDir]};
+  const options /*: {paths?: Array<string>, ...} */ = {paths: [startDir]};
   const rncli = require.resolve('@react-native-community/cli', options);
   // $FlowFixMe[unsupported-syntax]
   return require(rncli);

package/flow/bom.js.flow

@@ -12,6 +12,71 @@
 
 declare var window: typeof globalThis;
 
+type DevToolsColor =
+  | 'primary'
+  | 'primary-light'
+  | 'primary-dark'
+  | 'secondary'
+  | 'secondary-light'
+  | 'secondary-dark'
+  | 'tertiary'
+  | 'tertiary-light'
+  | 'tertiary-dark'
+  | 'warning'
+  | 'error';
+
+// $FlowExpectedError[libdef-override] Flow core definitions are incomplete.
+declare var console: {
+  // Logging
+  log(...data: $ReadOnlyArray<mixed>): void,
+  trace(...data: $ReadOnlyArray<mixed>): void,
+  debug(...data: $ReadOnlyArray<mixed>): void,
+  info(...data: $ReadOnlyArray<mixed>): void,
+  warn(...data: $ReadOnlyArray<mixed>): void,
+  error(...data: $ReadOnlyArray<mixed>): void,
+
+  // Grouping
+  group(...data: $ReadOnlyArray<mixed>): void,
+  groupCollapsed(...data: $ReadOnlyArray<mixed>): void,
+  groupEnd(): void,
+
+  // Printing
+  table(
+    tabularData:
+      | $ReadOnly<{[key: string]: mixed, ...}>
+      | $ReadOnlyArray<$ReadOnly<{[key: string]: mixed, ...}>>
+      | $ReadOnlyArray<$ReadOnlyArray<mixed>>,
+  ): void,
+  dir(...data: $ReadOnlyArray<mixed>): void,
+  dirxml(...data: $ReadOnlyArray<mixed>): void,
+  clear(): void,
+
+  // Utilities
+  assert(condition: mixed, ...data: $ReadOnlyArray<mixed>): void,
+
+  // Profiling
+  profile(name?: string): void,
+  profileEnd(name?: string): void,
+
+  // Counts
+  count(label?: string): void,
+  countReset(label?: string): void,
+
+  // Timing / tracing
+  time(label?: string): void,
+  timeEnd(label?: string): void,
+  timeStamp(
+    label?: string,
+    start?: string | number,
+    end?: string | number,
+    trackName?: string,
+    trackGroup?: string,
+    color?: DevToolsColor,
+  ): void,
+
+  ...
+};
+
 declare class Navigator {
   product: 'ReactNative';
   appName?: ?string;
@@ -23,12 +88,169 @@ declare var navigator: Navigator;
 // https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp
 declare type DOMHighResTimeStamp = number;
 
+type PerformanceEntryFilterOptions = {
+  entryType: string,
+  name: string,
+  ...
+};
+
+// https://www.w3.org/TR/performance-timeline-2/
+declare class PerformanceEntry {
+  duration: DOMHighResTimeStamp;
+  entryType: string;
+  name: string;
+  startTime: DOMHighResTimeStamp;
+  toJSON(): string;
+}
+
+// https://w3c.github.io/user-timing/#performancemark
+declare class PerformanceMark extends PerformanceEntry {
+  constructor(name: string, markOptions?: PerformanceMarkOptions): void;
+  +detail: mixed;
+}
+
+// https://w3c.github.io/user-timing/#performancemeasure
+declare class PerformanceMeasure extends PerformanceEntry {
+  +detail: mixed;
+}
+
+// https://w3c.github.io/server-timing/#the-performanceservertiming-interface
+declare class PerformanceServerTiming {
+  description: string;
+  duration: DOMHighResTimeStamp;
+  name: string;
+  toJSON(): string;
+}
+
+// https://www.w3.org/TR/resource-timing-2/#sec-performanceresourcetiming
+// https://w3c.github.io/server-timing/#extension-to-the-performanceresourcetiming-interface
+declare class PerformanceResourceTiming extends PerformanceEntry {
+  connectEnd: number;
+  connectStart: number;
+  decodedBodySize: number;
+  domainLookupEnd: number;
+  domainLookupStart: number;
+  encodedBodySize: number;
+  fetchStart: number;
+  initiatorType: string;
+  nextHopProtocol: string;
+  redirectEnd: number;
+  redirectStart: number;
+  requestStart: number;
+  responseEnd: number;
+  responseStart: number;
+  secureConnectionStart: number;
+  serverTiming: Array<PerformanceServerTiming>;
+  transferSize: number;
+  workerStart: number;
+}
+
+// https://w3c.github.io/event-timing/#sec-performance-event-timing
+declare class PerformanceEventTiming extends PerformanceEntry {
+  cancelable: boolean;
+  interactionId: number;
+  processingEnd: number;
+  processingStart: number;
+  target: ?Node;
+}
+
+// https://w3c.github.io/longtasks/#taskattributiontiming
+declare class TaskAttributionTiming extends PerformanceEntry {
+  containerId: string;
+  containerName: string;
+  containerSrc: string;
+  containerType: string;
+}
+
+// https://w3c.github.io/longtasks/#sec-PerformanceLongTaskTiming
+declare class PerformanceLongTaskTiming extends PerformanceEntry {
+  attribution: $ReadOnlyArray<TaskAttributionTiming>;
+}
+
+// https://www.w3.org/TR/user-timing/#extensions-performance-interface
+declare type PerformanceMarkOptions = {
+  detail?: mixed,
+  startTime?: number,
+};
+
+declare type PerformanceMeasureOptions = {
+  detail?: mixed,
+  duration?: number,
+  end?: number | string,
+  start?: number | string,
+};
+
+type EventCountsForEachCallbackType =
+  | (() => void)
+  | ((value: number) => void)
+  | ((value: number, key: string) => void)
+  | ((value: number, key: string, map: Map<string, number>) => void);
+
+// https://www.w3.org/TR/event-timing/#eventcounts
+declare interface EventCounts {
+  entries(): Iterator<[string, number]>;
+
+  forEach(callback: EventCountsForEachCallbackType): void;
+  get(key: string): ?number;
+  has(key: string): boolean;
+  keys(): Iterator<string>;
+  size: number;
+  values(): Iterator<number>;
+}
+
 declare class Performance {
-  now: () => DOMHighResTimeStamp;
+  +eventCounts: EventCounts;
+  +timeOrigin: DOMHighResTimeStamp;
+
+  clearMarks(name?: string): void;
+  clearMeasures(name?: string): void;
+  getEntries: (
+    options?: PerformanceEntryFilterOptions,
+  ) => Array<PerformanceEntry>;
+  getEntriesByName: (name: string, type?: string) => Array<PerformanceEntry>;
+  getEntriesByType: (type: string) => Array<PerformanceEntry>;
+  mark(name: string, options?: PerformanceMarkOptions): PerformanceMark;
+  measure(
+    name: string,
+    startMarkOrOptions?: string | PerformanceMeasureOptions,
+    endMark?: string,
+  ): PerformanceMeasure;
+  now(): DOMHighResTimeStamp;
+  toJSON(): string;
 }
 
 declare var performance: Performance;
 
+type PerformanceEntryList = Array<PerformanceEntry>;
+
+declare interface PerformanceObserverEntryList {
+  getEntries(): PerformanceEntryList;
+  getEntriesByName(name: string, type: ?string): PerformanceEntryList;
+  getEntriesByType(type: string): PerformanceEntryList;
+}
+
+type PerformanceObserverInit = {
+  buffered?: boolean,
+  entryTypes?: Array<string>,
+  type?: string,
+  ...
+};
+
+declare class PerformanceObserver {
+  constructor(
+    callback: (
+      entries: PerformanceObserverEntryList,
+      observer: PerformanceObserver,
+    ) => mixed,
+  ): void;
+
+  disconnect(): void;
+  observe(options: ?PerformanceObserverInit): void;
+  static supportedEntryTypes: Array<string>;
+
+  takeRecords(): PerformanceEntryList;
+}
+
 type FormDataEntryValue = string | File;
 
 declare class FormData {

package/flow/prettier.js.flow

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+// $FlowFixMe[unsupported-syntax]
+declare module 'prettier' {
+  declare module.exports: $FlowFixMe;
+}

package/gradle/libs.versions.toml

@@ -6,7 +6,7 @@ compileSdk = "36"
 buildTools = "36.0.0"
 ndkVersion = "27.1.12297006"
 # Dependencies versions
-agp = "8.11.0"
+agp = "8.12.0"
 androidx-annotation = "1.6.0"
 androidx-appcompat = "1.7.0"
 androidx-autofill = "1.1.0"
@@ -29,12 +29,13 @@ jsc-android = "2026004.0.1"
 jsr305 = "3.0.2"
 junit = "4.13.2"
 kotlin = "2.1.20"
+ktfmt = "0.22.0"
 mockito = "3.12.4"
 mockito-kotlin = "3.2.0"
-nexus-publish = "1.3.0"
+nexus-publish = "2.0.0"
 okhttp = "4.9.2"
 okio = "2.9.0"
-robolectric = "4.9.2"
+robolectric = "4.15.1"
 soloader = "0.12.1"
 uiautomator = "2.3.0"
 xstream = "1.4.20"
@@ -92,6 +93,7 @@ thoughtworks = {module = "com.thoughtworks.xstream:xstream", version.ref = "xstr
 android-application = { id = "com.android.application", version.ref = "agp" }
 android-library = { id = "com.android.library", version.ref = "agp" }
 download = { id = "de.undercouch.download", version.ref = "download" }
+ktfmt = { id = "com.ncorti.ktfmt.gradle", version.ref = "ktfmt" }
 nexus-publish = { id = "io.github.gradle-nexus.publish-plugin", version.ref = "nexus-publish" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 binary-compatibility-validator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "binary-compatibility-validator" }

package/index.js

@@ -86,14 +86,14 @@ module.exports = {
   /**
    * @deprecated SafeAreaView has been deprecated and will be removed in a future release.
    * Please use 'react-native-safe-area-context' instead.
-   * See https://github.com/th3rdwave/react-native-safe-area-context
+   * See https://github.com/AppAndFlow/react-native-safe-area-context
    */
   get SafeAreaView() {
     warnOnce(
       'safe-area-view-deprecated',
       'SafeAreaView has been deprecated and will be removed in a future release. ' +
         "Please use 'react-native-safe-area-context' instead. " +
-        'See https://github.com/th3rdwave/react-native-safe-area-context',
+        'See https://github.com/AppAndFlow/react-native-safe-area-context',
     );
     return require('./Libraries/Components/SafeAreaView/SafeAreaView').default;
   },
@@ -224,6 +224,12 @@ module.exports = {
    * @deprecated
    */
   get InteractionManager() {
+    warnOnce(
+      'interaction-manager-deprecated',
+      'InteractionManager has been deprecated and will be removed in a ' +
+        'future release. Please refactor long tasks into smaller ones, and ' +
+        " use 'requestIdleCallback' instead.",
+    );
     return require('./Libraries/Interaction/InteractionManager').default;
   },
   get Keyboard() {
@@ -241,6 +247,9 @@ module.exports = {
   get NativeAppEventEmitter() {
     return require('./Libraries/EventEmitter/RCTNativeAppEventEmitter').default;
   },
+  get NativeComponentRegistry() {
+    return require('./Libraries/NativeComponent/NativeComponentRegistry');
+  },
   get NativeDialogManagerAndroid() {
     return require('./Libraries/NativeModules/specs/NativeDialogManagerAndroid')
       .default;
@@ -289,6 +298,9 @@ module.exports = {
   get requireNativeComponent() {
     return require('./Libraries/ReactNative/requireNativeComponent').default;
   },
+  get ReactNativeVersion() {
+    return require('./Libraries/Core/ReactNativeVersion').default;
+  },
   get RootTagContext() {
     return require('./Libraries/ReactNative/RootTag').RootTagContext;
   },

package/index.js.flow

@@ -311,6 +311,8 @@ export {default as LogBox} from './Libraries/LogBox/LogBox';
 
 export {default as NativeAppEventEmitter} from './Libraries/EventEmitter/RCTNativeAppEventEmitter';
 
+export * as NativeComponentRegistry from './Libraries/NativeComponent/NativeComponentRegistry';
+
 export {default as NativeDialogManagerAndroid} from './Libraries/NativeModules/specs/NativeDialogManagerAndroid';
 
 export type {
@@ -358,6 +360,8 @@ export {default as processColor} from './Libraries/StyleSheet/processColor';
 export {default as registerCallableModule} from './Libraries/Core/registerCallableModule';
 export {default as requireNativeComponent} from './Libraries/ReactNative/requireNativeComponent';
 
+export {default as ReactNativeVersion} from './Libraries/Core/ReactNativeVersion';
+
 export type {RootTag} from './Libraries/ReactNative/RootTag';
 export {RootTagContext} from './Libraries/ReactNative/RootTag';
 

package/jest/local-setup.js

@@ -16,13 +16,13 @@ import './setup';
 const consoleError = console.error;
 const consoleWarn = console.warn;
 
-// $FlowIgnore[cannot-write]
+// $FlowFixMe[cannot-write]
 console.error = (...args) => {
   consoleError(...args);
   throw new Error('console.error() was called (see error above)');
 };
 
-// $FlowIgnore[cannot-write]
+// $FlowFixMe[cannot-write]
 console.warn = (...args) => {
   consoleWarn(...args);
   throw new Error('console.warn() was called (see warning above)');

package/jest/mock.js

@@ -34,6 +34,6 @@ export default function mock<TModuleRef: $Flow$ModuleRef<mixed>>(
 }
 
 function deref(ref: $Flow$ModuleRef<mixed>): string {
-  // $FlowIgnore[incompatible-cast]
+  // $FlowFixMe[incompatible-type]
   return (ref as string).substring(2);
 }