react-native-tvos 0.79.3-0 → 0.80.0-0

package/Libraries/Utilities/setAndForwardRef.js

@@ -10,11 +10,11 @@
 
 'use strict';
 
-import type {ElementRef} from 'react';
+import * as React from 'react';
 
 type Args = $ReadOnly<{|
-  getForwardedRef: () => ?ElementRef<any>,
-  setLocalRef: (ref: ElementRef<any>) => mixed,
+  getForwardedRef: () => ?React.ElementRef<any>,
+  setLocalRef: (ref: React.ElementRef<any>) => mixed,
 |}>;
 
 /**
@@ -51,8 +51,8 @@ type Args = $ReadOnly<{|
 function setAndForwardRef({
   getForwardedRef,
   setLocalRef,
-}: Args): (ref: ElementRef<any>) => void {
-  return function forwardRef(ref: ElementRef<any>) {
+}: Args): (ref: React.ElementRef<any>) => void {
+  return function forwardRef(ref: React.ElementRef<any>) {
     const forwardedRef = getForwardedRef();
 
     setLocalRef(ref);
@@ -68,4 +68,4 @@ function setAndForwardRef({
   };
 }
 
-module.exports = setAndForwardRef;
+export default setAndForwardRef;

package/Libraries/Vibration/React-RCTVibration.podspec

@@ -16,12 +16,7 @@ else
   source[:tag] = "v#{version}"
 end
 
-folly_config = get_folly_config()
-folly_compiler_flags = folly_config[:compiler_flags]
-folly_version = folly_config[:version]
-
 header_search_paths = [
-  "\"$(PODS_ROOT)/RCT-Folly\"",
   "\"${PODS_ROOT}/Headers/Public/ReactCodegen/react/renderer/components\"",
 ]
 
@@ -34,7 +29,7 @@ Pod::Spec.new do |s|
   s.license                = package["license"]
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
-  s.compiler_flags         = folly_compiler_flags + ' -Wno-nullability-completeness'
+  s.compiler_flags         = '-Wno-nullability-completeness'
   s.source                 = source
   s.source_files           = "*.{m,mm}"
   s.preserve_paths         = "package.json", "LICENSE", "LICENSE-docs"
@@ -46,11 +41,12 @@ Pod::Spec.new do |s|
                              }
   s.frameworks             = "AudioToolbox"
 
-  s.dependency "RCT-Folly", folly_version
   s.dependency "React-jsi"
   s.dependency "React-Core/RCTVibrationHeaders"
 
   add_dependency(s, "React-RCTFBReactNativeSpec")
   add_dependency(s, "ReactCommon", :subspec => "turbomodule/core", :additional_framework_paths => ["react/nativemodule/core"])
   add_dependency(s, "React-NativeModulesApple")
+
+  add_rn_third_party_dependencies(s)
 end

package/Libraries/WebSocket/WebSocket.js

@@ -8,13 +8,318 @@
  * @flow
  */
 
-import typeof WebSocket from './WebSocket_old';
+import type {EventCallback} from '../../src/private/webapis/dom/events/EventTarget';
+import type {BlobData} from '../Blob/BlobTypes';
+import type {EventSubscription} from '../vendor/emitter/EventEmitter';
 
-// Use a global instead of a flag from ReactNativeFeatureFlags because this will
-// be read before apps have a chance to set overrides.
-const useBuiltInEventTarget = global.RN$useBuiltInEventTarget?.();
+import Event from '../../src/private/webapis/dom/events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../../src/private/webapis/dom/events/EventHandlerAttributes';
+import EventTarget from '../../src/private/webapis/dom/events/EventTarget';
+import MessageEvent from '../../src/private/webapis/html/events/MessageEvent';
+import CloseEvent from '../../src/private/webapis/websockets/events/CloseEvent';
+import Blob from '../Blob/Blob';
+import BlobManager from '../Blob/BlobManager';
+import NativeEventEmitter from '../EventEmitter/NativeEventEmitter';
+import binaryToBase64 from '../Utilities/binaryToBase64';
+import Platform from '../Utilities/Platform';
+import NativeWebSocketModule from './NativeWebSocketModule';
+import base64 from 'base64-js';
+import invariant from 'invariant';
 
