initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/Core/Devtools/getDevServer.js

@@ -0,0 +1,38 @@
+/**
+ * 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 getDevServer
+ * @flow
+ */
+'use strict';
+
+const {SourceCode} = require('NativeModules');
+
+let _cachedDevServerURL: ?string;
+const FALLBACK = 'http://localhost:8081/';
+
+type DevServerInfo = {
+  url: string,
+  bundleLoadedFromServer: boolean,
+};
+
+/**
+ * Many RN development tools rely on the development server (packager) running
+ * @return URL to packager with trailing slash
+ */
+function getDevServer(): DevServerInfo {
+  if (_cachedDevServerURL === undefined) {
+    const match = SourceCode && SourceCode.scriptURL && SourceCode.scriptURL.match(/^https?:\/\/.*?\//);
+    _cachedDevServerURL = match ? match[0] : null;
+  }
+
+  return {
+    url: _cachedDevServerURL || FALLBACK,
+    bundleLoadedFromServer: _cachedDevServerURL !== null,
+  };
+}
+
+module.exports = getDevServer;

node_modules/react-native/Libraries/Core/Devtools/openFileInEditor.js

@@ -0,0 +1,21 @@
+/**
+ * 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 openFileInEditor
+ * @flow
+ */
+'use strict';
+
+const getDevServer = require('getDevServer');
+
+function openFileInEditor(file: string, lineNumber: number) {
+  fetch(getDevServer().url + 'open-stack-frame', {
+    method: 'POST',
+    body: JSON.stringify({file, lineNumber}),
+  });
+}
+
+module.exports = openFileInEditor;

node_modules/react-native/Libraries/Core/Devtools/parseErrorStack.js

@@ -0,0 +1,41 @@
+/**
+ * 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 parseErrorStack
+ * @flow
+ */
+'use strict';
+
+export type StackFrame = {
+  column: ?number,
+  file: string,
+  lineNumber: number,
+  methodName: string,
+};
+
+export type ExtendedError = Error & {
+  framesToPop?: number,
+};
+
+function parseErrorStack(e: ExtendedError): Array<StackFrame> {
+  if (!e || !e.stack) {
+    return [];
+  }
+
+  /* $FlowFixMe(>=0.54.0 site=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. */
+  const stacktraceParser = require('stacktrace-parser');
+  const stack = Array.isArray(e.stack) ? e.stack : stacktraceParser.parse(e.stack);
+
+  let framesToPop = typeof e.framesToPop === 'number' ? e.framesToPop : 0;
+  while (framesToPop--) {
+    stack.shift();
+  }
+  return stack;
+}
+
+module.exports = parseErrorStack;

node_modules/react-native/Libraries/Core/Devtools/setupDevtools.js

@@ -0,0 +1,62 @@
+/**
+ * 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 setupDevtools
+ * @flow
+ */
+'use strict';
+
+type DevToolsPluginConnection = {
+  isAppActive: () => boolean,
+  host: string,
+  port: number,
+};
+
+type DevToolsPlugin = {
+  connectToDevTools: (connection: DevToolsPluginConnection) => void,
+};
+
+let register = function () {
+  // noop
+};
+
+if (__DEV__) {
+  const AppState = require('AppState');
+  const WebSocket = require('WebSocket');
+  /* $FlowFixMe(>=0.54.0 site=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. */
+  const reactDevTools = require('react-devtools-core');
+  const getDevServer = require('getDevServer');
+
+  // Initialize dev tools only if the native module for WebSocket is available
+  if (WebSocket.isAvailable) {
+    // Don't steal the DevTools from currently active app.
+    // Note: if you add any AppState subscriptions to this file,
+    // you will also need to guard against `AppState.isAvailable`,
+    // or the code will throw for bundles that don't have it.
+    const isAppActive = () => AppState.currentState !== 'background';
+
+    // Get hostname from development server (packager)
+    const devServer = getDevServer();
+    const host = devServer.bundleLoadedFromServer
+      ? devServer.url.replace(/https?:\/\//, '').split(':')[0]
+      : 'localhost';
+
+    reactDevTools.connectToDevTools({
+      isAppActive,
+      host,
+      // Read the optional global variable for backward compatibility.
+      // It was added in https://github.com/facebook/react-native/commit/bf2b435322e89d0aeee8792b1c6e04656c2719a0.
+      port: window.__REACT_DEVTOOLS_PORT__,
+      resolveRNStyle: require('flattenStyle'),
+    });
+  }
+}
+
+module.exports = {
+  register,
+};

node_modules/react-native/Libraries/Core/Devtools/symbolicateStackTrace.js

@@ -0,0 +1,73 @@
+/**
+ * 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 symbolicateStackTrace
+ * @flow
+ */
+'use strict';
+
+const getDevServer = require('getDevServer');
+
+const {SourceCode} = require('NativeModules');
+
+// Avoid requiring fetch on load of this module; see symbolicateStackTrace
+let fetch;
+
+import type {StackFrame} from 'parseErrorStack';
+
+function isSourcedFromDisk(sourcePath: string): boolean {
+  return !/^http/.test(sourcePath) && /[\\/]/.test(sourcePath);
+}
+
+async function symbolicateStackTrace(stack: Array<StackFrame>): Promise<Array<StackFrame>> {
+  // RN currently lazy loads whatwg-fetch using a custom fetch module, which,
+  // when called for the first time, requires and re-exports 'whatwg-fetch'.
+  // However, when a dependency of the project tries to require whatwg-fetch
+  // either directly or indirectly, whatwg-fetch is required before
+  // RN can lazy load whatwg-fetch. As whatwg-fetch checks
+  // for a fetch polyfill before loading, it will in turn try to load
+  // RN's fetch module, which immediately tries to import whatwg-fetch AGAIN.
+  // This causes a circular require which results in RN's fetch module
+  // exporting fetch as 'undefined'.
+  // The fix below postpones trying to load fetch until the first call to symbolicateStackTrace.
+  // At that time, we will have either global.fetch (whatwg-fetch) or RN's fetch.
+  if (!fetch) {
+    fetch = global.fetch || require('fetch').fetch;
+  }
+
+  const devServer = getDevServer();
+  if (!devServer.bundleLoadedFromServer) {
+    throw new Error('Bundle was not loaded from the packager');
+  }
+
+  let stackCopy = stack;
+
+  if (SourceCode.scriptURL) {
+    let foundInternalSource: boolean = false;
+    stackCopy = stack.map((frame: StackFrame) => {
+      // If the sources exist on disk rather than appearing to come from the packager,
+      // replace the location with the packager URL until we reach an internal source
+      // which does not have a path (no slashes), indicating a switch from within
+      // the application to a surrounding debugging environment.
+      if (!foundInternalSource && isSourcedFromDisk(frame.file)) {
+        // Copy frame into new object and replace 'file' property
+        return {...frame, file: SourceCode.scriptURL};
+      }
+
+      foundInternalSource = true;
+      return frame;
+    });
+  }
+
+  const response = await fetch(devServer.url + 'symbolicate', {
+    method: 'POST',
+    body: JSON.stringify({stack: stackCopy}),
+  });
+  const json = await response.json();
+  return json.stack;
+}
+
+module.exports = symbolicateStackTrace;

node_modules/react-native/Libraries/Core/ExceptionsManager.js

@@ -0,0 +1,112 @@
+/**
+ * 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 ExceptionsManager
+ * @flow
+ */
+'use strict';
+
+import type {ExtendedError} from 'parseErrorStack';
+
+/**
+ * Handles the developer-visible aspect of errors and exceptions
+ */
+let exceptionID = 0;
+function reportException(e: ExtendedError, isFatal: bool) {
+  const {ExceptionsManager} = require('NativeModules');
+  if (ExceptionsManager) {
+    const parseErrorStack = require('parseErrorStack');
+    const stack = parseErrorStack(e);
+    const currentExceptionID = ++exceptionID;
+    if (isFatal) {
+      ExceptionsManager.reportFatalException(e.message, stack, currentExceptionID);
+    } else {
+      ExceptionsManager.reportSoftException(e.message, stack, currentExceptionID);
+    }
+    if (__DEV__) {
+      const symbolicateStackTrace = require('symbolicateStackTrace');
+      symbolicateStackTrace(stack).then(
+        (prettyStack) => {
+          if (prettyStack) {
+            ExceptionsManager.updateExceptionMessage(e.message, prettyStack, currentExceptionID);
+          } else {
+            throw new Error('The stack is null');
+          }
+        }
+      ).catch(
+        (error) => console.warn('Unable to symbolicate stack trace: ' + error.message)
+      );
+    }
+  }
+}
+
+declare var console: typeof console & {
+  _errorOriginal: Function,
+  reportErrorsAsExceptions: boolean,
+};
+
+/**
+ * Logs exceptions to the (native) console and displays them
+ */
+function handleException(e: Error, isFatal: boolean) {
+  // Workaround for reporting errors caused by `throw 'some string'`
+  // Unfortunately there is no way to figure out the stacktrace in this
+  // case, so if you ended up here trying to trace an error, look for
+  // `throw '<error message>'` somewhere in your codebase.
+  if (!e.message) {
+    e = new Error(e);
+  }
+  if (console._errorOriginal) {
+    console._errorOriginal(e.message);
+  } else {
+    console.error(e.message);
+  }
+  reportException(e, isFatal);
+}
+
+function reactConsoleErrorHandler() {
+  console._errorOriginal.apply(console, arguments);
+  if (!console.reportErrorsAsExceptions) {
+    return;
+  }
+
+  if (arguments[0] && arguments[0].stack) {
+    reportException(arguments[0], /* isFatal */ false);
+  } else {
+    const stringifySafe = require('stringifySafe');
+    const str = Array.prototype.map.call(arguments, stringifySafe).join(', ');
+    if (str.slice(0, 10) === '"Warning: ') {
+      // React warnings use console.error so that a stack trace is shown, but
+      // we don't (currently) want these to show a redbox
+      // (Note: Logic duplicated in polyfills/console.js.)
+      return;
+    }
+    const error : ExtendedError = new Error('console.error: ' + str);
+    error.framesToPop = 1;
+    reportException(error, /* isFatal */ false);
+  }
+}
+
+/**
+ * Shows a redbox with stacktrace for all console.error messages.  Disable by
+ * setting `console.reportErrorsAsExceptions = false;` in your app.
+ */
+function installConsoleErrorReporter() {
+  // Enable reportErrorsAsExceptions
+  if (console._errorOriginal) {
+    return; // already installed
+  }
+  // Flow doesn't like it when you set arbitrary values on a global object
+  console._errorOriginal = console.error.bind(console);
+  console.error = reactConsoleErrorHandler;
+  if (console.reportErrorsAsExceptions === undefined) {
+    // Individual apps can disable this
+    // Flow doesn't like it when you set arbitrary values on a global object
+    console.reportErrorsAsExceptions = true;
+  }
+}
+
+module.exports = { handleException, installConsoleErrorReporter };

node_modules/react-native/Libraries/Core/InitializeCore.js

@@ -0,0 +1,203 @@
+/**
+ * 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 InitializeCore
+ * @flow
+ */
+
+/* globals window: true */
+
+/**
+ * Sets up global variables typical in most JavaScript environments.
+ *
+ *   1. Global timers (via `setTimeout` etc).
+ *   2. Global console object.
+ *   3. Hooks for printing stack traces with source maps.
+ *
+ * Leaves enough room in the environment for implementing your own:
+ *
+ *   1. Require system.
+ *   2. Bridged modules.
+ *
+ */
+'use strict';
+
+const {polyfillObjectProperty, polyfillGlobal} = require('PolyfillFunctions');
+
+if (global.GLOBAL === undefined) {
+  global.GLOBAL = global;
+}
+
+if (global.window === undefined) {
+  global.window = global;
+}
+
+// Set up collections
+const _shouldPolyfillCollection = require('_shouldPolyfillES6Collection');
+if (_shouldPolyfillCollection('Map')) {
+  polyfillGlobal('Map', () => require('Map'));
+}
+if (_shouldPolyfillCollection('Set')) {
+  polyfillGlobal('Set', () => require('Set'));
+}
+
+// Set up process
+global.process = global.process || {};
+global.process.env = global.process.env || {};
+if (!global.process.env.NODE_ENV) {
+  global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
+}
+
+// Setup the Systrace profiling hooks if necessary
+if (global.__RCTProfileIsProfiling) {
+  const Systrace = require('Systrace');
+  Systrace.installReactHook();
+  Systrace.setEnabled(true);
+}
+
+// Set up console
+const ExceptionsManager = require('ExceptionsManager');
+ExceptionsManager.installConsoleErrorReporter();
+
+// Set up error handler
+if (!global.__fbDisableExceptionsManager) {
+  const handleError = (e, isFatal) => {
+    try {
+      ExceptionsManager.handleException(e, isFatal);
+    } catch (ee) {
+      console.log('Failed to print error: ', ee.message);
+      throw e;
+    }
+  };
+
+  const ErrorUtils = require('ErrorUtils');
+  ErrorUtils.setGlobalHandler(handleError);
+}
+
+// Check for compatibility between the JS and native code
+const ReactNativeVersionCheck = require('ReactNativeVersionCheck');
+ReactNativeVersionCheck.checkVersions();
+
+// Set up Promise
+// The native Promise implementation throws the following error:
+// ERROR: Event loop not supported.
+polyfillGlobal('Promise', () => require('Promise'));
+
+// Set up regenerator.
+polyfillGlobal('regeneratorRuntime', () => {
+  // The require just sets up the global, so make sure when we first
+  // invoke it the global does not exist
+  delete global.regeneratorRuntime;
+  /* $FlowFixMe(>=0.54.0 site=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. */
+  require('regenerator-runtime/runtime');
+  return global.regeneratorRuntime;
+});
+
+// Set up timers
+const defineLazyTimer = name => {
+  polyfillGlobal(name, () => require('JSTimers')[name]);
+};
+defineLazyTimer('setTimeout');
+defineLazyTimer('setInterval');
+defineLazyTimer('setImmediate');
+defineLazyTimer('clearTimeout');
+defineLazyTimer('clearInterval');
+defineLazyTimer('clearImmediate');
+defineLazyTimer('requestAnimationFrame');
+defineLazyTimer('cancelAnimationFrame');
+defineLazyTimer('requestIdleCallback');
+defineLazyTimer('cancelIdleCallback');
+
+// Set up XHR
+// The native XMLHttpRequest in Chrome dev tools is CORS aware and won't
+// let you fetch anything from the internet
+polyfillGlobal('XMLHttpRequest', () => require('XMLHttpRequest'));
+polyfillGlobal('FormData', () => require('FormData'));
+
+polyfillGlobal('fetch', () => require('fetch').fetch);
+polyfillGlobal('Headers', () => require('fetch').Headers);
+polyfillGlobal('Request', () => require('fetch').Request);
+polyfillGlobal('Response', () => require('fetch').Response);
+polyfillGlobal('WebSocket', () => require('WebSocket'));
+polyfillGlobal('Blob', () => require('Blob'));
+polyfillGlobal('File', () => require('File'));
+polyfillGlobal('FileReader', () => require('FileReader'));
+polyfillGlobal('URL', () => require('URL'));
+
+// Set up alert
+if (!global.alert) {
+  global.alert = function(text) {
+    // Require Alert on demand. Requiring it too early can lead to issues
+    // with things like Platform not being fully initialized.
+    require('Alert').alert('Alert', '' + text);
+  };
+}
+
+// Set up Geolocation
+let navigator = global.navigator;
+if (navigator === undefined) {
+  global.navigator = navigator = {};
+}
+
+// see https://github.com/facebook/react-native/issues/10881
+polyfillObjectProperty(navigator, 'product', () => 'ReactNative');
+polyfillObjectProperty(navigator, 'geolocation', () => require('Geolocation'));
+
+// Just to make sure the JS gets packaged up. Wait until the JS environment has
+// been initialized before requiring them.
+const BatchedBridge = require('BatchedBridge');
+BatchedBridge.registerLazyCallableModule('Systrace', () => require('Systrace'));
+BatchedBridge.registerLazyCallableModule('JSTimers', () => require('JSTimers'));
+BatchedBridge.registerLazyCallableModule('HeapCapture', () => require('HeapCapture'));
+BatchedBridge.registerLazyCallableModule('SamplingProfiler', () => require('SamplingProfiler'));
+BatchedBridge.registerLazyCallableModule('RCTLog', () => require('RCTLog'));
+BatchedBridge.registerLazyCallableModule('RCTDeviceEventEmitter', () => require('RCTDeviceEventEmitter'));
+BatchedBridge.registerLazyCallableModule('RCTNativeAppEventEmitter', () => require('RCTNativeAppEventEmitter'));
+BatchedBridge.registerLazyCallableModule('PerformanceLogger', () => require('PerformanceLogger'));
+BatchedBridge.registerLazyCallableModule('JSDevSupportModule', () => require('JSDevSupportModule'));
+
+global.__fetchSegment = function(
+  segmentId: number,
+  callback: (?Error) => void,
+) {
+  const {SegmentFetcher} = require('NativeModules');
+  if (!SegmentFetcher) {
+    throw new Error('SegmentFetcher is missing. Please ensure that it is ' +
+      'included as a NativeModule.');
+  }
+
+  SegmentFetcher.fetchSegment(segmentId, (errorObject: ?{message: string, code: string}) => {
+    if (errorObject) {
+      const error = new Error(errorObject.message);
+      (error: any).code = errorObject.code;
+      callback(error);
+    }
+
+    callback(null);
+  });
+};
+
+// Set up devtools
+if (__DEV__) {
+  if (!global.__RCTProfileIsProfiling) {
+    BatchedBridge.registerCallableModule('HMRClient', require('HMRClient'));
+
+    // not when debugging in chrome
+    // TODO(t12832058) This check is broken
+    if (!window.document) {
+      require('setupDevtools');
+    }
+
+    // Set up inspector
+    const JSInspector = require('JSInspector');
+    /* $FlowFixMe(>=0.56.0 site=react_native_fb,react_native_oss) This comment
+     * suppresses an error found when Flow v0.56 was deployed. To see the error
+     * delete this comment and run Flow. */
+    JSInspector.registerAgent(require('NetworkAgent'));
+  }
+}

node_modules/react-native/Libraries/Core/ReactNativeVersion.js

@@ -0,0 +1,18 @@
+/**
+ * @generated by scripts/bump-oss-version.js
+ *
+ * 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.
+ *
+ * @flow
+ * @providesModule ReactNativeVersion
+ */
+
+exports.version = {
+  major: 0,
+  minor: 55,
+  patch: 4,
+  prerelease: null,
+};

node_modules/react-native/Libraries/Core/ReactNativeVersionCheck.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2017-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 ReactNativeVersionCheck
+ * @flow
+ * @format
+ */
+'use strict';
+
+const {PlatformConstants} = require('NativeModules');
+const ReactNativeVersion = require('ReactNativeVersion');
+
+/**
+ * Checks that the version of this React Native JS is compatible with the native
+ * code, throwing an error if it isn't.
+ *
+ * The existence of this module is part of the public interface of React Native
+ * even though it is used only internally within React Native. React Native
+ * implementations for other platforms (ex: Windows) may override this module
+ * and rely on its existence as a separate module.
+ */
+exports.checkVersions = function checkVersions(): void {
+  if (!PlatformConstants) {
+    return;
+  }
+
+  const nativeVersion = PlatformConstants.reactNativeVersion;
+  if (
+    ReactNativeVersion.version.major !== nativeVersion.major ||
+    ReactNativeVersion.version.minor !== nativeVersion.minor
+  ) {
+    console.error(
+      `React Native version mismatch.\n\nJavaScript version: ${_formatVersion(
+        ReactNativeVersion.version,
+      )}\n` +
+        `Native version: ${_formatVersion(nativeVersion)}\n\n` +
+        'Make sure that you have rebuilt the native code. If the problem ' +
+        'persists try clearing the Watchman and packager caches with ' +
+        '`watchman watch-del-all && react-native start --reset-cache`.',
+    );
+  }
+};
+
+function _formatVersion(version): string {
+  return (
+    `${version.major}.${version.minor}.${version.patch}` +
+    (version.prerelease !== null ? `-${version.prerelease}` : '')
+  );
+}

node_modules/react-native/Libraries/Core/Timers/JSTimers.js

@@ -0,0 +1,495 @@
+/**
+ * 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 JSTimers
+ * @format
+ * @flow
+ */
+'use strict';
+
+const Platform = require('Platform');
+const Systrace = require('Systrace');
+
+const invariant = require('fbjs/lib/invariant');
+const {Timing} = require('NativeModules');
+
+import type {ExtendedError} from 'parseErrorStack';
+
+let _performanceNow = null;
+function performanceNow() {
+  if (!_performanceNow) {
+    /* $FlowFixMe(>=0.54.0 site=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. */
+    _performanceNow = require('fbjs/lib/performanceNow');
+  }
+  return _performanceNow();
+}
+
+/**
+ * JS implementation of timer functions. Must be completely driven by an
+ * external clock signal, all that's stored here is timerID, timer type, and
+ * callback.
+ */
+
+export type JSTimerType =
+  | 'setTimeout'
+  | 'setInterval'
+  | 'requestAnimationFrame'
+  | 'setImmediate'
+  | 'requestIdleCallback';
+
+// These timing constants should be kept in sync with the ones in native ios and
+// android `RCTTiming` module.
+const FRAME_DURATION = 1000 / 60;
+const IDLE_CALLBACK_FRAME_DEADLINE = 1;
+
+const MAX_TIMER_DURATION_MS = 60 * 1000;
+const IS_ANDROID = Platform.OS === 'android';
+const ANDROID_LONG_TIMER_MESSAGE =
+  'Setting a timer for a long period of time, i.e. multiple minutes, is a ' +
+  'performance and correctness issue on Android as it keeps the timer ' +
+  'module awake, and timers can only be called when the app is in the foreground. ' +
+  'See https://github.com/facebook/react-native/issues/12981 for more info.';
+
+// Parallel arrays
+const callbacks: Array<?Function> = [];
+const types: Array<?JSTimerType> = [];
+const timerIDs: Array<?number> = [];
+let immediates: Array<number> = [];
+let requestIdleCallbacks: Array<number> = [];
+const requestIdleCallbackTimeouts: {[number]: number} = {};
+const identifiers: Array<null | {methodName: string}> = [];
+
+let GUID = 1;
+let errors: ?Array<Error> = null;
+
+let hasEmittedTimeDriftWarning = false;
+
+// Returns a free index if one is available, and the next consecutive index otherwise.
+function _getFreeIndex(): number {
+  let freeIndex = timerIDs.indexOf(null);
+  if (freeIndex === -1) {
+    freeIndex = timerIDs.length;
+  }
+  return freeIndex;
+}
+
+function _allocateCallback(func: Function, type: JSTimerType): number {
+  const id = GUID++;
+  const freeIndex = _getFreeIndex();
+  timerIDs[freeIndex] = id;
+  callbacks[freeIndex] = func;
+  types[freeIndex] = type;
+  if (__DEV__) {
+    const parseErrorStack = require('parseErrorStack');
+    const error: ExtendedError = new Error();
+    error.framesToPop = 1;
+    const stack = parseErrorStack(error);
+    if (stack) {
+      identifiers[freeIndex] = stack.shift();
+    }
+  }
+  return id;
+}
+
+/**
+ * Calls the callback associated with the ID. Also unregister that callback
+ * if it was a one time timer (setTimeout), and not unregister it if it was
+ * recurring (setInterval).
+ */
+function _callTimer(timerID: number, frameTime: number, didTimeout: ?boolean) {
+  /* $FlowFixMe(>=0.54.0 site=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. */
+  require('fbjs/lib/warning')(
+    timerID <= GUID,
+    'Tried to call timer with ID %s but no such timer exists.',
+    timerID,
+  );
+
+  // timerIndex of -1 means that no timer with that ID exists. There are
+  // two situations when this happens, when a garbage timer ID was given
+  // and when a previously existing timer was deleted before this callback
+  // fired. In both cases we want to ignore the timer id, but in the former
+  // case we warn as well.
+  const timerIndex = timerIDs.indexOf(timerID);
+  if (timerIndex === -1) {
+    return;
+  }
+
+  const type = types[timerIndex];
+  const callback = callbacks[timerIndex];
+  if (!callback || !type) {
+    console.error('No callback found for timerID ' + timerID);
+    return;
+  }
+
+  if (__DEV__) {
+    const identifier = identifiers[timerIndex] || {};
+    Systrace.beginEvent('Systrace.callTimer: ' + identifier.methodName);
+  }
+
+  // Clear the metadata
+  if (
+    type === 'setTimeout' ||
+    type === 'setImmediate' ||
+    type === 'requestAnimationFrame' ||
+    type === 'requestIdleCallback'
+  ) {
+    _clearIndex(timerIndex);
+  }
+
+  try {
+    if (
+      type === 'setTimeout' ||
+      type === 'setInterval' ||
+      type === 'setImmediate'
+    ) {
+      callback();
+    } else if (type === 'requestAnimationFrame') {
+      callback(performanceNow());
+    } else if (type === 'requestIdleCallback') {
+      callback({
+        timeRemaining: function() {
+          // TODO: Optimisation: allow running for longer than one frame if
+          // there are no pending JS calls on the bridge from native. This
+          // would require a way to check the bridge queue synchronously.
+          return Math.max(0, FRAME_DURATION - (performanceNow() - frameTime));
+        },
+        didTimeout: !!didTimeout,
+      });
+    } else {
+      console.error('Tried to call a callback with invalid type: ' + type);
+    }
+  } catch (e) {
+    // Don't rethrow so that we can run all timers.
+    if (!errors) {
+      errors = [e];
+    } else {
+      errors.push(e);
+    }
+  }
+
+  if (__DEV__) {
+    Systrace.endEvent();
+  }
+}
+
+/**
+ * Performs a single pass over the enqueued immediates. Returns whether
+ * more immediates are queued up (can be used as a condition a while loop).
+ */
+function _callImmediatesPass() {
+  if (__DEV__) {
+    Systrace.beginEvent('callImmediatesPass()');
+  }
+
+  // The main reason to extract a single pass is so that we can track
+  // in the system trace
+  if (immediates.length > 0) {
+    const passImmediates = immediates.slice();
+    immediates = [];
+
+    // Use for loop rather than forEach as per @vjeux's advice
+    // https://github.com/facebook/react-native/commit/c8fd9f7588ad02d2293cac7224715f4af7b0f352#commitcomment-14570051
+    for (let i = 0; i < passImmediates.length; ++i) {
+      _callTimer(passImmediates[i], 0);
+    }
+  }
+
+  if (__DEV__) {
+    Systrace.endEvent();
+  }
+  return immediates.length > 0;
+}
+
+function _clearIndex(i: number) {
+  timerIDs[i] = null;
+  callbacks[i] = null;
+  types[i] = null;
+  identifiers[i] = null;
+}
+
+function _freeCallback(timerID: number) {
+  // timerIDs contains nulls after timers have been removed;
+  // ignore nulls upfront so indexOf doesn't find them
+  if (timerID == null) {
+    return;
+  }
+
+  const index = timerIDs.indexOf(timerID);
+  // See corresponding comment in `callTimers` for reasoning behind this
+  if (index !== -1) {
+    _clearIndex(index);
+    const type = types[index];
+    if (type !== 'setImmediate' && type !== 'requestIdleCallback') {
+      Timing.deleteTimer(timerID);
+    }
+  }
+}
+
+/**
+ * JS implementation of timer functions. Must be completely driven by an
+ * external clock signal, all that's stored here is timerID, timer type, and
+ * callback.
+ */
+const JSTimers = {
+  /**
+   * @param {function} func Callback to be invoked after `duration` ms.
+   * @param {number} duration Number of milliseconds.
+   */
+  setTimeout: function(func: Function, duration: number, ...args: any): number {
+    if (__DEV__ && IS_ANDROID && duration > MAX_TIMER_DURATION_MS) {
+      console.warn(
+        ANDROID_LONG_TIMER_MESSAGE +
+          '\n' +
+          '(Saw setTimeout with duration ' +
+          duration +
+          'ms)',
+      );
+    }
+    const id = _allocateCallback(
+      () => func.apply(undefined, args),
+      'setTimeout',
+    );
+    Timing.createTimer(id, duration || 0, Date.now(), /* recurring */ false);
+    return id;
+  },
+
+  /**
+   * @param {function} func Callback to be invoked every `duration` ms.
+   * @param {number} duration Number of milliseconds.
+   */
+  setInterval: function(
+    func: Function,
+    duration: number,
+    ...args: any
+  ): number {
+    if (__DEV__ && IS_ANDROID && duration > MAX_TIMER_DURATION_MS) {
+      console.warn(
+        ANDROID_LONG_TIMER_MESSAGE +
+          '\n' +
+          '(Saw setInterval with duration ' +
+          duration +
+          'ms)',
+      );
+    }
+    const id = _allocateCallback(
+      () => func.apply(undefined, args),
+      'setInterval',
+    );
+    Timing.createTimer(id, duration || 0, Date.now(), /* recurring */ true);
+    return id;
+  },
+
+  /**
+   * @param {function} func Callback to be invoked before the end of the
+   * current JavaScript execution loop.
+   */
+  setImmediate: function(func: Function, ...args: any) {
+    const id = _allocateCallback(
+      () => func.apply(undefined, args),
+      'setImmediate',
+    );
+    immediates.push(id);
+    return id;
+  },
+
+  /**
+   * @param {function} func Callback to be invoked every frame.
+   */
+  requestAnimationFrame: function(func: Function) {
+    const id = _allocateCallback(func, 'requestAnimationFrame');
+    Timing.createTimer(id, 1, Date.now(), /* recurring */ false);
+    return id;
+  },
+
+  /**
+   * @param {function} func Callback to be invoked every frame and provided
+   * with time remaining in frame.
+   * @param {?object} options
+   */
+  requestIdleCallback: function(func: Function, options: ?Object) {
+    if (requestIdleCallbacks.length === 0) {
+      Timing.setSendIdleEvents(true);
+    }
+
+    const timeout = options && options.timeout;
+    const id = _allocateCallback(
+      timeout != null
+        ? deadline => {
+            const timeoutId = requestIdleCallbackTimeouts[id];
+            if (timeoutId) {
+              JSTimers.clearTimeout(timeoutId);
+              delete requestIdleCallbackTimeouts[id];
+            }
+            return func(deadline);
+          }
+        : func,
+      'requestIdleCallback',
+    );
+    requestIdleCallbacks.push(id);
+
+    if (timeout != null) {
+      const timeoutId = JSTimers.setTimeout(() => {
+        const index = requestIdleCallbacks.indexOf(id);
+        if (index > -1) {
+          requestIdleCallbacks.splice(index, 1);
+          _callTimer(id, performanceNow(), true);
+        }
+        delete requestIdleCallbackTimeouts[id];
+        if (requestIdleCallbacks.length === 0) {
+          Timing.setSendIdleEvents(false);
+        }
+      }, timeout);
+      requestIdleCallbackTimeouts[id] = timeoutId;
+    }
+    return id;
+  },
+
+  cancelIdleCallback: function(timerID: number) {
+    _freeCallback(timerID);
+    const index = requestIdleCallbacks.indexOf(timerID);
+    if (index !== -1) {
+      requestIdleCallbacks.splice(index, 1);
+    }
+
+    const timeoutId = requestIdleCallbackTimeouts[timerID];
+    if (timeoutId) {
+      JSTimers.clearTimeout(timeoutId);
+      delete requestIdleCallbackTimeouts[timerID];
+    }
+
+    if (requestIdleCallbacks.length === 0) {
+      Timing.setSendIdleEvents(false);
+    }
+  },
+
+  clearTimeout: function(timerID: number) {
+    _freeCallback(timerID);
+  },
+
+  clearInterval: function(timerID: number) {
+    _freeCallback(timerID);
+  },
+
+  clearImmediate: function(timerID: number) {
+    _freeCallback(timerID);
+    const index = immediates.indexOf(timerID);
+    if (index !== -1) {
+      immediates.splice(index, 1);
+    }
+  },
+
+  cancelAnimationFrame: function(timerID: number) {
+    _freeCallback(timerID);
+  },
+
+  /**
+   * This is called from the native side. We are passed an array of timerIDs,
+   * and
+   */
+  callTimers: function(timersToCall: Array<number>) {
+    invariant(
+      timersToCall.length !== 0,
+      'Cannot call `callTimers` with an empty list of IDs.',
+    );
+
+    // $FlowFixMe: optionals do not allow assignment from null
+    errors = null;
+    for (let i = 0; i < timersToCall.length; i++) {
+      _callTimer(timersToCall[i], 0);
+    }
+
+    if (errors) {
+      const errorCount = errors.length;
+      if (errorCount > 1) {
+        // Throw all the other errors in a setTimeout, which will throw each
+        // error one at a time
+        for (let ii = 1; ii < errorCount; ii++) {
+          JSTimers.setTimeout(
+            (error => {
+              throw error;
+            }).bind(null, errors[ii]),
+            0,
+          );
+        }
+      }
+      throw errors[0];
+    }
+  },
+
+  callIdleCallbacks: function(frameTime: number) {
+    if (
+      FRAME_DURATION - (performanceNow() - frameTime) <
+      IDLE_CALLBACK_FRAME_DEADLINE
+    ) {
+      return;
+    }
+
+    // $FlowFixMe: optionals do not allow assignment from null
+    errors = null;
+    if (requestIdleCallbacks.length > 0) {
+      const passIdleCallbacks = requestIdleCallbacks.slice();
+      requestIdleCallbacks = [];
+
+      for (let i = 0; i < passIdleCallbacks.length; ++i) {
+        _callTimer(passIdleCallbacks[i], frameTime);
+      }
+    }
+
+    if (requestIdleCallbacks.length === 0) {
+      Timing.setSendIdleEvents(false);
+    }
+
+    if (errors) {
+      errors.forEach(error =>
+        JSTimers.setTimeout(() => {
+          throw error;
+        }, 0),
+      );
+    }
+  },
+
+  /**
+   * This is called after we execute any command we receive from native but
+   * before we hand control back to native.
+   */
+  callImmediates() {
+    errors = null;
+    while (_callImmediatesPass()) {}
+    if (errors) {
+      errors.forEach(error =>
+        JSTimers.setTimeout(() => {
+          throw error;
+        }, 0),
+      );
+    }
+  },
+
+  /**
+   * Called from native (in development) when environment times are out-of-sync.
+   */
+  emitTimeDriftWarning(warningMessage: string) {
+    if (hasEmittedTimeDriftWarning) {
+      return;
+    }
+    hasEmittedTimeDriftWarning = true;
+    console.warn(warningMessage);
+  },
+};
+
+if (!Timing) {
+  console.warn("Timing native module is not available, can't set timers.");
+  // $FlowFixMe: we can assume timers are generally available
+  module.exports = ({
+    callImmediates: JSTimers.callImmediates,
+    setImmediate: JSTimers.setImmediate,
+  }: typeof JSTimers);
+} else {
+  module.exports = JSTimers;
+}

node_modules/react-native/Libraries/Core/__mocks__/ErrorUtils.js

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+
+// This mock only provides short-circuited methods of applyWithGuard and guard.
+// A lot of modules rely on these two functions. This mock relieves their tests
+// from depending on the real ErrorUtils module. If you need real error handling
+// don't use this mock.
+'use strict';
+
+function execute(fun, context, args) {
+  return fun.apply(context, args);
+}
+
+function reportError(error) {
+  throw error;
+}
+
+var ErrorUtils = {
+  apply: jest.fn(execute),
+  applyWithGuard: jest.fn(execute),
+  guard: jest.fn(callback => callback),
+  inGuard: jest.fn().mockReturnValue(true),
+  reportError: jest.fn(reportError),
+  setGlobalHandler: jest.fn(),
+};
+
+module.exports = ErrorUtils;