react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/src/private/renderer/events/ResponderEvent.js

@@ -0,0 +1,40 @@
+/**
+ * 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
+ */
+
+import type {EventInit} from '../../webapis/dom/events/Event';
+import type {DispatchConfig} from './LegacySyntheticEvent';
+import type {TouchHistory} from './ResponderTouchHistoryStore';
+
+import LegacySyntheticEvent from './LegacySyntheticEvent';
+
+// flowlint unsafe-getters-setters:off
+
+/**
+ * Event class for responder system events. Extends LegacySyntheticEvent with
+ * a `touchHistory` field that tracks active touch positions.
+ */
+export default class ResponderEvent extends LegacySyntheticEvent {
+  _touchHistory: TouchHistory;
+
+  constructor(
+    type: string,
+    options: EventInit,
+    nativeEvent: {[string]: unknown},
+    dispatchConfig: ?DispatchConfig,
+    touchHistory: TouchHistory,
+  ) {
+    super(type, options, nativeEvent, dispatchConfig);
+    this._touchHistory = touchHistory;
+  }
+
+  get touchHistory(): TouchHistory {
+    return this._touchHistory;
+  }
+}

package/src/private/renderer/events/ResponderTouchHistoryStore.js

@@ -0,0 +1,258 @@
+/**
+ * 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
+ */
+
+/**
+ * Tracks the position and time of each active touch by `touch.identifier`. We
+ * should typically only see IDs in the range of 1-20 because IDs get recycled
+ * when touches end and start again.
+ */
+type TouchRecord = {
+  touchActive: boolean,
+  startPageX: number,
+  startPageY: number,
+  startTimeStamp: number,
+  currentPageX: number,
+  currentPageY: number,
+  currentTimeStamp: number,
+  previousPageX: number,
+  previousPageY: number,
+  previousTimeStamp: number,
+};
+
+type Touch = {
+  identifier: ?number,
+  pageX: number,
+  pageY: number,
+  timestamp: number,
+  ...
+};
+
+export type TouchEvent = {
+  changedTouches: Array<Touch>,
+  touches: Array<Touch>,
+  ...
+};
+
+function isStartish(topLevelType: string): boolean {
+  return topLevelType === 'topTouchStart';
+}
+
+function isMoveish(topLevelType: string): boolean {
+  return topLevelType === 'topTouchMove';
+}
+
+function isEndish(topLevelType: string): boolean {
+  return topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
+}
+
+export type TouchHistory = {
+  touchBank: Array<TouchRecord>,
+  numberActiveTouches: number,
+  indexOfSingleActiveTouch: number,
+  mostRecentTimeStamp: number,
+};
+
+const MAX_TOUCH_BANK = 20;
+const touchBank: Array<TouchRecord> = [];
+const touchHistory: TouchHistory = {
+  touchBank,
+  numberActiveTouches: 0,
+  // If there is only one active touch, we remember its location. This prevents
+  // us having to loop through all of the touches all the time in the most
+  // common case.
+  indexOfSingleActiveTouch: -1,
+  mostRecentTimeStamp: 0,
+};
+
+function timestampForTouch(touch: Touch): number {
+  // The legacy internal implementation provides "timeStamp", which has been
+  // renamed to "timestamp". Let both work for now while we iron it out
+  return (touch as $FlowFixMe).timeStamp || touch.timestamp;
+}
+
+function createTouchRecord(touch: Touch, timestamp: number): TouchRecord {
+  return {
+    touchActive: true,
+    startPageX: touch.pageX,
+    startPageY: touch.pageY,
+    startTimeStamp: timestamp,
+    currentPageX: touch.pageX,
+    currentPageY: touch.pageY,
+    currentTimeStamp: timestamp,
+    previousPageX: touch.pageX,
+    previousPageY: touch.pageY,
+    previousTimeStamp: timestamp,
+  };
+}
+
+function resetTouchRecord(
+  touchRecord: TouchRecord,
+  touch: Touch,
+  timestamp: number,
+): void {
+  touchRecord.touchActive = true;
+  touchRecord.startPageX = touch.pageX;
+  touchRecord.startPageY = touch.pageY;
+  touchRecord.startTimeStamp = timestamp;
+  touchRecord.currentPageX = touch.pageX;
+  touchRecord.currentPageY = touch.pageY;
+  touchRecord.currentTimeStamp = timestamp;
+  touchRecord.previousPageX = touch.pageX;
+  touchRecord.previousPageY = touch.pageY;
+  touchRecord.previousTimeStamp = timestamp;
+}
+
+function getTouchIdentifier({identifier}: Touch): number {
+  if (identifier == null) {
+    throw new Error('Touch object is missing identifier.');
+  }
+
+  if (__DEV__) {
+    if (identifier > MAX_TOUCH_BANK) {
+      console.error(
+        'Touch identifier %s is greater than maximum supported %s which causes ' +
+          'performance issues backfilling array locations for all of the indices.',
+        identifier,
+        MAX_TOUCH_BANK,
+      );
+    }
+  }
+  return identifier;
+}
+
+function recordTouchStart(touch: Touch): void {
+  const identifier = getTouchIdentifier(touch);
+  const timestamp = timestampForTouch(touch);
+  const touchRecord = touchBank[identifier];
+  if (touchRecord) {
+    resetTouchRecord(touchRecord, touch, timestamp);
+  } else {
+    touchBank[identifier] = createTouchRecord(touch, timestamp);
+  }
+  touchHistory.mostRecentTimeStamp = timestamp;
+}
+
+function recordTouchMove(touch: Touch): void {
+  const touchRecord = touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = true;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    const timestamp = timestampForTouch(touch);
+    touchRecord.currentTimeStamp = timestamp;
+    touchHistory.mostRecentTimeStamp = timestamp;
+  } else {
+    if (__DEV__) {
+      console.warn(
+        'Cannot record touch move without a touch start.\n' +
+          'Touch Move: %s\n' +
+          'Touch Bank: %s',
+        printTouch(touch),
+        printTouchBank(),
+      );
+    }
+  }
+}
+
+function recordTouchEnd(touch: Touch): void {
+  const touchRecord = touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = false;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    const timestamp = timestampForTouch(touch);
+    touchRecord.currentTimeStamp = timestamp;
+    touchHistory.mostRecentTimeStamp = timestamp;
+  } else {
+    if (__DEV__) {
+      console.warn(
+        'Cannot record touch end without a touch start.\n' +
+          'Touch End: %s\n' +
+          'Touch Bank: %s',
+        printTouch(touch),
+        printTouchBank(),
+      );
+    }
+  }
+}
+
+function printTouch(touch: Touch): string {
+  return JSON.stringify({
+    identifier: touch.identifier,
+    pageX: touch.pageX,
+    pageY: touch.pageY,
+    timestamp: timestampForTouch(touch),
+  });
+}
+
+function printTouchBank(): string {
+  let printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+  if (touchBank.length > MAX_TOUCH_BANK) {
+    printed += ' (original size: ' + touchBank.length + ')';
+  }
+  return printed;
+}
+
+let instrumentationCallback: ?(string, TouchEvent) => void;
+
+const ResponderTouchHistoryStore = {
+  /**
+   * Registers a listener which can be used to instrument every touch event.
+   */
+  instrument(callback: (string, TouchEvent) => void): void {
+    instrumentationCallback = callback;
+  },
+
+  recordTouchTrack(topLevelType: string, nativeEvent: TouchEvent): void {
+    if (instrumentationCallback != null) {
+      instrumentationCallback(topLevelType, nativeEvent);
+    }
+
+    if (isMoveish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordTouchMove);
+    } else if (isStartish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordTouchStart);
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        touchHistory.indexOfSingleActiveTouch =
+          // $FlowFixMe[incompatible-type] might be null according to type
+          nativeEvent.touches[0].identifier;
+      }
+    } else if (isEndish(topLevelType)) {
+      nativeEvent.changedTouches.forEach(recordTouchEnd);
+      touchHistory.numberActiveTouches = nativeEvent.touches.length;
+      if (touchHistory.numberActiveTouches === 1) {
+        for (let i = 0; i < touchBank.length; i++) {
+          const touchTrackToCheck = touchBank[i];
+          if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+            touchHistory.indexOfSingleActiveTouch = i;
+            break;
+          }
+        }
+        if (__DEV__) {
+          const activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+          if (activeRecord == null || !activeRecord.touchActive) {
+            console.error('Cannot find single active touch.');
+          }
+        }
+      }
+    }
+  },
+
+  touchHistory,
+};
+
+export default ResponderTouchHistoryStore;