-export default (useBuiltInEventTarget
-  ? // $FlowExpectedError[incompatible-cast]
-    require('./WebSocket_new').default
-  : require('./WebSocket_old').default) as WebSocket;
+type ArrayBufferView =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | DataView;
+
+type BinaryType = 'blob' | 'arraybuffer';
+
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSING = 2;
+const CLOSED = 3;
+
+const CLOSE_NORMAL = 1000;
+
+// Abnormal closure where no code is provided in a control frame
+// https://www.rfc-editor.org/rfc/rfc6455.html#section-7.1.5
+const CLOSE_ABNORMAL = 1006;
+
+let nextWebSocketId = 0;
+
+type WebSocketEventDefinitions = {
+  websocketOpen: [{id: number, protocol: string}],
+  websocketClosed: [{id: number, code: number, reason: string}],
+  websocketMessage: [
+    | {type: 'binary', id: number, data: string}
+    | {type: 'text', id: number, data: string}
+    | {type: 'blob', id: number, data: BlobData},
+  ],
+  websocketFailed: [{id: number, message: string}],
+};
+
+/**
+ * Browser-compatible WebSockets implementation.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+ * See https://github.com/websockets/ws
+ */
+class WebSocket extends EventTarget {
+  static CONNECTING: number = CONNECTING;
+  static OPEN: number = OPEN;
+  static CLOSING: number = CLOSING;
+  static CLOSED: number = CLOSED;
+
+  CONNECTING: number = CONNECTING;
+  OPEN: number = OPEN;
+  CLOSING: number = CLOSING;
+  CLOSED: number = CLOSED;
+
+  _socketId: number;
+  _eventEmitter: NativeEventEmitter<WebSocketEventDefinitions>;
+  _subscriptions: Array<EventSubscription>;
+  _binaryType: ?BinaryType;
+
+  bufferedAmount: number;
+  extension: ?string;
+  protocol: ?string;
+  readyState: number = CONNECTING;
+  url: ?string;
+
+  constructor(
+    url: string,
+    protocols: ?string | ?Array<string>,
+    options: ?{headers?: {origin?: string, ...}, ...},
+  ) {
+    super();
+    this.url = url;
+    if (typeof protocols === 'string') {
+      protocols = [protocols];
+    }
+
+    const {headers = {}, ...unrecognized} = options || {};
+
+    // Preserve deprecated backwards compatibility for the 'origin' option
+    // $FlowFixMe[prop-missing]
+    if (unrecognized && typeof unrecognized.origin === 'string') {
+      console.warn(
+        'Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.',
+      );
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
+      headers.origin = unrecognized.origin;
+      /* $FlowFixMe[prop-missing] (>=0.54.0 site=react_native_fb,react_native_
+       * oss) This comment suppresses an error found when Flow v0.54 was
+       * deployed. To see the error delete this comment and run Flow. */
+      delete unrecognized.origin;
+    }
+
+    // Warn about and discard anything else
+    if (Object.keys(unrecognized).length > 0) {
+      console.warn(
+        'Unrecognized WebSocket connection option(s) `' +
+          Object.keys(unrecognized).join('`, `') +
+          '`. ' +
+          'Did you mean to put these under `headers`?',
+      );
+    }
+
+    if (!Array.isArray(protocols)) {
+      protocols = null;
+    }
+
+    this._eventEmitter = new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeWebSocketModule,
+    );
+    this._socketId = nextWebSocketId++;
+    this._registerEvents();
+    NativeWebSocketModule.connect(url, protocols, {headers}, this._socketId);
+  }
+
+  get binaryType(): ?BinaryType {
+    return this._binaryType;
+  }
+
+  set binaryType(binaryType: BinaryType): void {
+    if (binaryType !== 'blob' && binaryType !== 'arraybuffer') {
+      throw new Error("binaryType must be either 'blob' or 'arraybuffer'");
+    }
+    if (this._binaryType === 'blob' || binaryType === 'blob') {
+      invariant(
+        BlobManager.isAvailable,
+        'Native module BlobModule is required for blob support',
+      );
+      if (binaryType === 'blob') {
+        BlobManager.addWebSocketHandler(this._socketId);
+      } else {
+        BlobManager.removeWebSocketHandler(this._socketId);
+      }
+    }
+    this._binaryType = binaryType;
+  }
+
+  close(code?: number, reason?: string): void {
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+      return;
+    }
+
+    this.readyState = this.CLOSING;
+    this._close(code, reason);
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView | Blob): void {
+    if (this.readyState === this.CONNECTING) {
+      throw new Error('INVALID_STATE_ERR');
+    }
+
+    if (data instanceof Blob) {
+      invariant(
+        BlobManager.isAvailable,
+        'Native module BlobModule is required for blob support',
+      );
+      BlobManager.sendOverSocket(data, this._socketId);
+      return;
+    }
+
+    if (typeof data === 'string') {
+      NativeWebSocketModule.send(data, this._socketId);
+      return;
+    }
+
+    if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      NativeWebSocketModule.sendBinary(binaryToBase64(data), this._socketId);
+      return;
+    }
+
+    throw new Error('Unsupported data type');
+  }
+
+  ping(): void {
+    if (this.readyState === this.CONNECTING) {
+      throw new Error('INVALID_STATE_ERR');
+    }
+
+    NativeWebSocketModule.ping(this._socketId);
+  }
+
+  _close(code?: number, reason?: string): void {
+    // See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+    const statusCode = typeof code === 'number' ? code : CLOSE_NORMAL;
+    const closeReason = typeof reason === 'string' ? reason : '';
+    NativeWebSocketModule.close(statusCode, closeReason, this._socketId);
+
+    if (BlobManager.isAvailable && this._binaryType === 'blob') {
+      BlobManager.removeWebSocketHandler(this._socketId);
+    }
+  }
+
+  _unregisterEvents(): void {
+    this._subscriptions.forEach(e => e.remove());
+    this._subscriptions = [];
+  }
+
+  _registerEvents(): void {
+    this._subscriptions = [
+      this._eventEmitter.addListener('websocketMessage', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        let data: Blob | BlobData | ArrayBuffer | string = ev.data;
+        switch (ev.type) {
+          case 'binary':
+            data = base64.toByteArray(ev.data).buffer;
+            break;
+          case 'blob':
+            data = BlobManager.createFromOptions(ev.data);
+            break;
+        }
+        this.dispatchEvent(new MessageEvent('message', {data}));
+      }),
+      this._eventEmitter.addListener('websocketOpen', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.OPEN;
+        this.protocol = ev.protocol;
+        this.dispatchEvent(new Event('open'));
+      }),
+      this._eventEmitter.addListener('websocketClosed', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.CLOSED;
+        this.dispatchEvent(
+          new CloseEvent('close', {
+            code: ev.code,
+            reason: ev.reason,
+            // TODO: missing `wasClean` (exposed on iOS as `clean` but missing on Android)
+          }),
+        );
+        this._unregisterEvents();
+        this.close();
+      }),
+      this._eventEmitter.addListener('websocketFailed', ev => {
+        if (ev.id !== this._socketId) {
+          return;
+        }
+        this.readyState = this.CLOSED;
+        this.dispatchEvent(new Event('error'));
+        this.dispatchEvent(
+          new CloseEvent('close', {
+            code: CLOSE_ABNORMAL,
+            reason: ev.message,
+            // TODO: Expose `wasClean`
+          }),
+        );
+        this._unregisterEvents();
+        this.close();
+      }),
+    ];
+  }
+
+  get onclose(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'close');
+  }
+
+  set onclose(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'close', listener);
+  }
+
+  get onerror(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'error');
+  }
+
+  set onerror(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'error', listener);
+  }
+
+  get onmessage(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'message');
+  }
+
+  set onmessage(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'message', listener);
+  }
+
+  get onopen(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'open');
+  }
+
+  set onopen(listener: ?EventCallback) {
+    setEventHandlerAttribute(this, 'open', listener);
+  }
+}
+
+export default WebSocket;

