react-native 0.70.6 → 0.71.0-rc.1

package/Libraries/AppDelegate/RCTAppDelegate.mm

@@ -0,0 +1,164 @@
+/*
+ * 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/RCTFabricSurfaceHostingProxyRootView.h>
+#import <React/RCTSurfacePresenter.h>
+#import <react/config/ReactNativeConfig.h>
+
+static NSString *const kRNConcurrentRoot = @"concurrentRoot";
+
+@interface RCTAppDelegate () {
+  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, *)) {
+    rootView.backgroundColor = [UIColor systemBackgroundColor];
+  } 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 = [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" }
+  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.

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

@@ -241,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);
@@ -252,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: mixed) => {
+      const isValidArgument = (val: mixed): boolean => {
         switch (typeof val) {
           case 'undefined':
           case 'boolean':
@@ -321,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],
@@ -380,7 +381,7 @@ class MessageQueue {
     return (
       // $FlowFixMe[cannot-resolve-name]
       typeof DebuggerInternal !== 'undefined' &&
-      DebuggerInternal.shouldPauseOnThrow === true // eslint-disable-line no-undef
+      DebuggerInternal.shouldPauseOnThrow === true
     );
   }
 
@@ -408,9 +409,12 @@ class MessageQueue {
       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. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
+        `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.`,
       );
     }
@@ -424,7 +428,7 @@ class MessageQueue {
     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

@@ -155,6 +155,7 @@ function genMethod(moduleID: number, methodID: number, type: MethodType) {
       }
     };
   }
+  // $FlowFixMe[prop-missing]
   fn.type = type;
   return fn;
 }

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
@@ -73,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) {
@@ -104,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 {

package/Libraries/Blob/RCTBlobCollector.h

@@ -7,8 +7,6 @@
 
 #import <jsi/jsi.h>
 
-using namespace facebook;
-
 @class RCTBlobManager;
 
 namespace facebook {

package/Libraries/Blob/RCTBlobCollector.mm

@@ -7,16 +7,19 @@
 
 #import "RCTBlobCollector.h"
 
-#import <React/RCTBridge+Private.h>
 #import <React/RCTBlobManager.h>
+#import <React/RCTBridge+Private.h>
 
 namespace facebook {
 namespace react {
 
 RCTBlobCollector::RCTBlobCollector(RCTBlobManager *blobManager, const std::string &blobId)
-: blobId_(blobId), blobManager_(blobManager) {}
+    : blobId_(blobId), blobManager_(blobManager)
+{
+}
 
-RCTBlobCollector::~RCTBlobCollector() {
+RCTBlobCollector::~RCTBlobCollector()
+{
   RCTBlobManager *blobManager = blobManager_;
   NSString *blobId = [NSString stringWithUTF8String:blobId_.c_str()];
   dispatch_async([blobManager_ methodQueue], ^{
@@ -24,28 +27,29 @@ RCTBlobCollector::~RCTBlobCollector() {
   });
 }
 
-void RCTBlobCollector::install(RCTBlobManager *blobManager) {
+void RCTBlobCollector::install(RCTBlobManager *blobManager)
+{
   __weak RCTCxxBridge *cxxBridge = (RCTCxxBridge *)blobManager.bridge;
-  [cxxBridge dispatchBlock:^{
-    if (!cxxBridge || cxxBridge.runtime == nullptr) {
-      return;
-    }
-    jsi::Runtime &runtime = *(jsi::Runtime *)cxxBridge.runtime;
-    runtime.global().setProperty(
-      runtime,
-      "__blobCollectorProvider",
-      jsi::Function::createFromHostFunction(
-        runtime,
-        jsi::PropNameID::forAscii(runtime, "__blobCollectorProvider"),
-        1,
-        [blobManager](jsi::Runtime& rt, const jsi::Value& thisVal, const jsi::Value* args, size_t count) {
-          auto blobId = args[0].asString(rt).utf8(rt);
-          auto blobCollector = std::make_shared<RCTBlobCollector>(blobManager, blobId);
-          return jsi::Object::createFromHostObject(rt, blobCollector);
+  [cxxBridge
+      dispatchBlock:^{
+        if (!cxxBridge || cxxBridge.runtime == nullptr) {
+          return;
         }
-      )
-    );
-  } queue:RCTJSThread];
+        jsi::Runtime &runtime = *(jsi::Runtime *)cxxBridge.runtime;
+        runtime.global().setProperty(
+            runtime,
+            "__blobCollectorProvider",
+            jsi::Function::createFromHostFunction(
+                runtime,
+                jsi::PropNameID::forAscii(runtime, "__blobCollectorProvider"),
+                1,
+                [blobManager](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
+                  auto blobId = args[0].asString(rt).utf8(rt);
+                  auto blobCollector = std::make_shared<RCTBlobCollector>(blobManager, blobId);
+                  return jsi::Object::createFromHostObject(rt, blobCollector);
+                }));
+      }
+              queue:RCTJSThread];
 }
 
 } // namespace react

package/Libraries/Blob/RCTBlobManager.h

@@ -7,8 +7,8 @@
 
 #import <React/RCTBridge.h>
 #import <React/RCTBridgeModule.h>
-#import <React/RCTURLRequestHandler.h>
 #import <React/RCTInitializing.h>
+#import <React/RCTURLRequestHandler.h>
 
 @interface RCTBlobManager : NSObject <RCTBridgeModule, RCTURLRequestHandler, RCTInitializing>