package/src/private/renderer/events/dispatchNativeEvent.js

@@ -0,0 +1,83 @@
+/**
+ * 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-local
+ * @format
+ */
+
+import type EventTarget from '../../webapis/dom/events/EventTarget';
+
+import {
+  customBubblingEventTypes,
+  customDirectEventTypes,
+} from '../../../../Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
+import {setEventInitTimeStamp} from '../../webapis/dom/events/internals/EventInternals';
+import {dispatchTrustedEvent} from '../../webapis/dom/events/internals/EventTargetInternals';
+import LegacySyntheticEvent from './LegacySyntheticEvent';
+import {topLevelTypeToEventType} from './ReactNativeEventTypeMapping';
+import {
+  processResponderEvent,
+  rethrowCaughtError,
+} from './ReactNativeResponder';
+
+/**
+ * Dispatches a native event through the EventTarget-based dispatch system.
+ * This handles:
+ * 1. Responder negotiation (touch handling, grant/release lifecycle)
+ * 2. Normal event dispatch via dispatchTrustedEvent (capture/bubble phases)
+ *
+ * Called from the React renderer's dispatchEvent when
+ * enableNativeEventTargetEventDispatching is enabled.
+ */
+export default function dispatchNativeEvent(
+  target: EventTarget,
+  type: string,
+  payload: {[string]: unknown},
+): void {
+  // Process responder events before normal event dispatch.
+  processResponderEvent(type, target, payload);
+
+  // Normal EventTarget dispatch
+  const bubbleConfig = customBubblingEventTypes[type];
+  const directConfig = customDirectEventTypes[type];
+
+  // Skip events that are not registered in the view config
+  if (bubbleConfig != null || directConfig != null) {
+    // Honor `skipBubbling` declared in the view config: when set, the bubble
+    // phase only fires on the target itself (matching the legacy renderer's
+    // behavior). The synthesized event reports `bubbles: false`, which causes
+    // the EventTarget bubble loop to short-circuit after dispatching to the
+    // target. Capture-phase listeners are unaffected.
+    const bubbles =
+      bubbleConfig != null &&
+      bubbleConfig.phasedRegistrationNames.skipBubbling !== true;
+
+    const eventType = topLevelTypeToEventType(type);
+    const options: {bubbles: boolean, cancelable: boolean} = {
+      bubbles,
+      cancelable: true,
+    };
+
+    // Preserve the native event timestamp for backwards compatibility.
+    const nativeTimestamp = payload.timeStamp ?? payload.timestamp;
+    if (typeof nativeTimestamp === 'number') {
+      setEventInitTimeStamp(options, nativeTimestamp);
+    }
+
+    const syntheticEvent = new LegacySyntheticEvent(
+      eventType,
+      options,
+      payload,
+      bubbleConfig ?? directConfig,
+    );
+    dispatchTrustedEvent(target, syntheticEvent);
+  }
+
+  // Rethrow the first error caught during responder lifecycle dispatch,
+  // after all dispatching is complete. This matches the old system's
+  // runEventsInBatch → rethrowCaughtError pattern.
+  rethrowCaughtError();
+}