package/Libraries/vendor/core/ErrorUtils.js

@@ -8,7 +8,33 @@
  * @flow strict
  */
 
-import type {ErrorUtilsT} from '@react-native/js-polyfills/error-guard';
+// From @react-native/js-polyfills
+type ErrorHandler = (error: mixed, isFatal: boolean) => void;
+type Fn<Args: $ReadOnlyArray<mixed>, Return> = (...Args) => Return;
+export type ErrorUtils = {
+  applyWithGuard<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    context?: mixed,
+    args?: ?TArgs,
+    unused_onError?: null,
+    unused_name?: ?string,
+  ): ?TOut,
+  applyWithGuardIfNeeded<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    context?: mixed,
+    args?: ?TArgs,
+  ): ?TOut,
+  getGlobalHandler(): ErrorHandler,
+  guard<TArgs: $ReadOnlyArray<mixed>, TOut>(
+    fun: Fn<TArgs, TOut>,
+    name?: ?string,
+    context?: mixed,
+  ): ?(...TArgs) => ?TOut,
+  inGuard(): boolean,
+  reportError(error: mixed): void,
+  reportFatalError(error: mixed): void,
+  setGlobalHandler(fun: ErrorHandler): void,
+};
 
 /**
  * The particular require runtime that we are using looks for a global
@@ -22,4 +48,4 @@ import type {ErrorUtilsT} from '@react-native/js-polyfills/error-guard';
  * that use it aren't just using a global variable, so simply export the global
  * variable here. ErrorUtils is originally defined in a file named error-guard.js.
  */
