first commit

node_modules/react-native/Libraries/BatchedBridge/BatchedBridge.js

@@ -0,0 +1,31 @@
+/**
+ * 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
+ * @deprecated
+ */
+
+'use strict';
+
+import typeof MessageQueueT from './MessageQueue';
+
+const MessageQueue: MessageQueueT = require('./MessageQueue').default;
+
+const BatchedBridge: MessageQueue = new MessageQueue();
+
+// Wire up the batched bridge on the global object so that we can call into it.
+// Ideally, this would be the inverse relationship. I.e. the native environment
+// provides this global directly with its script embedded. Then this module
+// would export it. A possible fix would be to trim the dependencies in
+// MessageQueue to its minimal features and embed that in the native runtime.
+
+Object.defineProperty(global, '__fbBatchedBridge', {
+  configurable: true,
+  value: BatchedBridge,
+});
+
+export default BatchedBridge;

node_modules/react-native/Libraries/BatchedBridge/MessageQueue.js

@@ -0,0 +1,498 @@
+/**
+ * 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
+ * @deprecated
+ */
+
+'use strict';
+
+const Systrace = require('../Performance/Systrace');
+const deepFreezeAndThrowOnMutationInDev =
+  require('../Utilities/deepFreezeAndThrowOnMutationInDev').default;
+const stringifySafe = require('../Utilities/stringifySafe').default;
+const warnOnce = require('../Utilities/warnOnce').default;
+const ErrorUtils = require('../vendor/core/ErrorUtils').default;
+const invariant = require('invariant');
+
+export type SpyData = {
+  type: number,
+  module: ?string,
+  method: string | number,
+  args: mixed[],
+  ...
+};
+
+const TO_JS = 0;
+const TO_NATIVE = 1;
+
+const MODULE_IDS = 0;
+const METHOD_IDS = 1;
+const PARAMS = 2;
+const MIN_TIME_BETWEEN_FLUSHES_MS = 5;
+
+// eslint-disable-next-line no-bitwise
+const TRACE_TAG_REACT = 1 << 13;
+
+const DEBUG_INFO_LIMIT = 32;
+
+class MessageQueue {
+  _lazyCallableModules: {[key: string]: (void) => {...}, ...};
+  _queue: [number[], number[], mixed[], number];
+  _successCallbacks: Map<number, ?(...mixed[]) => void>;
+  _failureCallbacks: Map<number, ?(...mixed[]) => void>;
+  _callID: number;
+  _lastFlush: number;
+  _eventLoopStartTime: number;
+  _reactNativeMicrotasksCallback: ?() => void;
+
+  _debugInfo: {[number]: [number, number], ...};
+  _remoteModuleTable: {[number]: string, ...};
+  _remoteMethodTable: {[number]: $ReadOnlyArray<string>, ...};
+
+  __spy: ?(data: SpyData) => void;
+
+  constructor() {
+    this._lazyCallableModules = {};
+    this._queue = [[], [], [], 0];
+    this._successCallbacks = new Map();
+    this._failureCallbacks = new Map();
+    this._callID = 0;
+    this._lastFlush = 0;
+    this._eventLoopStartTime = Date.now();
+    this._reactNativeMicrotasksCallback = null;
+
+    if (__DEV__) {
+      this._debugInfo = {};
+      this._remoteModuleTable = {};
+      this._remoteMethodTable = {};
+    }
+
+    // $FlowFixMe[cannot-write]
+    this.callFunctionReturnFlushedQueue =
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.callFunctionReturnFlushedQueue.bind(this);
+    // $FlowFixMe[cannot-write]
+    // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+    this.flushedQueue = this.flushedQueue.bind(this);
+
+    // $FlowFixMe[cannot-write]
+    this.invokeCallbackAndReturnFlushedQueue =
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.invokeCallbackAndReturnFlushedQueue.bind(this);
+  }
+
+  /**
+   * Public APIs
+   */
+
+  static spy(spyOrToggle: boolean | ((data: SpyData) => void)) {
+    if (spyOrToggle === true) {
+      MessageQueue.prototype.__spy = info => {
+        console.log(
+          `${info.type === TO_JS ? 'N->JS' : 'JS->N'} : ` +
+            `${info.module != null ? info.module + '.' : ''}${info.method}` +
+            `(${JSON.stringify(info.args)})`,
+        );
+      };
+    } else if (spyOrToggle === false) {
+      MessageQueue.prototype.__spy = null;
+    } else {
+      MessageQueue.prototype.__spy = spyOrToggle;
+    }
+  }
+
+  callFunctionReturnFlushedQueue(
+    module: string,
+    method: string,
+    args: mixed[],
+  ): null | [Array<number>, Array<number>, Array<mixed>, number] {
+    this.__guard(() => {
+      this.__callFunction(module, method, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  invokeCallbackAndReturnFlushedQueue(
+    cbID: number,
+    args: mixed[],
+  ): null | [Array<number>, Array<number>, Array<mixed>, number] {
+    this.__guard(() => {
+      this.__invokeCallback(cbID, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  flushedQueue(): null | [Array<number>, Array<number>, Array<mixed>, number] {
+    this.__guard(() => {
+      this.__callReactNativeMicrotasks();
+    });
+
+    const queue = this._queue;
+    this._queue = [[], [], [], this._callID];
+    return queue[0].length ? queue : null;
+  }
+
+  getEventLoopRunningTime(): number {
+    return Date.now() - this._eventLoopStartTime;
+  }
+
+  registerCallableModule(name: string, module: {...}) {
+    this._lazyCallableModules[name] = () => module;
+  }
+
+  registerLazyCallableModule(name: string, factory: void => interface {}) {
+    let module: interface {};
+    let getValue: ?(void) => interface {} = factory;
+    this._lazyCallableModules[name] = () => {
+      if (getValue) {
+        module = getValue();
+        getValue = null;
+      }
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      return module;
+    };
+  }
+
+  getCallableModule(name: string): {...} | null {
+    const getValue = this._lazyCallableModules[name];
+    /* $FlowFixMe[constant-condition] Error discovered during Constant
+     * Condition roll out. See https://fburl.com/workplace/1v97vimq. */
+    return getValue ? getValue() : null;
+  }
+
+  callNativeSyncHook(
+    moduleID: number,
+    methodID: number,
+    params: mixed[],
+    onFail: ?(...mixed[]) => void,
+    onSucc: ?(...mixed[]) => void,
+  ): mixed {
+    if (__DEV__) {
+      invariant(
+        global.nativeCallSyncHook,
+        'Calling synchronous methods on native ' +
+          'modules is not supported in Chrome.\n\n Consider providing alternative ' +
+          'methods to expose this method in debug mode, e.g. by exposing constants ' +
+          'ahead-of-time.',
+      );
+    }
+    this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
+    return global.nativeCallSyncHook(moduleID, methodID, params);
+  }
+
+  processCallbacks(
+    moduleID: number,
+    methodID: number,
+    params: mixed[],
+    onFail: ?(...mixed[]) => void,
+    onSucc: ?(...mixed[]) => void,
+  ): void {
+    if (onFail || onSucc) {
+      if (__DEV__) {
+        this._debugInfo[this._callID] = [moduleID, methodID];
+        if (this._callID > DEBUG_INFO_LIMIT) {
+          delete this._debugInfo[this._callID - DEBUG_INFO_LIMIT];
+        }
+        if (this._successCallbacks.size > 500) {
+          const info: {[number]: {method: string, module: string}} = {};
+          this._successCallbacks.forEach((_, callID) => {
+            const debug = this._debugInfo[callID];
+            const module = debug && this._remoteModuleTable[debug[0]];
+            const method = debug && this._remoteMethodTable[debug[0]][debug[1]];
+            info[callID] = {module, method};
+          });
+          warnOnce(
+            'excessive-number-of-pending-callbacks',
+            `Excessive number of pending callbacks: ${
+              this._successCallbacks.size
+            }. Some pending callbacks that might have leaked by never being called from native code: ${stringifySafe(
+              info,
+            )}`,
+          );
+        }
+      }
+      // Encode callIDs into pairs of callback identifiers by shifting left and using the rightmost bit
+      // to indicate fail (0) or success (1)
+      // eslint-disable-next-line no-bitwise
+      onFail && params.push(this._callID << 1);
+      // eslint-disable-next-line no-bitwise
+      onSucc && params.push((this._callID << 1) | 1);
+      this._successCallbacks.set(this._callID, onSucc);
+      this._failureCallbacks.set(this._callID, onFail);
+    }
+    if (__DEV__) {
+      global.nativeTraceBeginAsyncFlow &&
+        global.nativeTraceBeginAsyncFlow(
+          TRACE_TAG_REACT,
+          'native',
+          this._callID,
+        );
+    }
+    this._callID++;
+  }
+
+  enqueueNativeCall(
+    moduleID: number,
+    methodID: number,
+    params: mixed[],
+    onFail: ?(...mixed[]) => void,
+    onSucc: ?(...mixed[]) => void,
+  ): void {
+    this.processCallbacks(moduleID, methodID, params, onFail, onSucc);
+
+    this._queue[MODULE_IDS].push(moduleID);
+    this._queue[METHOD_IDS].push(methodID);
+
+    if (__DEV__) {
+      // Validate that parameters passed over the bridge are
+      // 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): boolean => {
+        switch (typeof val) {
+          case 'undefined':
+          case 'boolean':
+          case 'string':
+            return true;
+          case 'number':
+            return isFinite(val);
+          case 'object':
+            if (val == null) {
+              return true;
+            }
+
+            if (Array.isArray(val)) {
+              return val.every(isValidArgument);
+            }
+
+            for (const k in val) {
+              if (typeof val[k] !== 'function' && !isValidArgument(val[k])) {
+                return false;
+              }
+            }
+
+            return true;
+          case 'function':
+            return false;
+          default:
+            return false;
+        }
+      };
+
+      // 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: string, val: $FlowFixMe) => {
+        const t = typeof val;
+        if (t === 'function') {
+          return '<<Function ' + val.name + '>>';
+        } else if (t === 'number' && !isFinite(val)) {
+          return '<<' + val.toString() + '>>';
+        } else {
+          return val;
+        }
+      };
+
+      // Note that JSON.stringify
+      invariant(
+        isValidArgument(params),
+        '%s is not usable as a native method argument',
+        JSON.stringify(params, replacer),
+      );
+
+      // The params object should not be mutated after being queued
+      deepFreezeAndThrowOnMutationInDev(params);
+    }
+    this._queue[PARAMS].push(params);
+
+    const now = Date.now();
+    if (
+      global.nativeFlushQueueImmediate &&
+      now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS
+    ) {
+      const queue = this._queue;
+      this._queue = [[], [], [], this._callID];
+      this._lastFlush = now;
+      global.nativeFlushQueueImmediate(queue);
+    }
+    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],
+        method: this._remoteMethodTable[moduleID][methodID],
+        args: params,
+      });
+    } else if (this.__spy) {
+      this.__spy({
+        type: TO_NATIVE,
+        module: moduleID + '',
+        method: methodID,
+        args: params,
+      });
+    }
+  }
+
+  createDebugLookup(
+    moduleID: number,
+    name: string,
+    methods: ?$ReadOnlyArray<string>,
+  ) {
+    if (__DEV__) {
+      this._remoteModuleTable[moduleID] = name;
+      this._remoteMethodTable[moduleID] = methods || [];
+    }
+  }
+
+  // For JSTimers to register its callback. Otherwise a circular dependency
+  // between modules is introduced. Note that only one callback may be
+  // registered at a time.
+  setReactNativeMicrotasksCallback(fn: () => void) {
+    this._reactNativeMicrotasksCallback = fn;
+  }
+
+  /**
+   * Private methods
+   */
+
+  __guard(fn: () => void) {
+    if (this.__shouldPauseOnThrow()) {
+      fn();
+    } else {
+      try {
+        fn();
+      } catch (error) {
+        ErrorUtils.reportFatalError(error);
+      }
+    }
+  }
+
+  // MessageQueue installs a global handler to catch all exceptions where JS users can register their own behavior
+  // This handler makes all exceptions to be propagated from inside MessageQueue rather than by the VM at their origin
+  // This makes stacktraces to be placed at MessageQueue rather than at where they were launched
+  // The parameter DebuggerInternal.shouldPauseOnThrow is used to check before catching all exceptions and
+  // can be configured by the VM or any Inspector
+  __shouldPauseOnThrow(): boolean {
+    return (
+      // $FlowFixMe[cannot-resolve-name]
+      typeof DebuggerInternal !== 'undefined' &&
+      // $FlowFixMe[cannot-resolve-name]
+      DebuggerInternal.shouldPauseOnThrow === true
+    );
+  }
+
+  __callReactNativeMicrotasks() {
+    Systrace.beginEvent('JSTimers.callReactNativeMicrotasks()');
+    try {
+      if (this._reactNativeMicrotasksCallback != null) {
+        this._reactNativeMicrotasksCallback();
+      }
+    } finally {
+      Systrace.endEvent();
+    }
+  }
+
+  __callFunction(module: string, method: string, args: mixed[]): void {
+    this._lastFlush = Date.now();
+    this._eventLoopStartTime = this._lastFlush;
+    if (__DEV__ || this.__spy) {
+      Systrace.beginEvent(`${module}.${method}(${stringifySafe(args)})`);
+    } else {
+      Systrace.beginEvent(`${module}.${method}(...)`);
+    }
+    try {
+      if (this.__spy) {
+        this.__spy({type: TO_JS, module, method, args});
+      }
+      const moduleMethods = this.getCallableModule(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.`,
+        );
+      }
+      // $FlowFixMe[invalid-computed-prop]
+      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);
+    } finally {
+      Systrace.endEvent();
+    }
+  }
+
+  __invokeCallback(cbID: number, args: mixed[]): void {
+    this._lastFlush = Date.now();
+    this._eventLoopStartTime = this._lastFlush;
+
+    // The rightmost bit of cbID indicates fail (0) or success (1), the other bits are the callID shifted left.
+    // eslint-disable-next-line no-bitwise
+    const callID = cbID >>> 1;
+    // eslint-disable-next-line no-bitwise
+    const isSuccess = cbID & 1;
+    const callback = isSuccess
+      ? this._successCallbacks.get(callID)
+      : this._failureCallbacks.get(callID);
+
+    if (__DEV__) {
+      const debug = this._debugInfo[callID];
+      const module = debug && this._remoteModuleTable[debug[0]];
+      const method = debug && this._remoteMethodTable[debug[0]][debug[1]];
+      invariant(
+        callback,
+        `No callback found with cbID ${cbID} and callID ${callID} for ` +
+          (method
+            ? ` ${module}.${method} - most likely the callback was already invoked`
+            : `module ${module || '<unknown>'}`) +
+          `. Args: '${stringifySafe(args)}'`,
+      );
+      const profileName = debug
+        ? '<callback for ' + module + '.' + method + '>'
+        : cbID;
+      /* $FlowFixMe[constant-condition] Error discovered during Constant
+       * Condition roll out. See https://fburl.com/workplace/1v97vimq. */
+      if (callback && this.__spy) {
+        this.__spy({type: TO_JS, module: null, method: profileName, args});
+      }
+      Systrace.beginEvent(
+        `MessageQueue.invokeCallback(${profileName}, ${stringifySafe(args)})`,
+      );
+    }
+
+    try {
+      if (!callback) {
+        return;
+      }
+
+      this._successCallbacks.delete(callID);
+      this._failureCallbacks.delete(callID);
+      callback(...args);
+    } finally {
+      if (__DEV__) {
+        Systrace.endEvent();
+      }
+    }
+  }
+}
+
+export default MessageQueue;

node_modules/react-native/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 information.
+ * 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;

node_modules/react-native/Libraries/BatchedBridge/NativeModules.js

@@ -0,0 +1,216 @@
+/**
+ * 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
+ */
+
+'use strict';
+
+import type {ExtendedError} from '../Core/ExtendedError';
+
+const BatchedBridge = require('./BatchedBridge').default;
+const invariant = require('invariant');
+
+export type ModuleConfig = [
+  string /* name */,
+  ?{...} /* constants */,
+  ?$ReadOnlyArray<string> /* functions */,
+  ?$ReadOnlyArray<number> /* promise method IDs */,
+  ?$ReadOnlyArray<number> /* sync method IDs */,
+];
+
+export type MethodType = 'async' | 'promise' | 'sync';
+
+function genModule(
+  config: ?ModuleConfig,
+  moduleID: number,
+): ?{
+  name: string,
+  module?: {...},
+  ...
+} {
+  if (!config) {
+    return null;
+  }
+
+  const [moduleName, constants, methods, promiseMethods, syncMethods] = config;
+  invariant(
+    !moduleName.startsWith('RCT') && !moduleName.startsWith('RK'),
+    "Module name prefixes should've been stripped by the native side " +
+      "but wasn't for " +
+      moduleName,
+  );
+
+  if (!constants && !methods) {
+    // Module contents will be filled in lazily later
+    return {name: moduleName};
+  }
+
+  const module: {[string]: mixed} = {};
+  methods &&
+    methods.forEach((methodName, methodID) => {
+      const isPromise =
+        (promiseMethods && arrayContains(promiseMethods, methodID)) || false;
+      const isSync =
+        (syncMethods && arrayContains(syncMethods, methodID)) || false;
+      invariant(
+        !isPromise || !isSync,
+        'Cannot have a method that is both async and a sync hook',
+      );
+      const methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
+      module[methodName] = genMethod(moduleID, methodID, methodType);
+    });
+
+  // $FlowFixMe[unsafe-object-assign]
+  Object.assign(module, constants);
+
+  if (module.getConstants == null) {
+    module.getConstants = () => constants || Object.freeze({});
+  } else {
+    console.warn(
+      `Unable to define method 'getConstants()' on NativeModule '${moduleName}'. NativeModule '${moduleName}' already has a constant or method called 'getConstants'. Please remove it.`,
+    );
+  }
+
+  if (__DEV__) {
+    BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
+  }
+
+  return {name: moduleName, module};
+}
+
+// export this method as a global so we can call it from native
+global.__fbGenNativeModule = genModule;
+
+function loadModule(name: string, moduleID: number): ?{...} {
+  invariant(
+    global.nativeRequireModuleConfig,
+    "Can't lazily create module without nativeRequireModuleConfig",
+  );
+  const config = global.nativeRequireModuleConfig(name);
+  const info = genModule(config, moduleID);
+  return info && info.module;
+}
+
+function genMethod(moduleID: number, methodID: number, type: MethodType) {
+  let fn = null;
+  if (type === 'promise') {
+    fn = function promiseMethodWrapper(...args: Array<mixed>) {
+      // In case we reject, capture a useful stack trace here.
+      /* $FlowFixMe[class-object-subtyping] added when improving typing for
+       * this parameters */
+      // $FlowFixMe[incompatible-type]
+      const enqueueingFrameError: ExtendedError = new Error();
+      return new Promise((resolve, reject) => {
+        BatchedBridge.enqueueNativeCall(
+          moduleID,
+          methodID,
+          args,
+          data => resolve(data),
+          errorData =>
+            reject(
+              updateErrorWithErrorData(
+                (errorData: $FlowFixMe),
+                enqueueingFrameError,
+              ),
+            ),
+        );
+      });
+    };
+  } else {
+    fn = function nonPromiseMethodWrapper(...args: Array<mixed>) {
+      const lastArg = args.length > 0 ? args[args.length - 1] : null;
+      const secondLastArg = args.length > 1 ? args[args.length - 2] : null;
+      const hasSuccessCallback = typeof lastArg === 'function';
+      const hasErrorCallback = typeof secondLastArg === 'function';
+      hasErrorCallback &&
+        invariant(
+          hasSuccessCallback,
+          'Cannot have a non-function arg after a function arg.',
+        );
+      // $FlowFixMe[incompatible-type]
+      const onSuccess: ?(mixed) => void = hasSuccessCallback ? lastArg : null;
+      // $FlowFixMe[incompatible-type]
+      const onFail: ?(mixed) => void = hasErrorCallback ? secondLastArg : null;
+      // $FlowFixMe[unsafe-addition]
+      const callbackCount = hasSuccessCallback + hasErrorCallback;
+      const newArgs = args.slice(0, args.length - callbackCount);
+      if (type === 'sync') {
+        return BatchedBridge.callNativeSyncHook(
+          moduleID,
+          methodID,
+          newArgs,
+          onFail,
+          onSuccess,
+        );
+      } else {
+        BatchedBridge.enqueueNativeCall(
+          moduleID,
+          methodID,
+          newArgs,
+          onFail,
+          onSuccess,
+        );
+      }
+    };
+  }
+  // $FlowFixMe[prop-missing]
+  fn.type = type;
+  return fn;
+}
+
+function arrayContains<T>(array: $ReadOnlyArray<T>, value: T): boolean {
+  return array.indexOf(value) !== -1;
+}
+
+function updateErrorWithErrorData(
+  errorData: {message: string, ...},
+  error: ExtendedError,
+): ExtendedError {
+  /* $FlowFixMe[class-object-subtyping] added when improving typing for this
+   * parameters */
+  // $FlowFixMe[incompatible-type]
+  // $FlowFixMe[unsafe-object-assign]
+  return Object.assign(error, errorData || {});
+}
+
+/* $FlowFixMe[unclear-type] unclear type of NativeModules */
+let NativeModules: {[moduleName: string]: any, ...} = {};
+if (global.nativeModuleProxy) {
+  NativeModules = global.nativeModuleProxy;
+} else {
+  const bridgeConfig = global.__fbBatchedBridgeConfig;
+  invariant(
+    bridgeConfig,
+    '__fbBatchedBridgeConfig is not set, cannot invoke native modules',
+  );
+
+  const defineLazyObjectProperty =
+    require('../Utilities/defineLazyObjectProperty').default;
+  (bridgeConfig.remoteModuleConfig || []).forEach(
+    (config: ModuleConfig, moduleID: number) => {
+      // Initially this config will only contain the module name when running in JSC. The actual
+      // configuration of the module will be lazily loaded.
+      const info = genModule(config, moduleID);
+      if (!info) {
+        return;
+      }
+
+      if (info.module) {
+        NativeModules[info.name] = info.module;
+      }
+      // If there's no module config, define a lazy getter
+      else {
+        defineLazyObjectProperty(NativeModules, info.name, {
+          get: () => loadModule(info.name, moduleID),
+        });
+      }
+    },
+  );
+}
+
+export default NativeModules;