react-native-tvos 0.69.8-2 → 0.71.7-0rc0

package/Libraries/AppDelegate/RCTAppDelegate.mm

@@ -0,0 +1,171 @@
+/*
+ * 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.
+ */
+
+#import "RCTAppDelegate.h"
+#import <React/RCTAppSetupUtils.h>
+#import <React/RCTRootView.h>
+
+#if RCT_NEW_ARCH_ENABLED
+#import <React/CoreModulesPlugins.h>
+#import <React/RCTCxxBridgeDelegate.h>
+#import <React/RCTFabricSurfaceHostingProxyRootView.h>
+#import <React/RCTSurfacePresenter.h>
+#import <React/RCTSurfacePresenterBridgeAdapter.h>
+#import <ReactCommon/RCTTurboModuleManager.h>
+#import <react/config/ReactNativeConfig.h>
+
+static NSString *const kRNConcurrentRoot = @"concurrentRoot";
+
+@interface RCTAppDelegate () <RCTTurboModuleManagerDelegate, RCTCxxBridgeDelegate> {
+  std::shared_ptr<const facebook::react::ReactNativeConfig> _reactNativeConfig;
+  facebook::react::ContextContainer::Shared _contextContainer;
+}
+@end
+
+#endif
+
+@implementation RCTAppDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
+{
+  BOOL enableTM = NO;
+#if RCT_NEW_ARCH_ENABLED
+  enableTM = self.turboModuleEnabled;
+#endif
+
+  RCTAppSetupPrepareApp(application, enableTM);
+
+  if (!self.bridge) {
+    self.bridge = [self createBridgeWithDelegate:self launchOptions:launchOptions];
+  }
+#if RCT_NEW_ARCH_ENABLED
+  _contextContainer = std::make_shared<facebook::react::ContextContainer const>();
+  _reactNativeConfig = std::make_shared<facebook::react::EmptyReactNativeConfig const>();
+  _contextContainer->insert("ReactNativeConfig", _reactNativeConfig);
+  self.bridgeAdapter = [[RCTSurfacePresenterBridgeAdapter alloc] initWithBridge:self.bridge
+                                                               contextContainer:_contextContainer];
+  self.bridge.surfacePresenter = self.bridgeAdapter.surfacePresenter;
+#endif
+
+  NSDictionary *initProps = [self prepareInitialProps];
+  UIView *rootView = [self createRootViewWithBridge:self.bridge moduleName:self.moduleName initProps:initProps];
+
+  if (@available(iOS 13.0, tvOS 13.0, *)) {
+#if TARGET_OS_TV
+    rootView.backgroundColor = [UIColor whiteColor];
+#else
+    rootView.backgroundColor = [UIColor systemBackgroundColor];
+#endif
+  } else {
+    rootView.backgroundColor = [UIColor whiteColor];
+  }
+
+  self.window = [[UIWindow alloc] initWithFrame:[UIScreen mainScreen].bounds];
+  UIViewController *rootViewController = [self createRootViewController];
+  rootViewController.view = rootView;
+  self.window.rootViewController = rootViewController;
+  [self.window makeKeyAndVisible];
+  return YES;
+}
+
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge
+{
+  [NSException raise:@"RCTBridgeDelegate::sourceURLForBridge not implemented"
+              format:@"Subclasses must implement a valid sourceURLForBridge method"];
+  return nil;
+}
+
+- (BOOL)concurrentRootEnabled
+{
+  [NSException raise:@"concurrentRootEnabled not implemented"
+              format:@"Subclasses must implement a valid concurrentRootEnabled method"];
+  return true;
+}
+
+- (NSDictionary *)prepareInitialProps
+{
+  NSMutableDictionary *initProps = self.initialProps ? [self.initialProps mutableCopy] : [NSMutableDictionary new];
+
+#ifdef RCT_NEW_ARCH_ENABLED
+  initProps[kRNConcurrentRoot] = @([self concurrentRootEnabled]);
+#endif
+
+  return initProps;
+}
+
+- (RCTBridge *)createBridgeWithDelegate:(id<RCTBridgeDelegate>)delegate launchOptions:(NSDictionary *)launchOptions
+{
+  return [[RCTBridge alloc] initWithDelegate:delegate launchOptions:launchOptions];
+}
+
+- (UIView *)createRootViewWithBridge:(RCTBridge *)bridge
+                          moduleName:(NSString *)moduleName
+                           initProps:(NSDictionary *)initProps
+{
+  BOOL enableFabric = NO;
+#if RCT_NEW_ARCH_ENABLED
+  enableFabric = self.fabricEnabled;
+#endif
+  return RCTAppSetupDefaultRootView(bridge, moduleName, initProps, enableFabric);
+}
+
+- (UIViewController *)createRootViewController
+{
+  return [UIViewController new];
+}
+
+#if RCT_NEW_ARCH_ENABLED
+#pragma mark - RCTCxxBridgeDelegate
+
+- (std::unique_ptr<facebook::react::JSExecutorFactory>)jsExecutorFactoryForBridge:(RCTBridge *)bridge
+{
+  self.turboModuleManager = [[RCTTurboModuleManager alloc] initWithBridge:bridge
+                                                                 delegate:self
+                                                                jsInvoker:bridge.jsCallInvoker];
+  return RCTAppSetupDefaultJsExecutorFactory(bridge, _turboModuleManager);
+}
+
+#pragma mark RCTTurboModuleManagerDelegate
+
+- (Class)getModuleClassFromName:(const char *)name
+{
+  return RCTCoreModulesClassProvider(name);
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+{
+  return nullptr;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
+                                                     initParams:
+                                                         (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return nullptr;
+}
+
+- (id<RCTTurboModule>)getModuleInstanceFromClass:(Class)moduleClass
+{
+  return RCTAppSetupDefaultModuleFromClass(moduleClass);
+}
+
+#pragma mark - New Arch Enabled settings
+
+- (BOOL)turboModuleEnabled
+{
+  return YES;
+}
+
+- (BOOL)fabricEnabled
+{
+  return YES;
+}
+
+#endif
+
+@end

package/Libraries/AppDelegate/React-RCTAppDelegate.podspec

@@ -0,0 +1,73 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1'
+folly_compiler_flags = folly_flags + ' ' + '-Wno-comma -Wno-shorten-64-to-32'
+
+new_arch_enabled_flag="RCT_NEW_ARCH_ENABLED"
+is_new_arch_enabled = ENV[new_arch_enabled_flag] == "1"
+other_cflags = "$(inherited) -DRN_FABRIC_ENABLED " + folly_flags + (is_new_arch_enabled ? " -D"+"RCT_NEW_ARCH_ENABLED" : "")
+
+use_hermes = ENV['USE_HERMES'] == '1'
+
+header_search_paths = [
+  "$(PODS_TARGET_SRCROOT)/ReactCommon",
+  "$(PODS_ROOT)/Headers/Private/React-Core",
+  "$(PODS_ROOT)/boost",
+  "$(PODS_ROOT)/DoubleConversion",
+  "$(PODS_ROOT)/RCT-Folly",
+  "${PODS_ROOT}/Headers/Public/FlipperKit",
+  "$(PODS_ROOT)/Headers/Public/ReactCommon",
+  "$(PODS_ROOT)/Headers/Public/React-RCTFabric"
+].concat(use_hermes ? [
+  "$(PODS_ROOT)/Headers/Public/React-hermes",
+  "$(PODS_ROOT)/Headers/Public/hermes-engine"
+] : []).map{|p| "\"#{p}\""}.join(" ")
+
+Pod::Spec.new do |s|
+  s.name            = "React-RCTAppDelegate"
+  s.version                = version
+  s.summary                = "An utility library to simplify common operations for the New Architecture"
+  s.homepage               = "https://reactnative.dev/"
+  s.documentation_url      = "https://reactnative.dev/docs/actionsheetios"
+  s.license                = package["license"]
+  s.author                 = "Facebook, Inc. and its affiliates"
+  s.platforms              = { :ios => "12.4", :tvos => "12.4" }
+  s.source                 = source
+  s.source_files            = "**/*.{c,h,m,mm,S,cpp}"
+
+  # This guard prevent to install the dependencies when we run `pod install` in the old architecture.
+  s.compiler_flags = other_cflags
+  s.pod_target_xcconfig    = {
+    "HEADER_SEARCH_PATHS" => header_search_paths,
+    "OTHER_CPLUSPLUSFLAGS" => other_cflags,
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+  }
+  s.user_target_xcconfig   = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/Headers/Private/React-Core\""}
+
+  s.dependency "React-Core"
+  s.dependency "RCT-Folly"
+  s.dependency "RCTRequired"
+  s.dependency "RCTTypeSafety"
+  s.dependency "ReactCommon/turbomodule/core"
+
+  if is_new_arch_enabled
+    s.dependency "React-RCTFabric"
+    s.dependency "React-graphics"
+  end
+end

package/Libraries/AppState/AppState.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+import {NativeEventSubscription} from '../EventEmitter/RCTNativeAppEventEmitter';
+
+/**
+ * AppState can tell you if the app is in the foreground or background,
+ * and notify you when the state changes.
+ *
+ * AppState is frequently used to determine the intent and proper behavior
+ * when handling push notifications.
+ *
+ * App State Events
+ *      change - This even is received when the app state has changed.
+ *      focus [Android] - Received when the app gains focus (the user is interacting with the app).
+ *      blur [Android] - Received when the user is not actively interacting with the app.
+ *
+ * App States
+ *      active - The app is running in the foreground
+ *      background - The app is running in the background. The user is either in another app or on the home screen
+ *      inactive [iOS] - This is a transition state that currently never happens for typical React Native apps.
+ *      unknown [iOS] - Initial value until the current app state is determined
+ *      extension [iOS] - The app is running as an app extension
+ *
+ * For more information, see Apple's documentation: https://developer.apple.com/library/ios/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/TheAppLifeCycle/TheAppLifeCycle.html
+ *
+ * @see https://reactnative.dev/docs/appstate#app-states
+ */
+export type AppStateEvent = 'change' | 'memoryWarning' | 'blur' | 'focus';
+export type AppStateStatus =
+  | 'active'
+  | 'background'
+  | 'inactive'
+  | 'unknown'
+  | 'extension';
+
+export interface AppStateStatic {
+  currentState: AppStateStatus;
+  isAvailable: boolean;
+
+  /**
+   * Add a handler to AppState changes by listening to the change event
+   * type and providing the handler
+   */
+  addEventListener(
+    type: AppStateEvent,
+    listener: (state: AppStateStatus) => void,
+  ): NativeEventSubscription;
+}
+
+export const AppState: AppStateStatic;
+export type AppState = AppStateStatic;

package/Libraries/AppState/AppState.js

@@ -8,11 +8,11 @@
  * @format
  */
 
-import {type EventSubscription} from '../vendor/emitter/EventEmitter';
 import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
 import logError from '../Utilities/logError';
-import NativeAppState from './NativeAppState';
 import Platform from '../Utilities/Platform';
+import {type EventSubscription} from '../vendor/emitter/EventEmitter';
+import NativeAppState from './NativeAppState';
 
 export type AppStateValues = 'inactive' | 'background' | 'active';
 
@@ -76,17 +76,13 @@ class AppState {
         // It's possible that the state will have changed here & listeners need to be notified
         if (!eventUpdated && this.currentState !== appStateData.app_state) {
           this.currentState = appStateData.app_state;
+          // $FlowFixMe[incompatible-call]
           emitter.emit('appStateDidChange', appStateData);
         }
       }, logError);
     }
   }
 