-export default (global.ErrorUtils: ErrorUtilsT);
+export default global.ErrorUtils as ErrorUtils;

package/Libraries/vendor/emitter/EventEmitter.js

@@ -72,8 +72,12 @@ export default class EventEmitter<
   > = $ReadOnly<Record<string, $ReadOnlyArray<UnsafeObject>>>,
 > implements IEventEmitter<TEventToArgsMap>
 {
-  // $FlowFixMe[incompatible-type]
-  #registry: Registry<TEventToArgsMap> = {};
+  #registry: Registry<TEventToArgsMap>;
+
+  constructor() {
+    // $FlowFixMe[incompatible-type]
+    this.#registry = {};
+  }
 
   /**
    * Registers a listener that is called when the supplied event is emitted.

package/README-core.md

@@ -138,7 +138,4 @@ Larger discussions and proposals are discussed in [**@react-native-community/dis
 
 React Native is MIT licensed, as found in the [LICENSE][l] file.
 
-React Native documentation is Creative Commons licensed, as found in the [LICENSE-docs][ld] file.
-
 [l]: https://github.com/facebook/react-native/blob/main/LICENSE
-[ld]: https://github.com/facebook/react-native/blob/main/LICENSE-docs

package/React/Base/RCTBridge.h

@@ -38,6 +38,11 @@ RCT_EXTERN_C_BEGIN
  */
 NSString *RCTBridgeModuleNameForClass(Class bridgeModuleClass);
 
+/**
+ * This function returns the list of modules that have been registered using the Old Architecture mechanism.
+ */
+NSMutableArray<NSString *> *getModulesLoadedWithOldArch(void);
+
 /**
  * Experimental.
  * Check/set if JSI-bound NativeModule is enabled. By default it's off.
@@ -77,9 +82,6 @@ void RCTSetTurboModuleInteropBridgeProxyLogLevel(RCTBridgeProxyLoggingLevel logL
 BOOL RCTTurboModuleInteropForAllTurboModulesEnabled(void);
 void RCTEnableTurboModuleInteropForAllTurboModules(BOOL enabled);
 
-BOOL RCTBridgeModuleBatchDidCompleteDisabled(void);
-void RCTDisableBridgeModuleBatchDidComplete(BOOL disabled);
-
 typedef enum {
   kRCTGlobalScope,
   kRCTGlobalScopeUsingRetainJSCallback,

package/React/Base/RCTBridge.mm

@@ -15,7 +15,6 @@
 #if RCT_ENABLE_INSPECTOR
 #import "RCTInspectorDevServerHelper.h"
 #endif
-#import <React/RCTInitializeUIKitProxies.h>
 #import <jsinspector-modern/InspectorFlags.h>
 #import <jsinspector-modern/InspectorInterfaces.h>
 #import <jsinspector-modern/ReactCdp.h>
@@ -43,6 +42,97 @@ NSArray<Class> *RCTGetModuleClasses(void)
   return result;
 }
 
+NSSet<NSString *> *getCoreModuleClasses(void);
+NSSet<NSString *> *getCoreModuleClasses(void)
+{
+  static NSSet<NSString *> *coreModuleClasses = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    coreModuleClasses = [NSSet setWithArray:@[
+      @"RCTViewManager",
+      @"RCTActivityIndicatorViewManager",
+      @"RCTDebuggingOverlayManager",
+      @"RCTModalHostViewManager",
+      @"RCTModalManager",
+      @"RCTRefreshControlManager",
+      @"RCTSafeAreaViewManager",
+      @"RCTScrollContentViewManager",
+      @"RCTScrollViewManager",
+      @"RCTSwitchManager",
+      @"RCTUIManager",
+      @"RCTAccessibilityManager",
+      @"RCTActionSheetManager",
+      @"RCTAlertManager",
+      @"RCTAppearance",
+      @"RCTAppState",
+      @"RCTClipboard",
+      @"RCTDeviceInfo",
+      @"RCTDevLoadingView",
+      @"RCTDevMenu",
+      @"RCTDevSettings",
+      @"RCTDevToolsRuntimeSettingsModule",
+      @"RCTEventDispatcher",
+      @"RCTExceptionsManager",
+      @"RCTI18nManager",
+      @"RCTKeyboardObserver",
+      @"RCTLogBox",
+      @"RCTPerfMonitor",
+      @"RCTPlatform",
+      @"RCTRedBox",
+      @"RCTSourceCode",
+      @"RCTStatusBarManager",
+      @"RCTTiming",
+      @"RCTWebSocketModule",
+      @"RCTNativeAnimatedModule",
+      @"RCTNativeAnimatedTurboModule",
+      @"RCTBlobManager",
+      @"RCTFileReaderModule",
+      @"RCTBundleAssetImageLoader",
+      @"RCTGIFImageDecoder",
+      @"RCTImageEditingManager",
+      @"RCTImageLoader",
+      @"RCTImageStoreManager",
+      @"RCTImageViewManager",
+      @"RCTLocalAssetImageLoader",
+      @"RCTLinkingManager",
+      @"RCTDataRequestHandler",
+      @"RCTFileRequestHandler",
+      @"RCTHTTPRequestHandler",
+      @"RCTNetworking",
+      @"RCTPushNotificationManager",
+      @"RCTSettingsManager",
+      @"RCTBaseTextViewManager",
+      @"RCTBaseTextInputViewManager",
+      @"RCTInputAccessoryViewManager",
+      @"RCTMultilineTextInputViewManager",
+      @"RCTRawTextViewManager",
+      @"RCTSinglelineTextInputViewManager",
+      @"RCTTextViewManager",
+      @"RCTVirtualTextViewManager",
+      @"RCTVibration",
+    ]];
+  });
+
+  return coreModuleClasses;
+}
+
+static NSMutableArray<NSString *> *modulesLoadedWithOldArch;
+void addModuleLoadedWithOldArch(NSString *);
+void addModuleLoadedWithOldArch(NSString *moduleName)
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    modulesLoadedWithOldArch = [NSMutableArray new];
+  });
+
+  [modulesLoadedWithOldArch addObject:moduleName];
+}
+
+NSMutableArray<NSString *> *getModulesLoadedWithOldArch(void)
+{
+  return modulesLoadedWithOldArch;
+}
+
 /**
  * Register the given class as a bridge module. All modules must be registered
  * prior to the first bridge initialization.
@@ -51,6 +141,10 @@ NSArray<Class> *RCTGetModuleClasses(void)
 void RCTRegisterModule(Class);
 void RCTRegisterModule(Class moduleClass)
 {
+  if (RCTAreLegacyLogsEnabled() && RCTIsNewArchEnabled() &&
+      ![getCoreModuleClasses() containsObject:[moduleClass description]]) {
+    addModuleLoadedWithOldArch([moduleClass description]);
+  }
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
     RCTModuleClasses = [NSMutableArray new];
@@ -160,17 +254,6 @@ void RCTEnableTurboModuleSyncVoidMethods(BOOL enabled)
   gTurboModuleEnableSyncVoidMethods = enabled;
 }
 
-static BOOL gBridgeModuleDisableBatchDidComplete = NO;
-BOOL RCTBridgeModuleBatchDidCompleteDisabled(void)
-{
-  return gBridgeModuleDisableBatchDidComplete;
-}
-
-void RCTDisableBridgeModuleBatchDidComplete(BOOL disabled)
-{
-  gBridgeModuleDisableBatchDidComplete = disabled;
-}
-
 BOOL kDispatchAccessibilityManagerInitOntoMain = NO;
 BOOL RCTUIManagerDispatchAccessibilityManagerInitOntoMain(void)
 {
@@ -512,7 +595,6 @@ RCT_NOT_IMPLEMENTED(-(instancetype)init)
   _bundleURL = [RCTConvert NSURL:_bundleURL.absoluteString];
 
   RCTExecuteOnMainQueue(^{
-    RCTInitializeUIKitProxies();
     RCTRegisterReloadCommandListener(self);
     RCTReloadCommandSetBundleURL(self->_bundleURL);
   });

package/React/Base/RCTBridgeProxy.mm

@@ -475,7 +475,7 @@ using namespace facebook;
 
 - (void)forwardInvocation:(NSInvocation *)invocation
 {
-  [self logError:@"This methid is unsupported." cmd:invocation.selector];
+  [self logError:@"This method is unsupported." cmd:invocation.selector];
 }
 
 /**

package/React/Base/RCTUtils.h

@@ -18,7 +18,13 @@ NS_ASSUME_NONNULL_BEGIN
 
 // Whether the New Architecture is enabled or not
 RCT_EXTERN BOOL RCTIsNewArchEnabled(void);
-RCT_EXTERN void RCTSetNewArchEnabled(BOOL enabled);
+RCT_EXTERN void RCTSetNewArchEnabled(BOOL enabled) __attribute__((deprecated(
+    "This function is now no-op. You need to modify the Info.plist adding a RCTNewArchEnabled bool property to control whether the New Arch is enabled or not")));
+;
+
+// Whether React native should output logs for modules and components used
+// through the interop layers
+RCT_EXTERN BOOL RCTAreLegacyLogsEnabled(void);
 
 // JSON serialization/deserialization
 RCT_EXTERN NSString *__nullable RCTJSONStringify(id __nullable jsonObject, NSError **error);
@@ -43,9 +49,7 @@ RCT_EXTERN void RCTExecuteOnMainQueue(dispatch_block_t block);
 // Legacy function to execute the specified block on the main queue synchronously.
 // Please do not use this unless you know what you're doing.
 RCT_EXTERN void RCTUnsafeExecuteOnMainQueueSync(dispatch_block_t block);
-
-// Get screen scale, can be only used on main
-RCT_EXTERN void RCTComputeScreenScale(void);
+RCT_EXTERN void RCTUnsafeExecuteOnMainQueueSyncWithError(dispatch_block_t block, NSString *context);
 
 // Get screen metrics in a thread-safe way
 RCT_EXTERN CGFloat RCTScreenScale(void);
@@ -56,7 +60,6 @@ RCT_EXTERN CGSize RCTViewportSize(void);
 // Round float coordinates to nearest whole screen pixel (not point)
 RCT_EXTERN CGFloat RCTRoundPixelValue(CGFloat value);
 RCT_EXTERN CGFloat RCTCeilPixelValue(CGFloat value);
-RCT_EXTERN CGFloat RCTFloorPixelValue(CGFloat value);
 
 // Convert a size in points to pixels, rounded up to the nearest integral size
 RCT_EXTERN CGSize RCTSizeInPixels(CGSize pointSize, CGFloat scale);