initial commit taken from gitlab.lrz.de

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

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule BatchedBridge
+ * @flow
+ */
+'use strict';
+
+const MessageQueue = require('MessageQueue');
+
+// MessageQueue can install a global handler to catch all exceptions where JS users can register their own behavior
+// This handler makes all exceptions to be handled inside MessageQueue rather than by the VM at its origin
+// This makes stacktraces to be placed at MessageQueue rather than at where they were launched
+// The parameter __fbUninstallRNGlobalErrorHandler is passed to MessageQueue to prevent the handler from being installed
+//
+// __fbUninstallRNGlobalErrorHandler is conditionally set by the Inspector while the VM is paused for initialization
+// If the Inspector isn't present it defaults to undefined and the global error handler is installed
+// The Inspector can still call MessageQueue#uninstallGlobalErrorHandler to uninstalled on attach
+
+const BatchedBridge = new MessageQueue(
+  // $FlowFixMe
+  typeof __fbUninstallRNGlobalErrorHandler !== 'undefined' &&
+    __fbUninstallRNGlobalErrorHandler === true, // eslint-disable-line no-undef
+);
+
+// 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,406 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule MessageQueue
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const ErrorUtils = require('ErrorUtils');
+const Systrace = require('Systrace');
+
+const deepFreezeAndThrowOnMutationInDev = require('deepFreezeAndThrowOnMutationInDev');
+const invariant = require('fbjs/lib/invariant');
+const stringifySafe = require('stringifySafe');
+
+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;
+
+// Work around an initialization order issue
+let JSTimers = null;
+
+class MessageQueue {
+  _lazyCallableModules: {[key: string]: (void) => Object};
+  _queue: [number[], number[], any[], number];
+  _successCallbacks: (?Function)[];
+  _failureCallbacks: (?Function)[];
+  _callID: number;
+  _inCall: number;
+  _lastFlush: number;
+  _eventLoopStartTime: number;
+
+  _debugInfo: {[number]: [number, number]};
+  _remoteModuleTable: {[number]: string};
+  _remoteMethodTable: {[number]: string[]};
+
+  __spy: ?(data: SpyData) => void;
+
+  __guard: (() => void) => void;
+
+  constructor(shouldUninstallGlobalErrorHandler: boolean = false) {
+    this._lazyCallableModules = {};
+    this._queue = [[], [], [], 0];
+    this._successCallbacks = [];
+    this._failureCallbacks = [];
+    this._callID = 0;
+    this._lastFlush = 0;
+    this._eventLoopStartTime = new Date().getTime();
+    if (shouldUninstallGlobalErrorHandler) {
+      this.uninstallGlobalErrorHandler();
+    } else {
+      this.installGlobalErrorHandler();
+    }
+
+    if (__DEV__) {
+      this._debugInfo = {};
+      this._remoteModuleTable = {};
+      this._remoteMethodTable = {};
+    }
+
+    (this: any).callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(
+      this,
+    );
+    (this: any).callFunctionReturnResultAndFlushedQueue = this.callFunctionReturnResultAndFlushedQueue.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[]) {
+    this.__guard(() => {
+      this.__callFunction(module, method, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  callFunctionReturnResultAndFlushedQueue(
+    module: string,
+    method: string,
+    args: any[],
+  ) {
+    let result;
+    this.__guard(() => {
+      result = this.__callFunction(module, method, args);
+    });
+
+    return [result, this.flushedQueue()];
+  }
+
+  invokeCallbackAndReturnFlushedQueue(cbID: number, args: any[]) {
+    this.__guard(() => {
+      this.__invokeCallback(cbID, args);
+    });
+
+    return this.flushedQueue();
+  }
+
+  flushedQueue() {
+    this.__guard(() => {
+      this.__callImmediates();
+    });
+
+    const queue = this._queue;
+    this._queue = [[], [], [], this._callID];
+    return queue[0].length ? queue : null;
+  }
+
+  getEventLoopRunningTime() {
+    return new Date().getTime() - 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) {
+    const getValue = this._lazyCallableModules[name];
+    return getValue ? getValue() : null;
+  }
+
+  enqueueNativeCall(
+    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];
+        }
+      }
+      // 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[this._callID] = onSucc;
+      this._failureCallbacks[this._callID] = onFail;
+    }
+
+    if (__DEV__) {
+      global.nativeTraceBeginAsyncFlow &&
+        global.nativeTraceBeginAsyncFlow(
+          TRACE_TAG_REACT_APPS,
+          'native',
+          this._callID,
+        );
+    }
+    this._callID++;
+
+    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 === 'number' ||
+          t === 'string'
+        ) {
+          return true;
+        }
+        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;
+      };
+
+      invariant(
+        isValidArgument(params),
+        '%s is not usable as a native method argument',
+        params,
+      );
+
+      // The params object should not be mutated after being queued
+      deepFreezeAndThrowOnMutationInDev((params: any));
+    }
+    this._queue[PARAMS].push(params);
+
+    const now = new Date().getTime();
+    if (
+      global.nativeFlushQueueImmediate &&
+      (now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS ||
+        this._inCall === 0)
+    ) {
+      var 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: string[]) {
+    if (__DEV__) {
+      this._remoteModuleTable[moduleID] = name;
+      this._remoteMethodTable[moduleID] = methods;
+    }
+  }
+
+  uninstallGlobalErrorHandler() {
+    this.__guard = this.__guardUnsafe;
+  }
+
+  installGlobalErrorHandler() {
+    this.__guard = this.__guardSafe;
+  }
+
+  /**
+   * Private methods
+   */
+
+  // Lets exceptions propagate to be handled by the VM at the origin
+  __guardUnsafe(fn: () => void) {
+    this._inCall++;
+    fn();
+    this._inCall--;
+  }
+
+  __guardSafe(fn: () => void) {
+    this._inCall++;
+    try {
+      fn();
+    } catch (error) {
+      ErrorUtils.reportFatalError(error);
+    } finally {
+      this._inCall--;
+    }
+  }
+
+  __callImmediates() {
+    Systrace.beginEvent('JSTimers.callImmediates()');
+    if (!JSTimers) {
+      JSTimers = require('JSTimers');
+    }
+    JSTimers.callImmediates();
+    Systrace.endEvent();
+  }
+
+  __callFunction(module: string, method: string, args: any[]): any {
+    this._lastFlush = new Date().getTime();
+    this._eventLoopStartTime = this._lastFlush;
+    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,
+    );
+    const result = moduleMethods[method].apply(moduleMethods, args);
+    Systrace.endEvent();
+    return result;
+  }
+
+  __invokeCallback(cbID: number, args: any[]) {
+    this._lastFlush = new Date().getTime();
+    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[callID]
+      : this._failureCallbacks[callID];
+
+    if (__DEV__) {
+      const debug = this._debugInfo[callID];
+      const module = debug && this._remoteModuleTable[debug[0]];
+      const method = debug && this._remoteMethodTable[debug[0]][debug[1]];
+      if (!callback) {
+        let errorMessage = `Callback with id ${cbID}: ${module}.${method}() not found`;
+        if (method) {
+          errorMessage =
+            `The callback ${method}() exists in module ${module}, ` +
+            'but only one callback may be registered to a function in a native module.';
+        }
+        invariant(callback, errorMessage);
+      }
+      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[callID] = this._failureCallbacks[callID] = null;
+    callback(...args);
+
+    if (__DEV__) {
+      Systrace.endEvent();
+    }
+  }
+}
+
+module.exports = MessageQueue;

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