-  // TODO: now that AppState is a subclass of NativeEventEmitter, we could
-  // deprecate `addEventListener` and `removeEventListener` and just use
-  // addListener` and `listener.remove()` directly. That will be a breaking
-  // change though, as both the method and event names are different
-  // (addListener events are currently required to be globally unique).
   /**
    * Add a handler to AppState changes by listening to the `change` event type
    * and providing the handler.
@@ -127,38 +123,6 @@ class AppState {
     }
     throw new Error('Trying to subscribe to unknown event: ' + type);
   }
-
-  /**
-   * @deprecated Use `remove` on the EventSubscription from `addEventListener`.
-   */
-  removeEventListener<K: $Keys<AppStateEventDefinitions>>(
-    type: K,
-    listener: (...$ElementType<AppStateEventDefinitions, K>) => mixed,
-  ): void {
-    const emitter = this._emitter;
-    if (emitter == null) {
-      throw new Error('Cannot use AppState when `isAvailable` is false.');
-    }
-    // NOTE: This will report a deprecation notice via `console.error`.
-    switch (type) {
-      case 'change':
-        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
-        // $FlowIssue[incompatible-call]
-        emitter.removeListener('appStateDidChange', listener);
-        return;
-      case 'memoryWarning':
-        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
-        emitter.removeListener('memoryWarning', listener);
-        return;
-      case 'blur':
-      case 'focus':
-        // $FlowIssue[invalid-tuple-arity] Flow cannot refine handler based on the event type
-        // $FlowIssue[incompatible-call]
-        emitter.removeListener('appStateFocusChange', listener);
-        return;
-    }
-    throw new Error('Trying to unsubscribe from unknown event: ' + type);
-  }
 }
 
 module.exports = (new AppState(): AppState);