package/src/private/setup/setUpDOM.js

@@ -73,4 +73,24 @@ export default function setUpDOM() {
     'HTMLElement',
     () => require('../webapis/dom/nodes/ReactNativeElement').default,
   );
+
+  polyfillGlobal('Event', () => require('../webapis/dom/events/Event').default);
+
+  polyfillGlobal(
+    'EventTarget',
+    () => require('../webapis/dom/events/EventTarget').default,
+  );
+
+  polyfillGlobal(
+    'CustomEvent',
+    () => require('../webapis/dom/events/CustomEvent').default,
+  );
+
+  // Expose a global function that the React renderer can call to check
+  // if EventTarget-based event dispatching is enabled.
+  // We use a global function because we don't have another mechanism to pass
+  // feature flags from RN to React in OSS (similar to RN$enableMicrotasksInReact
+  // in setUpTimers.js).
+  global.RN$isNativeEventTargetEventDispatchingEnabled = () =>
+    require('../featureflags/ReactNativeFeatureFlags').enableNativeEventTargetEventDispatching();
 }

package/src/private/setup/setUpDefaultReactNativeEnvironment.js

@@ -47,4 +47,10 @@ export default function setUpDefaltReactNativeEnvironment(
   ) {
     require('./setUpIntersectionObserver').default();
   }