@@ -0,0 +1,154 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule NativeModules
+ * @flow
+ */
+'use strict';
+
+const BatchedBridge = require('BatchedBridge');
+
+const invariant = require('fbjs/lib/invariant');
+
+import type {ExtendedError} from 'parseErrorStack';
+
+type ModuleConfig = [
+  string, /* name */
+  ?Object, /* constants */
+  Array<string>, /* functions */
+  Array<number>, /* promise method IDs */
+  Array<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 (__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(...args: Array<any>) {
+      return new Promise((resolve, reject) => {
+        BatchedBridge.enqueueNativeCall(moduleID, methodID, args,
+          (data) => resolve(data),
+          (errorData) => reject(createErrorFromErrorData(errorData)));
+      });
+    };
+  } else if (type === 'sync') {
+    fn = function(...args: Array<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.');
+      }
+      return global.nativeCallSyncHook(moduleID, methodID, args);
+    };
+  } else {
+    fn = function(...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);
+      BatchedBridge.enqueueNativeCall(moduleID, methodID, args, onFail, onSuccess);
+    };
+  }
+  fn.type = type;
+  return fn;
+}
+
+function arrayContains<T>(array: Array<T>, value: T): boolean {
+  return array.indexOf(value) !== -1;
+}
+
+function createErrorFromErrorData(errorData: {message: string}): ExtendedError {
+  const {
+    message,
+    ...extraErrorInfo
+  } = errorData || {};
+  const error : ExtendedError = new Error(message);
+  error.framesToPop = 1;
+  return Object.assign(error, extraErrorInfo);
+}
+
+let NativeModules : {[moduleName: string]: Object} = {};
+if (global.nativeModuleProxy) {
+  NativeModules = global.nativeModuleProxy;
+} else {
+  const bridgeConfig = global.__fbBatchedBridgeConfig;
+  invariant(bridgeConfig, '__fbBatchedBridgeConfig is not set, cannot invoke native modules');
+
+  const defineLazyObjectProperty = require('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,19 @@
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * These don't actually exist anywhere in the code.
+ */
+'use strict';
+var remoteModulesConfig = [
+  ['RemoteModule1',null,['remoteMethod','promiseMethod'],[]],
+  ['RemoteModule2',null,['remoteMethod','promiseMethod'],[]],
+];
+
+var MessageQueueTestConfig = {
+  remoteModuleConfig: remoteModulesConfig,
+};
+
+module.exports = MessageQueueTestConfig;

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

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