package/Libraries/AppState/NativeAppState.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {

package/Libraries/BatchedBridge/MessageQueue.js

@@ -10,13 +10,12 @@
 
 'use strict';
 
-const ErrorUtils = require('../vendor/core/ErrorUtils');
 const Systrace = require('../Performance/Systrace');
-
 const deepFreezeAndThrowOnMutationInDev = require('../Utilities/deepFreezeAndThrowOnMutationInDev');
-const invariant = require('invariant');
 const stringifySafe = require('../Utilities/stringifySafe').default;
 const warnOnce = require('../Utilities/warnOnce');
+const ErrorUtils = require('../vendor/core/ErrorUtils');
+const invariant = require('invariant');
 
 export type SpyData = {
   type: number,
@@ -199,7 +198,7 @@ class MessageQueue {
           delete this._debugInfo[this._callID - DEBUG_INFO_LIMIT];
         }
         if (this._successCallbacks.size > 500) {
-          const info = {};
+          const info: {[number]: {method: string, module: string}} = {};
           this._successCallbacks.forEach((_, callID) => {
             const debug = this._debugInfo[callID];
             const module = debug && this._remoteModuleTable[debug[0]];
@@ -242,7 +241,7 @@ class MessageQueue {
     params: mixed[],
     onFail: ?(...mixed[]) => void,
     onSucc: ?(...mixed[]) => void,
-  ) {
+  ): void {
     this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
 
     this._queue[MODULE_IDS].push(moduleID);
@@ -253,7 +252,7 @@ class MessageQueue {
       // folly-convertible.  As a special case, if a prop value is a
       // function it is permitted here, and special-cased in the
       // conversion.
-      const isValidArgument = val => {
+      const isValidArgument = (val: mixed): boolean => {
         switch (typeof val) {
           case 'undefined':
           case 'boolean':
@@ -287,7 +286,7 @@ class MessageQueue {
       // Replacement allows normally non-JSON-convertible values to be
       // seen.  There is ambiguity with string values, but in context,
       // it should at least be a strong hint.
-      const replacer = (key, val) => {
+      const replacer = (key: string, val: $FlowFixMe) => {
         const t = typeof val;
         if (t === 'function') {
           return '<<Function ' + val.name + '>>';
@@ -322,6 +321,7 @@ class MessageQueue {
     }
     Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);
     if (__DEV__ && this.__spy && isFinite(moduleID)) {
+      // $FlowFixMe[not-a-function]
       this.__spy({
         type: TO_NATIVE,
         module: this._remoteModuleTable[moduleID],
@@ -381,7 +381,7 @@ class MessageQueue {
     return (
       // $FlowFixMe[cannot-resolve-name]
       typeof DebuggerInternal !== 'undefined' &&
-      DebuggerInternal.shouldPauseOnThrow === true // eslint-disable-line no-undef
+      DebuggerInternal.shouldPauseOnThrow === true
     );
   }
 
@@ -405,20 +405,30 @@ class MessageQueue {
       this.__spy({type: TO_JS, module, method, args});
     }
     const moduleMethods = this.getCallableModule(module);
-    invariant(
-      !!moduleMethods,
-      `Module ${module} is not a registered callable module (calling ${method}). A frequent cause of the error is that the application entry file path is incorrect.
-      This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.`,
-    );
-    invariant(
-      !!moduleMethods[method],
-      `Method ${method} does not exist on module ${module}`,
-    );
+    if (!moduleMethods) {
+      const callableModuleNames = Object.keys(this._lazyCallableModules);
+      const n = callableModuleNames.length;
+      const callableModuleNameList = callableModuleNames.join(', ');
+
+      // TODO(T122225939): Remove after investigation: Why are we getting to this line in bridgeless mode?
+      const isBridgelessMode = global.RN$Bridgeless === true ? 'true' : 'false';
+      invariant(
+        false,
+        `Failed to call into JavaScript module method ${module}.${method}(). Module has not been registered as callable. Bridgeless Mode: ${isBridgelessMode}. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
+        A frequent cause of the error is that the application entry file path is incorrect. This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.`,
+      );
+    }
+    if (!moduleMethods[method]) {
+      invariant(
+        false,
+        `Failed to call into JavaScript module method ${module}.${method}(). Module exists, but the method is undefined.`,
+      );
+    }
     moduleMethods[method].apply(moduleMethods, args);
     Systrace.endEvent();
   }
 
-  __invokeCallback(cbID: number, args: mixed[]) {
+  __invokeCallback(cbID: number, args: mixed[]): void {
     this._lastFlush = Date.now();
     this._eventLoopStartTime = this._lastFlush;
 

package/Libraries/BatchedBridge/NativeModules.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @format
+ */
+
+/**
+ * Interface for NativeModules which allows to augment NativeModules with type informations.
+ * See react-native-sensor-manager for example.
+ */
+interface NativeModulesStatic {
+  [name: string]: any;
+}
+
+/**
+ * Native Modules written in ObjectiveC/Swift/Java exposed via the RCTBridge
+ * Define lazy getters for each module. These will return the module if already loaded, or load it if not.
+ * See https://reactnative.dev/docs/native-modules-ios
+ * @example
+ * const MyModule = NativeModules.ModuleName
+ */
+export const NativeModules: NativeModulesStatic;

package/Libraries/BatchedBridge/NativeModules.js

@@ -10,12 +10,11 @@
 
 'use strict';
 
-const BatchedBridge = require('./BatchedBridge');
+import type {ExtendedError} from '../Core/ExtendedError';
 
+const BatchedBridge = require('./BatchedBridge');
 const invariant = require('invariant');
 
-import type {ExtendedError} from '../Core/ExtendedError';
-
 export type ModuleConfig = [
   string /* name */,
   ?{...} /* constants */,
@@ -51,7 +50,7 @@ function genModule(
     return {name: moduleName};
   }
 
-  const module = {};
+  const module: {[string]: mixed} = {};
   methods &&
     methods.forEach((methodName, methodID) => {
       const isPromise =
@@ -156,6 +155,7 @@ function genMethod(moduleID: number, methodID: number, type: MethodType) {
       }
     };
   }
+  // $FlowFixMe[prop-missing]
   fn.type = type;
   return fn;
 }

package/Libraries/Blob/Blob.js

@@ -105,6 +105,12 @@ class Blob {
       blobId: this.data.blobId,
       offset,
       size,
+      /* Since `blob.slice()` creates a new view onto the same binary
+       * data as the original blob, we should re-use the same collector
+       * object so that the underlying resource gets deallocated when
+       * the last view into the data is released, not the first.
+       */
+      __collector: this.data.__collector,
     });
   }
 

package/Libraries/Blob/BlobManager.js

@@ -8,13 +8,14 @@
  * @format
  */
 
-const Blob = require('./Blob');
-const BlobRegistry = require('./BlobRegistry');
+import type {BlobCollector, BlobData, BlobOptions} from './BlobTypes';
 
-import type {BlobData, BlobOptions, BlobCollector} from './BlobTypes';
 import NativeBlobModule from './NativeBlobModule';
 import invariant from 'invariant';
 
+const Blob = require('./Blob');
+const BlobRegistry = require('./BlobRegistry');
+
 /*eslint-disable no-bitwise */
 /*eslint-disable eqeqeq */
 
@@ -110,6 +111,7 @@ class BlobManager {
    */
   static createFromOptions(options: BlobData): Blob {
     BlobRegistry.register(options.blobId);
+    // $FlowFixMe[prop-missing]
     return Object.assign(Object.create(Blob.prototype), {
       data:
         // Reuse the collector instance when creating from an existing blob.

package/Libraries/Blob/File.js

@@ -10,12 +10,11 @@
 
 'use strict';
 
-const Blob = require('./Blob');
+import type {BlobOptions} from './BlobTypes';
 
+const Blob = require('./Blob');
 const invariant = require('invariant');
 
-import type {BlobOptions} from './BlobTypes';
-
 /**
  * The File interface provides information about files.
  */

package/Libraries/Blob/FileReader.js

@@ -8,11 +8,12 @@
  * @format
  */
 
-const Blob = require('./Blob');
-const EventTarget = require('event-target-shim');
+import type Blob from './Blob';
 
 import NativeFileReaderModule from './NativeFileReaderModule';
 
+const EventTarget = require('event-target-shim');
+
 type ReadyState =
   | 0 // EMPTY
   | 1 // LOADING
@@ -46,7 +47,6 @@ class FileReader extends (EventTarget(...READER_EVENTS): any) {
   _error: ?Error;
   _result: ?ReaderResult;
   _aborted: boolean = false;
-  _subscriptions: Array<any> = [];
 
   constructor() {
     super();
@@ -59,11 +59,6 @@ class FileReader extends (EventTarget(...READER_EVENTS): any) {
     this._result = null;
   }
 
-  _clearSubscriptions(): void {
-    this._subscriptions.forEach(sub => sub.remove());
-    this._subscriptions = [];
-  }
-
   _setReadyState(newState: ReadyState) {
     this._readyState = newState;
     this.dispatchEvent({type: 'readystatechange'});
@@ -79,11 +74,11 @@ class FileReader extends (EventTarget(...READER_EVENTS): any) {
     }
   }
 
-  readAsArrayBuffer() {
+  readAsArrayBuffer(): any {
     throw new Error('FileReader.readAsArrayBuffer is not implemented');
   }
 
-  readAsDataURL(blob: ?Blob) {
+  readAsDataURL(blob: ?Blob): void {
     this._aborted = false;
 
     if (blob == null) {
@@ -110,7 +105,7 @@ class FileReader extends (EventTarget(...READER_EVENTS): any) {
     );
   }
 
-  readAsText(blob: ?Blob, encoding: string = 'UTF-8') {
+  readAsText(blob: ?Blob, encoding: string = 'UTF-8'): void {
     this._aborted = false;
 
     if (blob == null) {

package/Libraries/Blob/NativeBlobModule.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {

package/Libraries/Blob/NativeFileReaderModule.js

@@ -9,6 +9,7 @@
  */
 
 import type {TurboModule} from '../TurboModule/RCTExport';
+
 import * as TurboModuleRegistry from '../TurboModule/TurboModuleRegistry';
 
 export interface Spec extends TurboModule {