yeet

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

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const MessageQueue = require('./MessageQueue');
+
+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,
+});
+
+module.exports = BatchedBridge;

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

@@ -0,0 +1,470 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'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');
+
+export type SpyData = {
+  type: number,
+  module: ?string,
+  method: string | number,
+  args: any[],
+  ...
+};
+
+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_APPS = 1 << 17;
+
+const DEBUG_INFO_LIMIT = 32;
+
+class MessageQueue {
+  _lazyCallableModules: {[key: string]: (void) => Object, ...};
+  _queue: [number[], number[], any[], number];
+  _successCallbacks: Map<number, ?Function>;
+  _failureCallbacks: Map<number, ?Function>;
+  _callID: number;
+  _lastFlush: number;
+  _eventLoopStartTime: number;
+  _immediatesCallback: ?() => 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._immediatesCallback = null;
+
+    if (__DEV__) {
+      this._debugInfo = {};
+      this._remoteModuleTable = {};
+      this._remoteMethodTable = {};
+    }
+
+    (this: any).callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(
+      this,
+    );
+    (this: any).flushedQueue = this.flushedQueue.bind(this);
+    (this: any).invokeCallbackAndReturnFlushedQueue = 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 ? 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: any[],
+  ): null | [Array<number>, Array<number>, Array<any>, number] {
+    this.__guard(() => {
+      this.__callFunction(module, method, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  // Deprecated. T61834641: Remove me once native clients have updated
+  callFunctionReturnResultAndFlushedQueue(
+    module: string,
+    method: string,
+    args: any[],
+  ): void {}
+
+  invokeCallbackAndReturnFlushedQueue(
+    cbID: number,
+    args: any[],
+  ): null | [Array<number>, Array<number>, Array<any>, number] {
+    this.__guard(() => {
+      this.__invokeCallback(cbID, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  flushedQueue(): null | [Array<number>, Array<number>, Array<any>, number] {
+    this.__guard(() => {
+      this.__callImmediates();
+    });
+
+    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: Object) {
+    this._lazyCallableModules[name] = () => module;
+  }
+
+  registerLazyCallableModule(name: string, factory: void => Object) {
+    let module: Object;
+    let getValue: ?(void) => Object = factory;
+    this._lazyCallableModules[name] = () => {
+      if (getValue) {
+        module = getValue();
+        getValue = null;
+      }
+      return module;
+    };
+  }
+
+  getCallableModule(name: string): any | null {
+    const getValue = this._lazyCallableModules[name];
+    return getValue ? getValue() : null;
+  }
+
+  callNativeSyncHook(
+    moduleID: number,
+    methodID: number,
+    params: any[],
+    onFail: ?Function,
+    onSucc: ?Function,
+  ): any {
+    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: any[],
+    onFail: ?Function,
+    onSucc: ?Function,
+  ) {
+    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 = {};
+          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',
+            `Please report: 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_APPS,
+          'native',
+          this._callID,
+        );
+    }
+    this._callID++;
+  }
+
+  enqueueNativeCall(
+    moduleID: number,
+    methodID: number,
+    params: any[],
+    onFail: ?Function,
+    onSucc: ?Function,
+  ) {
+    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 => {
+        const t = typeof val;
+        if (
+          t === 'undefined' ||
+          t === 'null' ||
+          t === 'boolean' ||
+          t === 'string'
+        ) {
+          return true;
+        }
+        if (t === 'number') {
+          return isFinite(val);
+        }
+        if (t === 'function' || t !== 'object') {
+          return false;
+        }
+        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;
+      };
+
+      // 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 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: any));
+    }
+    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)) {
+      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.
+  setImmediatesCallback(fn: () => void) {
+    this._immediatesCallback = 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
+      typeof DebuggerInternal !== 'undefined' &&
+      DebuggerInternal.shouldPauseOnThrow === true // eslint-disable-line no-undef
+    );
+  }
+
+  __callImmediates() {
+    Systrace.beginEvent('JSTimers.callImmediates()');
+    if (this._immediatesCallback != null) {
+      this._immediatesCallback();
+    }
+    Systrace.endEvent();
+  }
+
+  __callFunction(module: string, method: string, args: any[]): void {
+    this._lastFlush = Date.now();
+    this._eventLoopStartTime = this._lastFlush;
+    if (__DEV__ || this.__spy) {
+      Systrace.beginEvent(`${module}.${method}(${stringifySafe(args)})`);
+    } else {
+      Systrace.beginEvent(`${module}.${method}(...)`);
+    }
+    if (this.__spy) {
+      this.__spy({type: TO_JS, module, method, args});
+    }
+    const moduleMethods = this.getCallableModule(module);
+    invariant(
+      !!moduleMethods,
+      'Module %s is not a registered callable module (calling %s)',
+      module,
+      method,
+    );
+    invariant(
+      !!moduleMethods[method],
+      'Method %s does not exist on module %s',
+      method,
+      module,
+    );
+    moduleMethods[method].apply(moduleMethods, args);
+    Systrace.endEvent();
+  }
+
+  __invokeCallback(cbID: number, args: any[]) {
+    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;
+      if (callback && this.__spy) {
+        this.__spy({type: TO_JS, module: null, method: profileName, args});
+      }
+      Systrace.beginEvent(
+        `MessageQueue.invokeCallback(${profileName}, ${stringifySafe(args)})`,
+      );
+    }
+
+    if (!callback) {
+      return;
+    }
+
+    this._successCallbacks.delete(callID);
+    this._failureCallbacks.delete(callID);
+    callback(...args);
+
+    if (__DEV__) {
+      Systrace.endEvent();
+    }
+  }
+}
+
+module.exports = MessageQueue;

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

@@ -0,0 +1,197 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const BatchedBridge = require('./BatchedBridge');
+
+const invariant = require('invariant');
+
+import type {ExtendedError} from '../Core/Devtools/parseErrorStack';
+
+export type ModuleConfig = [
+  string /* name */,
+  ?Object /* 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?: Object,
+  ...
+} {
+  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 = {};
+  methods &&
+    methods.forEach((methodName, methodID) => {
+      const isPromise =
+        promiseMethods && arrayContains(promiseMethods, methodID);
+      const isSync = syncMethods && arrayContains(syncMethods, methodID);
+      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);
+    });
+
+  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): ?Object {
+  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<any>) {
+      // In case we reject, capture a useful stack trace here.
+      const enqueueingFrameError: ExtendedError = new Error();
+      return new Promise((resolve, reject) => {
+        BatchedBridge.enqueueNativeCall(
+          moduleID,
+          methodID,
+          args,
+          data => resolve(data),
+          errorData =>
+            reject(updateErrorWithErrorData(errorData, enqueueingFrameError)),
+        );
+      });
+    };
+  } else {
+    fn = function nonPromiseMethodWrapper(...args: Array<any>) {
+      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.',
+        );
+      const onSuccess = hasSuccessCallback ? lastArg : null;
+      const onFail = hasErrorCallback ? secondLastArg : null;
+      const callbackCount = hasSuccessCallback + hasErrorCallback;
+      args = args.slice(0, args.length - callbackCount);
+      if (type === 'sync') {
+        return BatchedBridge.callNativeSyncHook(
+          moduleID,
+          methodID,
+          args,
+          onFail,
+          onSuccess,
+        );
+      } else {
+        BatchedBridge.enqueueNativeCall(
+          moduleID,
+          methodID,
+          args,
+          onFail,
+          onSuccess,
+        );
+      }
+    };
+  }
+  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 {
+  return Object.assign(error, errorData || {});
+}
+
+let NativeModules: {[moduleName: string]: Object, ...} = {};
+if (global.nativeModuleProxy) {
+  NativeModules = global.nativeModuleProxy;
+} else if (!global.nativeExtensions) {
+  const bridgeConfig = global.__fbBatchedBridgeConfig;
+  invariant(
+    bridgeConfig,
+    '__fbBatchedBridgeConfig is not set, cannot invoke native modules',
+  );
+
+  const defineLazyObjectProperty = require('../Utilities/defineLazyObjectProperty');
+  (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),
+        });
+      }
+    },
+  );
+}
+
+module.exports = NativeModules;

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

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// These don't actually exist anywhere in the code.
+
+'use strict';
+
+import type {ModuleConfig} from '../NativeModules';
+
+const remoteModulesConfig: $ReadOnlyArray<ModuleConfig> = [
+  [
+    'RemoteModule1',
+    null,
+    ['remoteMethod', 'promiseMethod', 'promiseReturningMethod', 'syncMethod'],
+    [2 /* promiseReturningMethod */],
+    [3 /* syncMethod */],
+  ],
+  [
+    'RemoteModule2',
+    null,
+    ['remoteMethod', 'promiseMethod', 'promiseReturningMethod', 'syncMethod'],
+    [2 /* promiseReturningMethod */],
+    [3 /* syncMethod */],
+  ],
+];
+
+const MessageQueueTestConfig = {
+  remoteModuleConfig: remoteModulesConfig,
+};
+
+module.exports = MessageQueueTestConfig;

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

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+/**
+ * Dummy module that only exists for the sake of proving that the message queue
+ * correctly dispatches to commonJS modules. The `testHook` is overridden by test
+ * cases.
+ */
+const MessageQueueTestModule = {
+  testHook1: function() {},
+  testHook2: function() {},
+};
+
+module.exports = MessageQueueTestModule;