initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/ReactNative/AppContainer.js

@@ -0,0 +1,137 @@
+/**
+ * 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 AppContainer
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const EmitterSubscription = require('EmitterSubscription');
+const PropTypes = require('prop-types');
+const RCTDeviceEventEmitter = require('RCTDeviceEventEmitter');
+const React = require('React');
+const ReactNative = require('ReactNative');
+const StyleSheet = require('StyleSheet');
+const View = require('View');
+
+type Context = {
+  rootTag: number,
+};
+type Props = {|
+  /* $FlowFixMe(>=0.53.0 site=react_native_fb,react_native_oss) This comment
+   * suppresses an error when upgrading Flow's support for React. To see the
+   * error delete this comment and run Flow. */
+  children?: React.Children,
+  fabric?: boolean,
+  rootTag: number,
+  WrapperComponent?: ?React.ComponentType<*>,
+|};
+type State = {
+  inspector: ?React.Element<any>,
+  mainKey: number,
+};
+
+class AppContainer extends React.Component<Props, State> {
+  state: State = {
+    inspector: null,
+    mainKey: 1,
+  };
+  _mainRef: ?React.Element<any>;
+  _subscription: ?EmitterSubscription = null;
+
+  static childContextTypes = {
+    rootTag: PropTypes.number,
+  };
+
+  getChildContext(): Context {
+    return {
+      rootTag: this.props.rootTag,
+    };
+  }
+
+  componentDidMount(): void {
+    if (__DEV__) {
+      if (!global.__RCTProfileIsProfiling) {
+        this._subscription = RCTDeviceEventEmitter.addListener(
+          'toggleElementInspector',
+          () => {
+            const Inspector = require('Inspector');
+            const inspector = this.state.inspector ? null : (
+              <Inspector
+                inspectedViewTag={ReactNative.findNodeHandle(this._mainRef)}
+                onRequestRerenderApp={updateInspectedViewTag => {
+                  this.setState(
+                    s => ({mainKey: s.mainKey + 1}),
+                    () =>
+                      updateInspectedViewTag(
+                        ReactNative.findNodeHandle(this._mainRef),
+                      ),
+                  );
+                }}
+              />
+            );
+            this.setState({inspector});
+          },
+        );
+      }
+    }
+  }
+
+  componentWillUnmount(): void {
+    if (this._subscription) {
+      this._subscription.remove();
+    }
+  }
+
+  render(): React.Node {
+    let yellowBox = null;
+    if (__DEV__) {
+      if (!global.__RCTProfileIsProfiling && !this.props.fabric) {
+        // TODO: Fabric doesn't support YellowBox.
+        const YellowBox = require('YellowBox');
+        yellowBox = <YellowBox />;
+      }
+    }
+
+    let innerView = (
+      <View
+        collapsable={!this.state.inspector}
+        key={this.state.mainKey}
+        pointerEvents="box-none"
+        style={styles.appContainer}
+        ref={ref => {
+          /* $FlowFixMe(>=0.53.0 site=react_native_fb,react_native_oss) This
+           * comment suppresses an error when upgrading Flow's support for
+           * React. To see the error delete this comment and run Flow. */
+          this._mainRef = ref;
+        }}>
+        {this.props.children}
+      </View>
+    );
+
+    const Wrapper = this.props.WrapperComponent;
+    if (Wrapper) {
+      innerView = <Wrapper>{innerView}</Wrapper>;
+    }
+    return (
+      <View style={styles.appContainer} pointerEvents="box-none">
+        {innerView}
+        {yellowBox}
+        {this.state.inspector}
+      </View>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  appContainer: {
+    flex: 1,
+  },
+});
+
+module.exports = AppContainer;

node_modules/react-native/Libraries/ReactNative/AppRegistry.js

@@ -0,0 +1,243 @@
+/**
+ * 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 AppRegistry
+ * @flow
+ * @format
+ */
+'use strict';
+
+const BatchedBridge = require('BatchedBridge');
+const BugReporting = require('BugReporting');
+const NativeModules = require('NativeModules');
+const ReactNative = require('ReactNative');
+const SceneTracker = require('SceneTracker');
+
+const infoLog = require('infoLog');
+const invariant = require('fbjs/lib/invariant');
+const renderApplication = require('renderApplication');
+
+type Task = (taskData: any) => Promise<void>;
+type TaskProvider = () => Task;
+export type ComponentProvider = () => React$ComponentType<any>;
+export type ComponentProviderInstrumentationHook = (
+  component: ComponentProvider,
+) => React$ComponentType<any>;
+export type AppConfig = {
+  appKey: string,
+  component?: ComponentProvider,
+  run?: Function,
+  section?: boolean,
+};
+export type Runnable = {
+  component?: ComponentProvider,
+  run: Function,
+};
+export type Runnables = {
+  [appKey: string]: Runnable,
+};
+export type Registry = {
+  sections: Array<string>,
+  runnables: Runnables,
+};
+export type WrapperComponentProvider = any => React$ComponentType<*>;
+
+const runnables: Runnables = {};
+let runCount = 1;
+const sections: Runnables = {};
+const tasks: Map<string, TaskProvider> = new Map();
+let componentProviderInstrumentationHook: ComponentProviderInstrumentationHook = (
+  component: ComponentProvider,
+) => component();
+
+let wrapperComponentProvider: ?WrapperComponentProvider;
+
+/**
+ * `AppRegistry` is the JavaScript entry point to running all React Native apps.
+ *
+ * See http://facebook.github.io/react-native/docs/appregistry.html
+ */
+const AppRegistry = {
+  setWrapperComponentProvider(provider: WrapperComponentProvider) {
+    wrapperComponentProvider = provider;
+  },
+
+  registerConfig(config: Array<AppConfig>): void {
+    config.forEach(appConfig => {
+      if (appConfig.run) {
+        AppRegistry.registerRunnable(appConfig.appKey, appConfig.run);
+      } else {
+        invariant(
+          appConfig.component != null,
+          'AppRegistry.registerConfig(...): Every config is expected to set ' +
+            'either `run` or `component`, but `%s` has neither.',
+          appConfig.appKey,
+        );
+        AppRegistry.registerComponent(
+          appConfig.appKey,
+          appConfig.component,
+          appConfig.section,
+        );
+      }
+    });
+  },
+
+  /**
+   * Registers an app's root component.
+   *
+   * See http://facebook.github.io/react-native/docs/appregistry.html#registercomponent
+   */
+  registerComponent(
+    appKey: string,
+    componentProvider: ComponentProvider,
+    section?: boolean,
+  ): string {
+    runnables[appKey] = {
+      componentProvider,
+      run: appParameters =>
+        renderApplication(
+          componentProviderInstrumentationHook(componentProvider),
+          appParameters.initialProps,
+          appParameters.rootTag,
+          wrapperComponentProvider && wrapperComponentProvider(appParameters),
+        ),
+    };
+    if (section) {
+      sections[appKey] = runnables[appKey];
+    }
+    return appKey;
+  },
+
+  registerRunnable(appKey: string, run: Function): string {
+    runnables[appKey] = {run};
+    return appKey;
+  },
+
+  registerSection(appKey: string, component: ComponentProvider): void {
+    AppRegistry.registerComponent(appKey, component, true);
+  },
+
+  getAppKeys(): Array<string> {
+    return Object.keys(runnables);
+  },
+
+  getSectionKeys(): Array<string> {
+    return Object.keys(sections);
+  },
+
+  getSections(): Runnables {
+    return {
+      ...sections,
+    };
+  },
+
+  getRunnable(appKey: string): ?Runnable {
+    return runnables[appKey];
+  },
+
+  getRegistry(): Registry {
+    return {
+      sections: AppRegistry.getSectionKeys(),
+      runnables: {...runnables},
+    };
+  },
+
+  setComponentProviderInstrumentationHook(
+    hook: ComponentProviderInstrumentationHook,
+  ) {
+    componentProviderInstrumentationHook = hook;
+  },
+
+  /**
+   * Loads the JavaScript bundle and runs the app.
+   *
+   * See http://facebook.github.io/react-native/docs/appregistry.html#runapplication
+   */
+  runApplication(appKey: string, appParameters: any): void {
+    const msg =
+      'Running application "' +
+      appKey +
+      '" with appParams: ' +
+      JSON.stringify(appParameters) +
+      '. ' +
+      '__DEV__ === ' +
+      String(__DEV__) +
+      ', development-level warning are ' +
+      (__DEV__ ? 'ON' : 'OFF') +
+      ', performance optimizations are ' +
+      (__DEV__ ? 'OFF' : 'ON');
+    infoLog(msg);
+    BugReporting.addSource(
+      'AppRegistry.runApplication' + runCount++,
+      () => msg,
+    );
+    invariant(
+      runnables[appKey] && runnables[appKey].run,
+      'Application ' +
+        appKey +
+        ' has not been registered.\n\n' +
+        "Hint: This error often happens when you're running the packager " +
+        '(local dev server) from a wrong folder. For example you have ' +
+        'multiple apps and the packager is still running for the app you ' +
+        'were working on before.\nIf this is the case, simply kill the old ' +
+        'packager instance (e.g. close the packager terminal window) ' +
+        'and start the packager in the correct app folder (e.g. cd into app ' +
+        "folder and run 'npm start').\n\n" +
+        'This error can also happen due to a require() error during ' +
+        'initialization or failure to call AppRegistry.registerComponent.\n\n',
+    );
+
+    SceneTracker.setActiveScene({name: appKey});
+    runnables[appKey].run(appParameters);
+  },
+
+  /**
+   * Stops an application when a view should be destroyed.
+   *
+   * See http://facebook.github.io/react-native/docs/appregistry.html#unmountapplicationcomponentatroottag
+   */
+  unmountApplicationComponentAtRootTag(rootTag: number): void {
+    ReactNative.unmountComponentAtNodeAndRemoveContainer(rootTag);
+  },
+
+  /**
+   * Register a headless task. A headless task is a bit of code that runs without a UI.
+   *
+   * See http://facebook.github.io/react-native/docs/appregistry.html#registerheadlesstask
+   */
+  registerHeadlessTask(taskKey: string, task: TaskProvider): void {
+    if (tasks.has(taskKey)) {
+      console.warn(
+        `registerHeadlessTask called multiple times for same key '${taskKey}'`,
+      );
+    }
+    tasks.set(taskKey, task);
+  },
+
+  /**
+   * Only called from native code. Starts a headless task.
+   *
+   * See http://facebook.github.io/react-native/docs/appregistry.html#startheadlesstask
+   */
+  startHeadlessTask(taskId: number, taskKey: string, data: any): void {
+    const taskProvider = tasks.get(taskKey);
+    if (!taskProvider) {
+      throw new Error(`No task registered for key ${taskKey}`);
+    }
+    taskProvider()(data)
+      .then(() =>
+        NativeModules.HeadlessJsTaskSupport.notifyTaskFinished(taskId),
+      )
+      .catch(reason => {
+        console.error(reason);
+        NativeModules.HeadlessJsTaskSupport.notifyTaskFinished(taskId);
+      });
+  },
+};
+
+BatchedBridge.registerCallableModule('AppRegistry', AppRegistry);
+
+module.exports = AppRegistry;

node_modules/react-native/Libraries/ReactNative/FabricUIManager.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 FabricUIManager
+ * @flow
+ * @format
+ */
+'use strict';
+
+// TODO: type these properly.
+type Node = {};
+type NodeSet = Array<Node>;
+type NodeProps = {};
+type InstanceHandle = {};
+type Spec = {|
+  +createNode: (
+    reactTag: number,
+    viewName: string,
+    rootTag: number,
+    props: NodeProps,
+    instanceHandle: InstanceHandle,
+  ) => Node,
+  +cloneNode: (node: Node) => Node,
+  +cloneNodeWithNewChildren: (node: Node) => Node,
+  +cloneNodeWithNewProps: (node: Node, newProps: NodeProps) => Node,
+  +cloneNodeWithNewChildrenAndProps: (node: Node, newProps: NodeProps) => Node,
+  +createChildSet: (rootTag: number) => NodeSet,
+  +appendChild: (parentNode: Node, child: Node) => Node,
+  +appendChildToSet: (childSet: NodeSet, child: Node) => void,
+  +completeRoot: (rootTag: number, childSet: NodeSet) => void,
+|};
+
+const FabricUIManager: ?Spec = global.nativeFabricUIManager;
+
+module.exports = FabricUIManager;

node_modules/react-native/Libraries/ReactNative/I18nManager.js

@@ -0,0 +1,29 @@
+/**
+ * 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 I18nManager
+ * @flow
+ * @format
+ */
+'use strict';
+
+type I18nManagerStatus = {
+  isRTL: boolean,
+  doLeftAndRightSwapInRTL: boolean,
+  allowRTL: (allowRTL: boolean) => {},
+  forceRTL: (forceRTL: boolean) => {},
+  swapLeftAndRightInRTL: (flipStyles: boolean) => {},
+};
+
+const I18nManager: I18nManagerStatus = require('NativeModules').I18nManager || {
+  isRTL: false,
+  doLeftAndRightSwapInRTL: true,
+  allowRTL: () => {},
+  forceRTL: () => {},
+  swapLeftAndRightInRTL: () => {},
+};
+
+module.exports = I18nManager;

node_modules/react-native/Libraries/ReactNative/UIManager.js

@@ -0,0 +1,88 @@
+/**
+ * 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 UIManager
+ * @flow
+ * @format
+ */
+'use strict';
+
+const NativeModules = require('NativeModules');
+const Platform = require('Platform');
+
+const defineLazyObjectProperty = require('defineLazyObjectProperty');
+const invariant = require('fbjs/lib/invariant');
+
+const {UIManager} = NativeModules;
+
+invariant(
+  UIManager,
+  'UIManager is undefined. The native module config is probably incorrect.',
+);
+
+// In past versions of ReactNative users called UIManager.takeSnapshot()
+// However takeSnapshot was moved to ReactNative in order to support flat
+// bundles and to avoid a cyclic dependency between UIManager and ReactNative.
+// UIManager.takeSnapshot still exists though. In order to avoid confusion or
+// accidental usage, mask the method with a deprecation warning.
+UIManager.__takeSnapshot = UIManager.takeSnapshot;
+UIManager.takeSnapshot = function() {
+  invariant(
+    false,
+    'UIManager.takeSnapshot should not be called directly. ' +
+      'Use ReactNative.takeSnapshot instead.',
+  );
+};
+
+/**
+ * Copies the ViewManager constants and commands into UIManager. This is
+ * only needed for iOS, which puts the constants in the ViewManager
+ * namespace instead of UIManager, unlike Android.
+ */
+if (Platform.OS === 'ios') {
+  Object.keys(UIManager).forEach(viewName => {
+    const viewConfig = UIManager[viewName];
+    if (viewConfig.Manager) {
+      defineLazyObjectProperty(viewConfig, 'Constants', {
+        get: () => {
+          const viewManager = NativeModules[viewConfig.Manager];
+          const constants = {};
+          viewManager &&
+            Object.keys(viewManager).forEach(key => {
+              const value = viewManager[key];
+              if (typeof value !== 'function') {
+                constants[key] = value;
+              }
+            });
+          return constants;
+        },
+      });
+      defineLazyObjectProperty(viewConfig, 'Commands', {
+        get: () => {
+          const viewManager = NativeModules[viewConfig.Manager];
+          const commands = {};
+          let index = 0;
+          viewManager &&
+            Object.keys(viewManager).forEach(key => {
+              const value = viewManager[key];
+              if (typeof value === 'function') {
+                commands[key] = index++;
+              }
+            });
+          return commands;
+        },
+      });
+    }
+  });
+} else if (UIManager.ViewManagerNames) {
+  UIManager.ViewManagerNames.forEach(viewManagerName => {
+    defineLazyObjectProperty(UIManager, viewManagerName, {
+      get: () => UIManager.getConstantsForViewManager(viewManagerName),
+    });
+  });
+}
+
+module.exports = UIManager;

node_modules/react-native/Libraries/ReactNative/UIManagerStatTracker.js

@@ -0,0 +1,63 @@
+/**
+ * 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 UIManagerStatTracker
+ * @flow
+ * @format
+ */
+'use strict';
+
+var UIManager = require('UIManager');
+
+var installed = false;
+var UIManagerStatTracker = {
+  install: function() {
+    if (installed) {
+      return;
+    }
+    installed = true;
+    var statLogHandle;
+    var stats = {};
+    function printStats() {
+      console.log({UIManagerStatTracker: stats});
+      statLogHandle = null;
+    }
+    function incStat(key: string, increment: number) {
+      stats[key] = (stats[key] || 0) + increment;
+      if (!statLogHandle) {
+        statLogHandle = setImmediate(printStats);
+      }
+    }
+    var createViewOrig = UIManager.createView;
+    UIManager.createView = function(tag, className, rootTag, props) {
+      incStat('createView', 1);
+      incStat('setProp', Object.keys(props || []).length);
+      createViewOrig(tag, className, rootTag, props);
+    };
+    var updateViewOrig = UIManager.updateView;
+    UIManager.updateView = function(tag, className, props) {
+      incStat('updateView', 1);
+      incStat('setProp', Object.keys(props || []).length);
+      updateViewOrig(tag, className, props);
+    };
+    var manageChildrenOrig = UIManager.manageChildren;
+    UIManager.manageChildren = function(
+      tag,
+      moveFrom,
+      moveTo,
+      addTags,
+      addIndices,
+      remove,
+    ) {
+      incStat('manageChildren', 1);
+      incStat('move', Object.keys(moveFrom || []).length);
+      incStat('remove', Object.keys(remove || []).length);
+      manageChildrenOrig(tag, moveFrom, moveTo, addTags, addIndices, remove);
+    };
+  },
+};
+
+module.exports = UIManagerStatTracker;

node_modules/react-native/Libraries/ReactNative/YellowBox.js

@@ -0,0 +1,532 @@
+/**
+ * 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 YellowBox
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const EventEmitter = require('EventEmitter');
+const Platform = require('Platform');
+const React = require('React');
+const SafeAreaView = require('SafeAreaView');
+const StyleSheet = require('StyleSheet');
+const RCTLog = require('RCTLog');
+
+const infoLog = require('infoLog');
+const openFileInEditor = require('openFileInEditor');
+const parseErrorStack = require('parseErrorStack');
+const stringifySafe = require('stringifySafe');
+const symbolicateStackTrace = require('symbolicateStackTrace');
+
+import type EmitterSubscription from 'EmitterSubscription';
+import type {StackFrame} from 'parseErrorStack';
+
+type WarningInfo = {
+  count: number,
+  stacktrace: Array<StackFrame>,
+  symbolicated: boolean,
+};
+
+const _warningEmitter = new EventEmitter();
+const _warningMap: Map<string, WarningInfo> = new Map();
+const IGNORED_WARNINGS: Array<string> = [];
+
+/**
+ * YellowBox renders warnings at the bottom of the app being developed.
+ *
+ * Warnings help guard against subtle yet significant issues that can impact the
+ * quality of the app. This "in your face" style of warning allows developers to
+ * notice and correct these issues as quickly as possible.
+ *
+ * By default, the warning box is enabled in `__DEV__`. Set the following flag
+ * to disable it (and call `console.warn` to update any rendered <YellowBox>):
+ *
+ *   console.disableYellowBox = true;
+ *   console.warn('YellowBox is disabled.');
+ *
+ * Ignore specific warnings by calling:
+ *
+ *   YellowBox.ignoreWarnings(['Warning: ...']);
+ *
+ * (DEPRECATED) Warnings can be ignored programmatically by setting the array:
+ *
+ *   console.ignoredYellowBox = ['Warning: ...'];
+ *
+ * Strings in `console.ignoredYellowBox` can be a prefix of the warning that
+ * should be ignored.
+ */
+
+if (__DEV__) {
+  const {error, warn} = console;
+
+  (console: any).error = function() {
+    error.apply(console, arguments);
+    // Show yellow box for the `warning` module.
+    if (
+      typeof arguments[0] === 'string' &&
+      arguments[0].startsWith('Warning: ')
+    ) {
+      updateWarningMap.apply(null, arguments);
+    }
+  };
+
+  (console: any).warn = function() {
+    warn.apply(console, arguments);
+    updateWarningMap.apply(null, arguments);
+  };
+
+  if (Platform.isTesting) {
+    (console: any).disableYellowBox = true;
+  }
+
+  RCTLog.setWarningHandler((...args) => {
+    updateWarningMap.apply(null, args);
+  });
+}
+
+/**
+ * Simple function for formatting strings.
+ *
+ * Replaces placeholders with values passed as extra arguments
+ *
+ * @param {string} format the base string
+ * @param ...args the values to insert
+ * @return {string} the replaced string
+ */
+function sprintf(format, ...args) {
+  let index = 0;
+  return format.replace(/%s/g, match => args[index++]);
+}
+
+function updateWarningMap(...args): void {
+  if (console.disableYellowBox) {
+    return;
+  }
+
+  let warning;
+  if (typeof args[0] === 'string') {
+    const [format, ...formatArgs] = args;
+    const argCount = (format.match(/%s/g) || []).length;
+    warning = [
+      sprintf(format, ...formatArgs.slice(0, argCount).map(stringifySafe)),
+      ...formatArgs.slice(argCount).map(stringifySafe),
+    ].join(' ');
+  } else {
+    warning = args.map(stringifySafe).join(' ');
+  }
+
+  if (warning.startsWith('(ADVICE)')) {
+    return;
+  }
+
+  const warningInfo = _warningMap.get(warning);
+  if (warningInfo) {
+    warningInfo.count += 1;
+  } else {
+    const error: any = new Error();
+    error.framesToPop = 2;
+
+    _warningMap.set(warning, {
+      count: 1,
+      stacktrace: parseErrorStack(error),
+      symbolicated: false,
+    });
+  }
+
+  _warningEmitter.emit('warning', _warningMap);
+}
+
+function ensureSymbolicatedWarning(warning: string): void {
+  const prevWarningInfo = _warningMap.get(warning);
+  if (!prevWarningInfo || prevWarningInfo.symbolicated) {
+    return;
+  }
+  prevWarningInfo.symbolicated = true;
+
+  symbolicateStackTrace(prevWarningInfo.stacktrace).then(
+    stack => {
+      const nextWarningInfo = _warningMap.get(warning);
+      if (nextWarningInfo) {
+        nextWarningInfo.stacktrace = stack;
+        _warningEmitter.emit('warning', _warningMap);
+      }
+    },
+    error => {
+      const nextWarningInfo = _warningMap.get(warning);
+      if (nextWarningInfo) {
+        infoLog('Failed to symbolicate warning, "%s":', warning, error);
+        _warningEmitter.emit('warning', _warningMap);
+      }
+    },
+  );
+}
+
+function isWarningIgnored(warning: string): boolean {
+  const isIgnored = IGNORED_WARNINGS.some((ignoredWarning: string) =>
+    warning.startsWith(ignoredWarning),
+  );
+
+  if (isIgnored) {
+    return true;
+  }
+
+  // DEPRECATED
+  return (
+    Array.isArray(console.ignoredYellowBox) &&
+    console.ignoredYellowBox.some(ignorePrefix =>
+      warning.startsWith(String(ignorePrefix)),
+    )
+  );
+}
+
+const WarningRow = ({count, warning, onPress}) => {
+  const Text = require('Text');
+  const TouchableHighlight = require('TouchableHighlight');
+  const View = require('View');
+
+  const countText =
+    count > 1 ? (
+      <Text style={styles.listRowCount}>{'(' + count + ') '}</Text>
+    ) : null;
+
+  return (
+    <View style={styles.listRow}>
+      <TouchableHighlight
+        activeOpacity={0.5}
+        onPress={onPress}
+        style={styles.listRowContent}
+        underlayColor="transparent">
+        <Text style={styles.listRowText} numberOfLines={2}>
+          {countText}
+          {warning}
+        </Text>
+      </TouchableHighlight>
+    </View>
+  );
+};
+
+type StackRowProps = {frame: StackFrame};
+const StackRow = ({frame}: StackRowProps) => {
+  const Text = require('Text');
+  const TouchableHighlight = require('TouchableHighlight');
+  const {file, lineNumber} = frame;
+  let fileName;
+  if (file) {
+    const fileParts = file.split('/');
+    fileName = fileParts[fileParts.length - 1];
+  } else {
+    fileName = '<unknown file>';
+  }
+
+  return (
+    <TouchableHighlight
+      activeOpacity={0.5}
+      style={styles.openInEditorButton}
+      underlayColor="transparent"
+      onPress={openFileInEditor.bind(null, file, lineNumber)}>
+      <Text style={styles.inspectorCountText}>
+        {fileName}:{lineNumber}
+      </Text>
+    </TouchableHighlight>
+  );
+};
+
+const WarningInspector = ({
+  warningInfo,
+  warning,
+  stacktraceVisible,
+  onDismiss,
+  onDismissAll,
+  onMinimize,
+  toggleStacktrace,
+}) => {
+  const ScrollView = require('ScrollView');
+  const Text = require('Text');
+  const TouchableHighlight = require('TouchableHighlight');
+  const View = require('View');
+  const {count, stacktrace} = warningInfo || {};
+
+  const countSentence =
+    'Warning encountered ' + count + ' time' + (count - 1 ? 's' : '') + '.';
+
+  let stacktraceList;
+  if (stacktraceVisible && stacktrace) {
+    stacktraceList = (
+      <View style={styles.stacktraceList}>
+        {stacktrace.map((frame, ii) => <StackRow frame={frame} key={ii} />)}
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.inspector}>
+      <SafeAreaView style={styles.safeArea}>
+        <View style={styles.inspectorCount}>
+          <Text style={styles.inspectorCountText}>{countSentence}</Text>
+          <TouchableHighlight
+            onPress={toggleStacktrace}
+            underlayColor="transparent">
+            <Text style={styles.inspectorButtonText}>
+              {stacktraceVisible ? '\u{25BC}' : '\u{25B6}'} Stacktrace
+            </Text>
+          </TouchableHighlight>
+        </View>
+        <ScrollView style={styles.inspectorWarning}>
+          {stacktraceList}
+          <Text style={styles.inspectorWarningText}>{warning}</Text>
+        </ScrollView>
+        <View style={styles.inspectorButtons}>
+          <TouchableHighlight
+            activeOpacity={0.5}
+            onPress={onMinimize}
+            style={styles.inspectorButton}
+            underlayColor="transparent">
+            <Text style={styles.inspectorButtonText}>Minimize</Text>
+          </TouchableHighlight>
+          <TouchableHighlight
+            activeOpacity={0.5}
+            onPress={onDismiss}
+            style={styles.inspectorButton}
+            underlayColor="transparent">
+            <Text style={styles.inspectorButtonText}>Dismiss</Text>
+          </TouchableHighlight>
+          <TouchableHighlight
+            activeOpacity={0.5}
+            onPress={onDismissAll}
+            style={styles.inspectorButton}
+            underlayColor="transparent">
+            <Text style={styles.inspectorButtonText}>Dismiss All</Text>
+          </TouchableHighlight>
+        </View>
+      </SafeAreaView>
+    </View>
+  );
+};
+
+class YellowBox extends React.Component<
+  mixed,
+  {
+    stacktraceVisible: boolean,
+    inspecting: ?string,
+    warningMap: Map<any, any>,
+  },
+> {
+  _listener: ?EmitterSubscription;
+  dismissWarning: (warning: ?string) => void;
+
+  constructor(props: mixed, context: mixed) {
+    super(props, context);
+    this.state = {
+      inspecting: null,
+      stacktraceVisible: false,
+      warningMap: _warningMap,
+    };
+    this.dismissWarning = warning => {
+      const {inspecting, warningMap} = this.state;
+      if (warning) {
+        warningMap.delete(warning);
+      } else {
+        warningMap.clear();
+      }
+      this.setState({
+        inspecting: warning && inspecting !== warning ? inspecting : null,
+        warningMap,
+      });
+    };
+  }
+
+  static ignoreWarnings(warnings: Array<string>): void {
+    warnings.forEach((warning: string) => {
+      if (IGNORED_WARNINGS.indexOf(warning) === -1) {
+        IGNORED_WARNINGS.push(warning);
+      }
+    });
+  }
+
+  componentDidMount() {
+    let scheduled = null;
+    this._listener = _warningEmitter.addListener('warning', warningMap => {
+      // Use `setImmediate` because warnings often happen during render, but
+      // state cannot be set while rendering.
+      scheduled =
+        scheduled ||
+        setImmediate(() => {
+          scheduled = null;
+          this.setState({
+            warningMap,
+          });
+        });
+    });
+  }
+
+  componentDidUpdate() {
+    const {inspecting} = this.state;
+    if (inspecting != null) {
+      ensureSymbolicatedWarning(inspecting);
+    }
+  }
+
+  componentWillUnmount() {
+    if (this._listener) {
+      this._listener.remove();
+    }
+  }
+
+  render() {
+    if (console.disableYellowBox || this.state.warningMap.size === 0) {
+      return null;
+    }
+    const ScrollView = require('ScrollView');
+    const View = require('View');
+
+    const {inspecting, stacktraceVisible} = this.state;
+    const inspector =
+      inspecting !== null ? (
+        <WarningInspector
+          warningInfo={this.state.warningMap.get(inspecting)}
+          warning={inspecting}
+          stacktraceVisible={stacktraceVisible}
+          onDismiss={() => this.dismissWarning(inspecting)}
+          onDismissAll={() => this.dismissWarning(null)}
+          onMinimize={() => this.setState({inspecting: null})}
+          toggleStacktrace={() =>
+            this.setState({stacktraceVisible: !stacktraceVisible})
+          }
+        />
+      ) : null;
+
+    const rows = [];
+    this.state.warningMap.forEach((warningInfo, warning) => {
+      if (!isWarningIgnored(warning)) {
+        rows.push(
+          <WarningRow
+            key={warning}
+            count={warningInfo.count}
+            warning={warning}
+            onPress={() => this.setState({inspecting: warning})}
+            onDismiss={() => this.dismissWarning(warning)}
+          />,
+        );
+      }
+    });
+
+    const listStyle = [
+      styles.list,
+      // Additional `0.4` so the 5th row can peek into view.
+      {height: Math.min(rows.length, 4.4) * (rowGutter + rowHeight)},
+    ];
+    return (
+      <View style={inspector ? styles.fullScreen : listStyle}>
+        <ScrollView style={listStyle} scrollsToTop={false}>
+          {rows}
+        </ScrollView>
+        {inspector}
+      </View>
+    );
+  }
+}
+
+const backgroundColor = opacity => 'rgba(250, 186, 48, ' + opacity + ')';
+const textColor = 'white';
+const rowGutter = 1;
+const rowHeight = 46;
+
+// For unknown reasons, setting elevation: Number.MAX_VALUE causes remote debugging to
+// hang on iOS (some sort of overflow maybe). Setting it to Number.MAX_SAFE_INTEGER fixes the iOS issue, but since
+// elevation is an android-only style property we might as well remove it altogether for iOS.
+// See: https://github.com/facebook/react-native/issues/12223
+const elevation =
+  Platform.OS === 'android' ? Number.MAX_SAFE_INTEGER : undefined;
+
+var styles = StyleSheet.create({
+  fullScreen: {
+    height: '100%',
+    width: '100%',
+    elevation: elevation,
+    position: 'absolute',
+  },
+  inspector: {
+    backgroundColor: backgroundColor(0.95),
+    height: '100%',
+    paddingTop: 5,
+    elevation: elevation,
+  },
+  inspectorButtons: {
+    flexDirection: 'row',
+  },
+  inspectorButton: {
+    flex: 1,
+    paddingVertical: 22,
+    backgroundColor: backgroundColor(1),
+  },
+  safeArea: {
+    flex: 1,
+  },
+  stacktraceList: {
+    paddingBottom: 5,
+  },
+  inspectorButtonText: {
+    color: textColor,
+    fontSize: 14,
+    opacity: 0.8,
+    textAlign: 'center',
+  },
+  openInEditorButton: {
+    paddingTop: 5,
+    paddingBottom: 5,
+  },
+  inspectorCount: {
+    padding: 15,
+    paddingBottom: 0,
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+  },
+  inspectorCountText: {
+    color: textColor,
+    fontSize: 14,
+  },
+  inspectorWarning: {
+    flex: 1,
+    paddingHorizontal: 15,
+  },
+  inspectorWarningText: {
+    color: textColor,
+    fontSize: 16,
+    fontWeight: '600',
+  },
+  list: {
+    backgroundColor: 'transparent',
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    bottom: 0,
+    elevation: elevation,
+  },
+  listRow: {
+    backgroundColor: backgroundColor(0.95),
+    height: rowHeight,
+    marginTop: rowGutter,
+  },
+  listRowContent: {
+    flex: 1,
+  },
+  listRowCount: {
+    color: 'rgba(255, 255, 255, 0.5)',
+  },
+  listRowText: {
+    color: textColor,
+    position: 'absolute',
+    left: 0,
+    top: Platform.OS === 'android' ? 5 : 7,
+    marginLeft: 15,
+    marginRight: 15,
+  },
+});
+
+module.exports = YellowBox;

node_modules/react-native/Libraries/ReactNative/queryLayoutByID.js

@@ -0,0 +1,58 @@
+/**
+ * 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 queryLayoutByID
+ * @flow
+ * @format
+ */
+'use strict';
+
+var UIManager = require('UIManager');
+
+type OnSuccessCallback = (
+  left: number,
+  top: number,
+  width: number,
+  height: number,
+  pageX: number,
+  pageY: number,
+) => void;
+
+// I don't know what type error is...
+type OnErrorCallback = (error: any) => void;
+
+/**
+ * Queries the layout of a view. The layout does not reflect the element as
+ * seen by the user, rather it reflects the position within the layout system,
+ * before any transforms are applied.
+ *
+ * The only other requirement is that the `pageX, pageY` values be in the same
+ * coordinate system that events' `pageX/Y` are reported. That means that for
+ * the web, `pageXOffset/pageYOffset` should be added to to
+ * getBoundingClientRect to make consistent with touches.
+ *
+ *  var pageXOffset = window.pageXOffset;
+ *  var pageYOffset = window.pageYOffset;
+ *
+ * This is an IOS specific implementation.
+ *
+ * @param {number} tag ID of the platform specific node to be measured.
+ * @param {function} onError `func(error)`
+ * @param {function} onSuccess `func(left, top, width, height, pageX, pageY)`
+ */
+var queryLayoutByID = function(
+  tag: ?number,
+  onError: OnErrorCallback,
+  onSuccess: OnSuccessCallback,
+): void {
+  if (tag == null) {
+    return;
+  }
+  // Native bridge doesn't *yet* surface errors.
+  UIManager.measure(tag, onSuccess);
+};
+
+module.exports = queryLayoutByID;

node_modules/react-native/Libraries/ReactNative/renderApplication.js

@@ -0,0 +1,52 @@
+/**
+ * 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 renderApplication
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const AppContainer = require('AppContainer');
+const React = require('React');
+const ReactNative = require('ReactNative');
+
+const invariant = require('fbjs/lib/invariant');
+
+// require BackHandler so it sets the default handler that exits the app if no listeners respond
+require('BackHandler');
+
+function renderApplication<Props: Object>(
+  RootComponent: React.ComponentType<Props>,
+  initialProps: Props,
+  rootTag: any,
+  WrapperComponent?: ?React.ComponentType<*>,
+) {
+  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+
+  let renderable = (
+    <AppContainer rootTag={rootTag} WrapperComponent={WrapperComponent}>
+      <RootComponent {...initialProps} rootTag={rootTag} />
+    </AppContainer>
+  );
+
+  // If the root component is async, the user probably wants the initial render
+  // to be async also. To do this, wrap AppContainer with an async marker.
+  // For more info see https://fb.me/is-component-async
+  if (
+    RootComponent.prototype != null &&
+    RootComponent.prototype.unstable_isAsyncReactComponent === true
+  ) {
+    // $FlowFixMe This is not yet part of the official public API
+    const AsyncMode = React.unstable_AsyncMode;
+    renderable = <AsyncMode>{renderable}</AsyncMode>;
+  }
+
+  ReactNative.render(renderable, rootTag);
+}
+
+module.exports = renderApplication;

node_modules/react-native/Libraries/ReactNative/renderFabricSurface.js

@@ -0,0 +1,56 @@
+/**
+ * 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 renderFabricSurface
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const AppContainer = require('AppContainer');
+const React = require('React');
+const ReactFabric = require('ReactFabric');
+
+const invariant = require('fbjs/lib/invariant');
+
+// require BackHandler so it sets the default handler that exits the app if no listeners respond
+require('BackHandler');
+
+// Note: this is a fork of renderApplication.js to simply invoke ReactFabric.
+function renderFabricSurface<Props: Object>(
+  RootComponent: React.ComponentType<Props>,
+  initialProps: Props,
+  rootTag: any,
+  WrapperComponent?: ?React.ComponentType<*>,
+) {
+  invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+
+  let renderable = (
+    <AppContainer
+      fabric={true}
+      rootTag={rootTag}
+      WrapperComponent={WrapperComponent}>
+      <RootComponent {...initialProps} rootTag={rootTag} />
+    </AppContainer>
+  );
+
+  // If the root component is async, the user probably wants the initial render
+  // to be async also. To do this, wrap AppContainer with an async marker.
+  // For more info see https://fb.me/is-component-async
+  if (
+    RootComponent.prototype != null &&
+    RootComponent.prototype.unstable_isAsyncReactComponent === true
+  ) {
+    // $FlowFixMe This is not yet part of the official public API
+    const AsyncMode = React.unstable_AsyncMode;
+    renderable = <AsyncMode>{renderable}</AsyncMode>;
+  }
+
+  ReactFabric.render(renderable, rootTag);
+}
+
+module.exports = renderFabricSurface;

node_modules/react-native/Libraries/ReactNative/requireFabricComponent.js

@@ -0,0 +1,240 @@
+/**
+ * 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 requireFabricComponent
+ * @flow
+ * @format
+ */
+'use strict';
+
+const Platform = require('Platform');
+const {
+  ReactNativeBridgeEventPlugin,
+  createReactNativeComponentClass,
+} = require('ReactFabricInternals');
+const ReactNativeStyleAttributes = require('ReactNativeStyleAttributes');
+const UIManager = require('UIManager');
+
+const insetsDiffer = require('insetsDiffer');
+const matricesDiffer = require('matricesDiffer');
+const pointsDiffer = require('pointsDiffer');
+const processColor = require('processColor');
+const resolveAssetSource = require('resolveAssetSource');
+const sizesDiffer = require('sizesDiffer');
+const verifyPropTypes = require('verifyPropTypes');
+const invariant = require('fbjs/lib/invariant');
+const warning = require('fbjs/lib/warning');
+
+/**
+ * Used to create React components that directly wrap native component
+ * implementations.  Config information is extracted from data exported from the
+ * UIManager module.  You should also wrap the native component in a
+ * hand-written component with full propTypes definitions and other
+ * documentation - pass the hand-written component in as `componentInterface` to
+ * verify all the native props are documented via `propTypes`.
+ *
+ * If some native props shouldn't be exposed in the wrapper interface, you can
+ * pass null for `componentInterface` and call `verifyPropTypes` directly
+ * with `nativePropsToIgnore`;
+ *
+ * Common types are lined up with the appropriate prop differs with
+ * `TypeToDifferMap`.  Non-scalar types not in the map default to `deepDiffer`.
+ */
+import type {ComponentInterface} from 'verifyPropTypes';
+
+let hasAttachedDefaultEventTypes: boolean = false;
+
+function requireNativeComponent(
+  viewName: string,
+  componentInterface?: ?ComponentInterface,
+  extraConfig?: ?{nativeOnly?: Object},
+): React$ComponentType<any> | string {
+  function attachDefaultEventTypes(viewConfig: any) {
+    if (Platform.OS === 'android') {
+      // This is supported on Android platform only,
+      // as lazy view managers discovery is Android-specific.
+      if (UIManager.ViewManagerNames) {
+        // Lazy view managers enabled.
+        viewConfig = merge(viewConfig, UIManager.getDefaultEventTypes());
+      } else {
+        viewConfig.bubblingEventTypes = merge(
+          viewConfig.bubblingEventTypes,
+          UIManager.genericBubblingEventTypes,
+        );
+        viewConfig.directEventTypes = merge(
+          viewConfig.directEventTypes,
+          UIManager.genericDirectEventTypes,
+        );
+      }
+    }
+  }
+
+  function merge(destination: ?Object, source: ?Object): ?Object {
+    if (!source) {
+      return destination;
+    }
+    if (!destination) {
+      return source;
+    }
+
+    for (const key in source) {
+      if (!source.hasOwnProperty(key)) {
+        continue;
+      }
+
+      var sourceValue = source[key];
+      if (destination.hasOwnProperty(key)) {
+        const destinationValue = destination[key];
+        if (
+          typeof sourceValue === 'object' &&
+          typeof destinationValue === 'object'
+        ) {
+          sourceValue = merge(destinationValue, sourceValue);
+        }
+      }
+      destination[key] = sourceValue;
+    }
+    return destination;
+  }
+
+  // Don't load the ViewConfig from UIManager until it's needed for rendering.
+  // Lazy-loading this can help avoid Prepack deopts.
+  function getViewConfig() {
+    const viewConfig = UIManager[viewName];
+
+    invariant(
+      viewConfig != null && !viewConfig.NativeProps != null,
+      'Native component for "%s" does not exist',
+      viewName,
+    );
+
+    viewConfig.uiViewClassName = viewName;
+    viewConfig.validAttributes = {};
+
+    // ReactNative `View.propTypes` have been deprecated in favor of
+    // `ViewPropTypes`. In their place a temporary getter has been added with a
+    // deprecated warning message. Avoid triggering that warning here by using
+    // temporary workaround, __propTypesSecretDontUseThesePlease.
+    // TODO (bvaughn) Revert this particular change any time after April 1
+    if (componentInterface) {
+      viewConfig.propTypes =
+        typeof componentInterface.__propTypesSecretDontUseThesePlease ===
+        'object'
+          ? componentInterface.__propTypesSecretDontUseThesePlease
+          : componentInterface.propTypes;
+    } else {
+      viewConfig.propTypes = null;
+    }
+
+    let baseModuleName = viewConfig.baseModuleName;
+    let bubblingEventTypes = viewConfig.bubblingEventTypes;
+    let directEventTypes = viewConfig.directEventTypes;
+    let nativeProps = viewConfig.NativeProps;
+    while (baseModuleName) {
+      const baseModule = UIManager[baseModuleName];
+      if (!baseModule) {
+        warning(false, 'Base module "%s" does not exist', baseModuleName);
+        baseModuleName = null;
+      } else {
+        bubblingEventTypes = {
+          ...baseModule.bubblingEventTypes,
+          ...bubblingEventTypes,
+        };
+        directEventTypes = {
+          ...baseModule.directEventTypes,
+          ...directEventTypes,
+        };
+        nativeProps = {
+          ...baseModule.NativeProps,
+          ...nativeProps,
+        };
+        baseModuleName = baseModule.baseModuleName;
+      }
+    }
+
+    viewConfig.bubblingEventTypes = bubblingEventTypes;
+    viewConfig.directEventTypes = directEventTypes;
+
+    for (const key in nativeProps) {
+      let useAttribute = false;
+      const attribute = {};
+
+      const differ = TypeToDifferMap[nativeProps[key]];
+      if (differ) {
+        attribute.diff = differ;
+        useAttribute = true;
+      }
+
+      const processor = TypeToProcessorMap[nativeProps[key]];
+      if (processor) {
+        attribute.process = processor;
+        useAttribute = true;
+      }
+
+      viewConfig.validAttributes[key] = useAttribute ? attribute : true;
+    }
+
+    // Unfortunately, the current set up puts the style properties on the top
+    // level props object. We also need to add the nested form for API
+    // compatibility. This allows these props on both the top level and the
+    // nested style level. TODO: Move these to nested declarations on the
+    // native side.
+    viewConfig.validAttributes.style = ReactNativeStyleAttributes;
+
+    if (__DEV__) {
+      componentInterface &&
+        verifyPropTypes(
+          componentInterface,
+          viewConfig,
+          extraConfig && extraConfig.nativeOnly,
+        );
+    }
+
+    if (!hasAttachedDefaultEventTypes) {
+      attachDefaultEventTypes(viewConfig);
+      hasAttachedDefaultEventTypes = true;
+    }
+
+    // Register this view's event types with the ReactNative renderer.
+    // This enables view managers to be initialized lazily, improving perf,
+    // While also enabling 3rd party components to define custom event types.
+    ReactNativeBridgeEventPlugin.processEventTypes(viewConfig);
+
+    return viewConfig;
+  }
+
+  return createReactNativeComponentClass(viewName, getViewConfig);
+}
+
+const TypeToDifferMap = {
+  // iOS Types
+  CATransform3D: matricesDiffer,
+  CGPoint: pointsDiffer,
+  CGSize: sizesDiffer,
+  UIEdgeInsets: insetsDiffer,
+  // Android Types
+  // (not yet implemented)
+};
+
+function processColorArray(colors: ?Array<any>): ?Array<?number> {
+  return colors && colors.map(processColor);
+}
+
+const TypeToProcessorMap = {
+  // iOS Types
+  CGColor: processColor,
+  CGColorArray: processColorArray,
+  UIColor: processColor,
+  UIColorArray: processColorArray,
+  CGImage: resolveAssetSource,
+  UIImage: resolveAssetSource,
+  RCTImageSource: resolveAssetSource,
+  // Android Types
+  Color: processColor,
+  ColorArray: processColorArray,
+};
+
+module.exports = requireNativeComponent;

node_modules/react-native/Libraries/ReactNative/requireNativeComponent.js

@@ -0,0 +1,238 @@
+/**
+ * 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 requireNativeComponent
+ * @flow
+ * @format
+ */
+'use strict';
+
+const Platform = require('Platform');
+const ReactNativeBridgeEventPlugin = require('ReactNativeBridgeEventPlugin');
+const ReactNativeStyleAttributes = require('ReactNativeStyleAttributes');
+const UIManager = require('UIManager');
+
+const createReactNativeComponentClass = require('createReactNativeComponentClass');
+const insetsDiffer = require('insetsDiffer');
+const matricesDiffer = require('matricesDiffer');
+const pointsDiffer = require('pointsDiffer');
+const processColor = require('processColor');
+const resolveAssetSource = require('resolveAssetSource');
+const sizesDiffer = require('sizesDiffer');
+const verifyPropTypes = require('verifyPropTypes');
+const invariant = require('fbjs/lib/invariant');
+const warning = require('fbjs/lib/warning');
+
+/**
+ * Used to create React components that directly wrap native component
+ * implementations.  Config information is extracted from data exported from the
+ * UIManager module.  You should also wrap the native component in a
+ * hand-written component with full propTypes definitions and other
+ * documentation - pass the hand-written component in as `componentInterface` to
+ * verify all the native props are documented via `propTypes`.
+ *
+ * If some native props shouldn't be exposed in the wrapper interface, you can
+ * pass null for `componentInterface` and call `verifyPropTypes` directly
+ * with `nativePropsToIgnore`;
+ *
+ * Common types are lined up with the appropriate prop differs with
+ * `TypeToDifferMap`.  Non-scalar types not in the map default to `deepDiffer`.
+ */
+import type {ComponentInterface} from 'verifyPropTypes';
+
+let hasAttachedDefaultEventTypes: boolean = false;
+
+function requireNativeComponent(
+  viewName: string,
+  componentInterface?: ?ComponentInterface,
+  extraConfig?: ?{nativeOnly?: Object},
+): React$ComponentType<any> | string {
+  function attachDefaultEventTypes(viewConfig: any) {
+    if (Platform.OS === 'android') {
+      // This is supported on Android platform only,
+      // as lazy view managers discovery is Android-specific.
+      if (UIManager.ViewManagerNames) {
+        // Lazy view managers enabled.
+        viewConfig = merge(viewConfig, UIManager.getDefaultEventTypes());
+      } else {
+        viewConfig.bubblingEventTypes = merge(
+          viewConfig.bubblingEventTypes,
+          UIManager.genericBubblingEventTypes,
+        );
+        viewConfig.directEventTypes = merge(
+          viewConfig.directEventTypes,
+          UIManager.genericDirectEventTypes,
+        );
+      }
+    }
+  }
+
+  function merge(destination: ?Object, source: ?Object): ?Object {
+    if (!source) {
+      return destination;
+    }
+    if (!destination) {
+      return source;
+    }
+
+    for (const key in source) {
+      if (!source.hasOwnProperty(key)) {
+        continue;
+      }
+
+      var sourceValue = source[key];
+      if (destination.hasOwnProperty(key)) {
+        const destinationValue = destination[key];
+        if (
+          typeof sourceValue === 'object' &&
+          typeof destinationValue === 'object'
+        ) {
+          sourceValue = merge(destinationValue, sourceValue);
+        }
+      }
+      destination[key] = sourceValue;
+    }
+    return destination;
+  }
+
+  // Don't load the ViewConfig from UIManager until it's needed for rendering.
+  // Lazy-loading this can help avoid Prepack deopts.
+  function getViewConfig() {
+    const viewConfig = UIManager[viewName];
+
+    invariant(
+      viewConfig != null && !viewConfig.NativeProps != null,
+      'Native component for "%s" does not exist',
+      viewName,
+    );
+
+    viewConfig.uiViewClassName = viewName;
+    viewConfig.validAttributes = {};
+
+    // ReactNative `View.propTypes` have been deprecated in favor of
+    // `ViewPropTypes`. In their place a temporary getter has been added with a
+    // deprecated warning message. Avoid triggering that warning here by using
+    // temporary workaround, __propTypesSecretDontUseThesePlease.
+    // TODO (bvaughn) Revert this particular change any time after April 1
+    if (componentInterface) {
+      viewConfig.propTypes =
+        typeof componentInterface.__propTypesSecretDontUseThesePlease ===
+        'object'
+          ? componentInterface.__propTypesSecretDontUseThesePlease
+          : componentInterface.propTypes;
+    } else {
+      viewConfig.propTypes = null;
+    }
+
+    let baseModuleName = viewConfig.baseModuleName;
+    let bubblingEventTypes = viewConfig.bubblingEventTypes;
+    let directEventTypes = viewConfig.directEventTypes;
+    let nativeProps = viewConfig.NativeProps;
+    while (baseModuleName) {
+      const baseModule = UIManager[baseModuleName];
+      if (!baseModule) {
+        warning(false, 'Base module "%s" does not exist', baseModuleName);
+        baseModuleName = null;
+      } else {
+        bubblingEventTypes = {
+          ...baseModule.bubblingEventTypes,
+          ...bubblingEventTypes,
+        };
+        directEventTypes = {
+          ...baseModule.directEventTypes,
+          ...directEventTypes,
+        };
+        nativeProps = {
+          ...baseModule.NativeProps,
+          ...nativeProps,
+        };
+        baseModuleName = baseModule.baseModuleName;
+      }
+    }
+
+    viewConfig.bubblingEventTypes = bubblingEventTypes;
+    viewConfig.directEventTypes = directEventTypes;
+
+    for (const key in nativeProps) {
+      let useAttribute = false;
+      const attribute = {};
+
+      const differ = TypeToDifferMap[nativeProps[key]];
+      if (differ) {
+        attribute.diff = differ;
+        useAttribute = true;
+      }
+
+      const processor = TypeToProcessorMap[nativeProps[key]];
+      if (processor) {
+        attribute.process = processor;
+        useAttribute = true;
+      }
+
+      viewConfig.validAttributes[key] = useAttribute ? attribute : true;
+    }
+
+    // Unfortunately, the current set up puts the style properties on the top
+    // level props object. We also need to add the nested form for API
+    // compatibility. This allows these props on both the top level and the
+    // nested style level. TODO: Move these to nested declarations on the
+    // native side.
+    viewConfig.validAttributes.style = ReactNativeStyleAttributes;
+
+    if (__DEV__) {
+      componentInterface &&
+        verifyPropTypes(
+          componentInterface,
+          viewConfig,
+          extraConfig && extraConfig.nativeOnly,
+        );
+    }
+
+    if (!hasAttachedDefaultEventTypes) {
+      attachDefaultEventTypes(viewConfig);
+      hasAttachedDefaultEventTypes = true;
+    }
+
+    // Register this view's event types with the ReactNative renderer.
+    // This enables view managers to be initialized lazily, improving perf,
+    // While also enabling 3rd party components to define custom event types.
+    ReactNativeBridgeEventPlugin.processEventTypes(viewConfig);
+
+    return viewConfig;
+  }
+
+  return createReactNativeComponentClass(viewName, getViewConfig);
+}
+
+const TypeToDifferMap = {
+  // iOS Types
+  CATransform3D: matricesDiffer,
+  CGPoint: pointsDiffer,
+  CGSize: sizesDiffer,
+  UIEdgeInsets: insetsDiffer,
+  // Android Types
+  // (not yet implemented)
+};
+
+function processColorArray(colors: ?Array<any>): ?Array<?number> {
+  return colors && colors.map(processColor);
+}
+
+const TypeToProcessorMap = {
+  // iOS Types
+  CGColor: processColor,
+  CGColorArray: processColorArray,
+  UIColor: processColor,
+  UIColorArray: processColorArray,
+  CGImage: resolveAssetSource,
+  UIImage: resolveAssetSource,
+  RCTImageSource: resolveAssetSource,
+  // Android Types
+  Color: processColor,
+  ColorArray: processColorArray,
+};
+
+module.exports = requireNativeComponent;

node_modules/react-native/Libraries/ReactNative/verifyPropTypes.js

@@ -0,0 +1,86 @@
+/**
+ * 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 verifyPropTypes
+ * @flow
+ * @format
+ */
+'use strict';
+
+var ReactNativeStyleAttributes = require('ReactNativeStyleAttributes');
+
+export type ComponentInterface =
+  | React$ComponentType<any>
+  | {
+      name?: string,
+      displayName?: string,
+      propTypes?: Object,
+    };
+
+function verifyPropTypes(
+  componentInterface: ComponentInterface,
+  viewConfig: Object,
+  nativePropsToIgnore?: ?Object,
+) {
+  if (!viewConfig) {
+    return; // This happens for UnimplementedView.
+  }
+  var componentName =
+    componentInterface.displayName || componentInterface.name || 'unknown';
+
+  // ReactNative `View.propTypes` have been deprecated in favor of
+  // `ViewPropTypes`. In their place a temporary getter has been added with a
+  // deprecated warning message. Avoid triggering that warning here by using
+  // temporary workaround, __propTypesSecretDontUseThesePlease.
+  // TODO (bvaughn) Revert this particular change any time after April 1
+  var propTypes =
+    (componentInterface: any).__propTypesSecretDontUseThesePlease ||
+    componentInterface.propTypes;
+
+  if (!propTypes) {
+    return;
+  }
+
+  var nativeProps = viewConfig.NativeProps;
+  for (var prop in nativeProps) {
+    if (
+      !propTypes[prop] &&
+      !ReactNativeStyleAttributes[prop] &&
+      (!nativePropsToIgnore || !nativePropsToIgnore[prop])
+    ) {
+      var message;
+      if (propTypes.hasOwnProperty(prop)) {
+        message =
+          '`' +
+          componentName +
+          '` has incorrectly defined propType for native prop `' +
+          viewConfig.uiViewClassName +
+          '.' +
+          prop +
+          '` of native type `' +
+          nativeProps[prop];
+      } else {
+        message =
+          '`' +
+          componentName +
+          '` has no propType for native prop `' +
+          viewConfig.uiViewClassName +
+          '.' +
+          prop +
+          '` of native type `' +
+          nativeProps[prop] +
+          '`';
+      }
+      message +=
+        "\nIf you haven't changed this prop yourself, this usually means that " +
+        'your versions of the native code and JavaScript code are out of sync. Updating both ' +
+        'should make this error go away.';
+      throw new Error(message);
+    }
+  }
+}
+
+module.exports = verifyPropTypes;