+
+  if (
+    require('../../../src/private/featureflags/ReactNativeFeatureFlags').enableMutationObserverByDefault()
+  ) {
+    require('./setUpMutationObserver').default();
+  }
 }

package/src/private/specs_DEPRECATED/components/ActivityIndicatorViewNativeComponent.js

@@ -48,9 +48,9 @@ type RCTActivityIndicatorViewNativeProps = Readonly<{
   size?: WithDefault<'small' | 'large', 'small'>,
 }>;
 
-export default (codegenNativeComponent<RCTActivityIndicatorViewNativeProps>(
+export default codegenNativeComponent<RCTActivityIndicatorViewNativeProps>(
   'ActivityIndicatorView',
   {
     paperComponentName: 'RCTActivityIndicatorView',
   },
-): HostComponent<RCTActivityIndicatorViewNativeProps>);
+) as HostComponent<RCTActivityIndicatorViewNativeProps>;

package/src/private/specs_DEPRECATED/components/AndroidDrawerLayoutNativeComponent.js

@@ -119,6 +119,6 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: ['openDrawer', 'closeDrawer'],
 });
 
-export default (codegenNativeComponent<AndroidDrawerLayoutNativeProps>(
+export default codegenNativeComponent<AndroidDrawerLayoutNativeProps>(
   'AndroidDrawerLayout',
-): NativeType);
+) as NativeType;

package/src/private/specs_DEPRECATED/components/AndroidHorizontalScrollContentViewNativeComponent.js

@@ -21,7 +21,7 @@ type AndroidHorizontalScrollContentViewNativeProps = Readonly<{
 
 type NativeType = HostComponent<AndroidHorizontalScrollContentViewNativeProps>;
 
-export default (codegenNativeComponent<AndroidHorizontalScrollContentViewNativeProps>(
+export default codegenNativeComponent<AndroidHorizontalScrollContentViewNativeProps>(
   'AndroidHorizontalScrollContentView',
   {interfaceOnly: true},
-): NativeType);
+) as NativeType;

package/src/private/specs_DEPRECATED/components/AndroidSwipeRefreshLayoutNativeComponent.js

@@ -69,6 +69,6 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: ['setNativeRefreshing'],
 });
 
-export default (codegenNativeComponent<AndroidSwipeRefreshLayoutNativeProps>(
+export default codegenNativeComponent<AndroidSwipeRefreshLayoutNativeProps>(
   'AndroidSwipeRefreshLayout',
-): NativeType);
+) as NativeType;

package/src/private/specs_DEPRECATED/components/AndroidSwitchNativeComponent.js

@@ -57,9 +57,9 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: ['setNativeValue'],
 });
 
-export default (codegenNativeComponent<AndroidSwitchNativeProps>(
+export default codegenNativeComponent<AndroidSwitchNativeProps>(
   'AndroidSwitch',
   {
     interfaceOnly: true,
   },
-): NativeType);
+) as NativeType;

package/src/private/specs_DEPRECATED/components/DebuggingOverlayNativeComponent.js

@@ -57,6 +57,6 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   ],
 });
 
-export default (codegenNativeComponent<DebuggingOverlayNativeProps>(
+export default codegenNativeComponent<DebuggingOverlayNativeProps>(
   'DebuggingOverlay',
-): HostComponent<DebuggingOverlayNativeProps>);
+) as HostComponent<DebuggingOverlayNativeProps>;

package/src/private/specs_DEPRECATED/components/ProgressBarAndroidNativeComponent.js

@@ -31,9 +31,9 @@ type AndroidProgressBarNativeProps = Readonly<{
   testID?: WithDefault<string, ''>,
 }>;
 
-export default (codegenNativeComponent<AndroidProgressBarNativeProps>(
+export default codegenNativeComponent<AndroidProgressBarNativeProps>(
   'AndroidProgressBar',
   {
     interfaceOnly: true,
   },
-): HostComponent<AndroidProgressBarNativeProps>);
+) as HostComponent<AndroidProgressBarNativeProps>;

package/src/private/specs_DEPRECATED/components/PullToRefreshViewNativeComponent.js

@@ -65,10 +65,10 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: ['setNativeRefreshing'],
 });
 
-export default (codegenNativeComponent<PullToRefreshNativeProps>(
+export default codegenNativeComponent<PullToRefreshNativeProps>(
   'PullToRefreshView',
   {
     paperComponentName: 'RCTRefreshControl',
     excludedPlatforms: ['android'],
   },
-): HostComponent<PullToRefreshNativeProps>);
+) as HostComponent<PullToRefreshNativeProps>;

package/src/private/specs_DEPRECATED/components/RCTInputAccessoryViewNativeComponent.js

@@ -19,11 +19,11 @@ type InputAccessoryNativeProps = Readonly<{
   backgroundColor?: ?ColorValue,
 }>;
 
-export default (codegenNativeComponent<InputAccessoryNativeProps>(
+export default codegenNativeComponent<InputAccessoryNativeProps>(
   'InputAccessory',
   {
     interfaceOnly: true,
     paperComponentName: 'RCTInputAccessoryView',
     excludedPlatforms: ['android'],
   },
-): HostComponent<InputAccessoryNativeProps>);
+) as HostComponent<InputAccessoryNativeProps>;

package/src/private/specs_DEPRECATED/components/RCTModalHostViewNativeComponent.js

@@ -147,10 +147,10 @@ type RCTModalHostViewNativeProps = Readonly<{
   identifier?: WithDefault<Int32, 0>,
 }>;
 
-export default (codegenNativeComponent<RCTModalHostViewNativeProps>(
+export default codegenNativeComponent<RCTModalHostViewNativeProps>(
   'ModalHostView',
   {
     interfaceOnly: true,
     paperComponentName: 'RCTModalHostView',
   },
-): HostComponent<RCTModalHostViewNativeProps>);
+) as HostComponent<RCTModalHostViewNativeProps>;

package/src/private/specs_DEPRECATED/components/RCTSafeAreaViewNativeComponent.js

@@ -19,10 +19,10 @@ type RCTSafeAreaViewNativeProps = Readonly<{
   // No props
 }>;
 
-export default (codegenNativeComponent<RCTSafeAreaViewNativeProps>(
+export default codegenNativeComponent<RCTSafeAreaViewNativeProps>(
   'SafeAreaView',
   {
     paperComponentName: 'RCTSafeAreaView',
     interfaceOnly: true,
   },
-): HostComponent<RCTSafeAreaViewNativeProps>);
+) as HostComponent<RCTSafeAreaViewNativeProps>;

package/src/private/specs_DEPRECATED/components/SwitchNativeComponent.js

@@ -55,8 +55,8 @@ export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
   supportedCommands: ['setValue'],
 });
 
-export default (codegenNativeComponent<SwitchNativeProps>('Switch', {
+export default codegenNativeComponent<SwitchNativeProps>('Switch', {
   paperComponentName: 'RCTSwitch',
   excludedPlatforms: ['android'],
   interfaceOnly: true,
-}): ComponentType);
+}) as ComponentType;

package/src/private/specs_DEPRECATED/components/UnimplementedNativeViewNativeComponent.js

@@ -21,6 +21,6 @@ type UnimplementedNativeViewNativeProps = Readonly<{
 
 // NOTE: This component is not implemented in paper
 // Do not require this file in paper builds
-export default (codegenNativeComponent<UnimplementedNativeViewNativeProps>(
+export default codegenNativeComponent<UnimplementedNativeViewNativeProps>(
   'UnimplementedNativeView',
-): HostComponent<UnimplementedNativeViewNativeProps>);
+) as HostComponent<UnimplementedNativeViewNativeProps>;

package/src/private/specs_DEPRECATED/modules/NativeAccessibilityInfo.js

@@ -39,4 +39,4 @@ export interface Spec extends TurboModule {
   ) => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('AccessibilityInfo'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('AccessibilityInfo') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeAccessibilityManager.js

@@ -67,4 +67,4 @@ export interface Spec extends TurboModule {
   ) => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('AccessibilityManager'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('AccessibilityManager') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeActionSheetManager.js

@@ -53,4 +53,4 @@ export interface Spec extends TurboModule {
   +dismissActionSheet?: () => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('ActionSheetManager'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('ActionSheetManager') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeAlertManager.js

@@ -32,4 +32,4 @@ export interface Spec extends TurboModule {
   ) => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('AlertManager'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('AlertManager') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeAppState.js

@@ -30,4 +30,4 @@ export interface Spec extends TurboModule {
   +removeListeners: (count: number) => void;
 }
 
-export default (TurboModuleRegistry.getEnforcing<Spec>('AppState'): Spec);
+export default TurboModuleRegistry.getEnforcing<Spec>('AppState') as Spec;

package/src/private/specs_DEPRECATED/modules/NativeAppearance.js

@@ -27,4 +27,4 @@ export interface Spec extends TurboModule {
   +removeListeners: (count: number) => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('Appearance'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('Appearance') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeBlobModule.js

@@ -58,4 +58,4 @@ if (NativeModule != null) {
   };
 }
 
-export default (NativeBlobModule: ?Spec);
+export default NativeBlobModule as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeClipboard.js

@@ -18,4 +18,4 @@ export interface Spec extends TurboModule {
   +setString: (content: string) => void;
 }
 
-export default (TurboModuleRegistry.getEnforcing<Spec>('Clipboard'): Spec);
+export default TurboModuleRegistry.getEnforcing<Spec>('Clipboard') as Spec;

package/src/private/specs_DEPRECATED/modules/NativeDevLoadingView.js

@@ -22,4 +22,4 @@ export interface Spec extends TurboModule {
   +hide: () => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('DevLoadingView'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('DevLoadingView') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeDevSettings.js

@@ -30,4 +30,4 @@ export interface Spec extends TurboModule {
   +setIsShakeToShowDevMenuEnabled: (enabled: boolean) => void;
 }
 
-export default (TurboModuleRegistry.getEnforcing<Spec>('DevSettings'): Spec);
+export default TurboModuleRegistry.getEnforcing<Spec>('DevSettings') as Spec;

package/src/private/specs_DEPRECATED/modules/NativeDeviceEventManager.js

@@ -16,4 +16,4 @@ export interface Spec extends TurboModule {
   +invokeDefaultBackPressHandler: () => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('DeviceEventManager'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('DeviceEventManager') as ?Spec;

package/src/private/specs_DEPRECATED/modules/NativeDialogManagerAndroid.js

@@ -45,4 +45,4 @@ export interface Spec extends TurboModule {
   ) => void;
 }
 
-export default (TurboModuleRegistry.get<Spec>('DialogManagerAndroid'): ?Spec);
+export default TurboModuleRegistry.get<Spec>('DialogManagerAndroid') as ?Spec;