initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/Components/Keyboard/Keyboard.js

@@ -0,0 +1,165 @@
+/**
+ * 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 Keyboard
+ * @flow
+ */
+'use strict';
+
+const LayoutAnimation = require('LayoutAnimation');
+const invariant = require('fbjs/lib/invariant');
+const NativeEventEmitter = require('NativeEventEmitter');
+const KeyboardObserver = require('NativeModules').KeyboardObserver;
+const dismissKeyboard = require('dismissKeyboard');
+const KeyboardEventEmitter = new NativeEventEmitter(KeyboardObserver);
+
+type KeyboardEventName =
+  | 'keyboardWillShow'
+  | 'keyboardDidShow'
+  | 'keyboardWillHide'
+  | 'keyboardDidHide'
+  | 'keyboardWillChangeFrame'
+  | 'keyboardDidChangeFrame';
+
+export type KeyboardEvent = {|
+  +duration?: number,
+  +easing?: string,
+  +endCoordinates: {|
+    +width: number,
+    +height: number,
+    +screenX: number,
+    +screenY: number,
+  |},
+|};
+
+type KeyboardEventListener = (e: KeyboardEvent) => void;
+
+// The following object exists for documentation purposes
+// Actual work happens in
+// https://github.com/facebook/react-native/blob/master/Libraries/EventEmitter/NativeEventEmitter.js
+
+/**
+ * `Keyboard` module to control keyboard events.
+ *
+ * ### Usage
+ *
+ * The Keyboard module allows you to listen for native events and react to them, as
+ * well as make changes to the keyboard, like dismissing it.
+ *
+ *```
+ * import React, { Component } from 'react';
+ * import { Keyboard, TextInput } from 'react-native';
+ *
+ * class Example extends Component {
+ *   componentWillMount () {
+ *     this.keyboardDidShowListener = Keyboard.addListener('keyboardDidShow', this._keyboardDidShow);
+ *     this.keyboardDidHideListener = Keyboard.addListener('keyboardDidHide', this._keyboardDidHide);
+ *   }
+ *
+ *   componentWillUnmount () {
+ *     this.keyboardDidShowListener.remove();
+ *     this.keyboardDidHideListener.remove();
+ *   }
+ *
+ *   _keyboardDidShow () {
+ *     alert('Keyboard Shown');
+ *   }
+ *
+ *   _keyboardDidHide () {
+ *     alert('Keyboard Hidden');
+ *   }
+ *
+ *   render() {
+ *     return (
+ *       <TextInput
+ *         onSubmitEditing={Keyboard.dismiss}
+ *       />
+ *     );
+ *   }
+ * }
+ *```
+ */
+
+let Keyboard = {
+  /**
+   * The `addListener` function connects a JavaScript function to an identified native
+   * keyboard notification event.
+   *
+   * This function then returns the reference to the listener.
+   *
+   * @param {string} eventName The `nativeEvent` is the string that identifies the event you're listening for.  This
+   *can be any of the following:
+   *
+   * - `keyboardWillShow`
+   * - `keyboardDidShow`
+   * - `keyboardWillHide`
+   * - `keyboardDidHide`
+   * - `keyboardWillChangeFrame`
+   * - `keyboardDidChangeFrame`
+   *
+   * Note that if you set `android:windowSoftInputMode` to `adjustResize`  or `adjustNothing`,
+   * only `keyboardDidShow` and `keyboardDidHide` events will be available on Android.
+   * `keyboardWillShow` as well as `keyboardWillHide` are generally not available on Android
+   * since there is no native corresponding event.
+   *
+   * @param {function} callback function to be called when the event fires.
+   */
+  addListener(eventName: KeyboardEventName, callback: KeyboardEventListener) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Removes a specific listener.
+   *
+   * @param {string} eventName The `nativeEvent` is the string that identifies the event you're listening for.
+   * @param {function} callback function to be called when the event fires.
+   */
+  removeListener(eventName: KeyboardEventName, callback: Function) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Removes all listeners for a specific event type.
+   *
+   * @param {string} eventType The native event string listeners are watching which will be removed.
+   */
+  removeAllListeners(eventName: KeyboardEventName) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Dismisses the active keyboard and removes focus.
+   */
+  dismiss() {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Useful for syncing TextInput (or other keyboard accessory view) size of
+   * position changes with keyboard movements.
+   */
+  scheduleLayoutAnimation(event: KeyboardEvent) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+};
+
+// Throw away the dummy object and reassign it to original module
+Keyboard = KeyboardEventEmitter;
+Keyboard.dismiss = dismissKeyboard;
+Keyboard.scheduleLayoutAnimation = function(event: KeyboardEvent) {
+  const {duration, easing} = event;
+  if (duration) {
+    LayoutAnimation.configureNext({
+      duration: duration,
+      update: {
+        duration: duration,
+        type: (easing && LayoutAnimation.Types[easing]) || 'keyboard',
+      },
+    });
+  }
+};
+
+module.exports = Keyboard;

node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js

@@ -0,0 +1,211 @@
+/**
+ * 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 KeyboardAvoidingView
+ * @flow
+ */
+'use strict';
+
+const createReactClass = require('create-react-class');
+const Keyboard = require('Keyboard');
+const LayoutAnimation = require('LayoutAnimation');
+const Platform = require('Platform');
+const PropTypes = require('prop-types');
+const React = require('React');
+/* $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 TimerMixin = require('react-timer-mixin');
+const View = require('View');
+const ViewPropTypes = require('ViewPropTypes');
+
+import type EmitterSubscription from 'EmitterSubscription';
+import type {ViewLayout, ViewLayoutEvent} from 'ViewPropTypes';
+
+type ScreenRect = {
+  screenX: number,
+  screenY: number,
+  width: number,
+  height: number,
+};
+type KeyboardChangeEvent = {
+  startCoordinates?: ScreenRect,
+  endCoordinates: ScreenRect,
+  duration?: number,
+  easing?: string,
+};
+
+const viewRef = 'VIEW';
+
+/**
+ * This is a component to solve the common problem of views that need to move out of the way of the virtual keyboard.
+ * It can automatically adjust either its height, position or bottom padding based on the position of the keyboard.
+ */
+const KeyboardAvoidingView = createReactClass({
+  displayName: 'KeyboardAvoidingView',
+  mixins: [TimerMixin],
+
+  propTypes: {
+    ...ViewPropTypes,
+    /**
+     * Specify how the `KeyboardAvoidingView` will react to the presence of
+     * the keyboard. It can adjust the height, position or bottom padding of the view
+     */
+    behavior: PropTypes.oneOf(['height', 'position', 'padding']),
+
+    /**
+     * The style of the content container(View) when behavior is 'position'.
+     */
+    contentContainerStyle: ViewPropTypes.style,
+
+    /**
+     * This is the distance between the top of the user screen and the react native view,
+     * may be non-zero in some use cases. The default value is 0.
+     */
+    keyboardVerticalOffset: PropTypes.number.isRequired,
+    /**
+    * This is to allow us to manually control which KAV shuld take effect when
+    * having more than one KAV at the same screen
+    */
+    enabled: PropTypes.bool.isRequired,
+  },
+
+  getDefaultProps() {
+    return {
+      enabled: true,
+      keyboardVerticalOffset: 0,
+    };
+  },
+
+  getInitialState() {
+    return {
+      bottom: 0,
+    };
+  },
+
+  subscriptions: ([]: Array<EmitterSubscription>),
+  frame: (null: ?ViewLayout),
+
+  _relativeKeyboardHeight(keyboardFrame: ScreenRect): number {
+    const frame = this.frame;
+    if (!frame || !keyboardFrame) {
+      return 0;
+    }
+
+    const keyboardY = keyboardFrame.screenY - this.props.keyboardVerticalOffset;
+
+    // Calculate the displacement needed for the view such that it
+    // no longer overlaps with the keyboard
+    return Math.max(frame.y + frame.height - keyboardY, 0);
+  },
+
+  _onKeyboardChange(event: ?KeyboardChangeEvent) {
+    if (!event) {
+      this.setState({bottom: 0});
+      return;
+    }
+
+    const {duration, easing, endCoordinates} = event;
+    const height = this._relativeKeyboardHeight(endCoordinates);
+
+    if (this.state.bottom === height) {
+      return;
+    }
+
+    if (duration && easing) {
+      LayoutAnimation.configureNext({
+        duration: duration,
+        update: {
+          duration: duration,
+          type: LayoutAnimation.Types[easing] || 'keyboard',
+        },
+      });
+    }
+    this.setState({bottom: height});
+  },
+
+  _onLayout(event: ViewLayoutEvent) {
+    this.frame = event.nativeEvent.layout;
+  },
+
+  UNSAFE_componentWillUpdate(nextProps: Object, nextState: Object, nextContext?: Object): void {
+    if (nextState.bottom === this.state.bottom &&
+        this.props.behavior === 'height' &&
+        nextProps.behavior === 'height') {
+      // If the component rerenders without an internal state change, e.g.
+      // triggered by parent component re-rendering, no need for bottom to change.
+      nextState.bottom = 0;
+    }
+  },
+
+  UNSAFE_componentWillMount() {
+    if (Platform.OS === 'ios') {
+      this.subscriptions = [
+        Keyboard.addListener('keyboardWillChangeFrame', this._onKeyboardChange),
+      ];
+    } else {
+      this.subscriptions = [
+        Keyboard.addListener('keyboardDidHide', this._onKeyboardChange),
+        Keyboard.addListener('keyboardDidShow', this._onKeyboardChange),
+      ];
+    }
+  },
+
+  componentWillUnmount() {
+    this.subscriptions.forEach((sub) => sub.remove());
+  },
+
+  render(): React.Element<any> {
+    // $FlowFixMe(>=0.41.0)
+    const {behavior, children, style, ...props} = this.props;
+    const bottomHeight = this.props.enabled ? this.state.bottom : 0;
+    switch (behavior) {
+      case 'height':
+        let heightStyle;
+        if (this.frame) {
+          // Note that we only apply a height change when there is keyboard present,
+          // i.e. this.state.bottom is greater than 0. If we remove that condition,
+          // this.frame.height will never go back to its original value.
+          // When height changes, we need to disable flex.
+          heightStyle = {height: this.frame.height - bottomHeight, flex: 0};
+        }
+        return (
+          <View ref={viewRef} style={[style, heightStyle]} onLayout={this._onLayout} {...props}>
+            {children}
+          </View>
+        );
+
+      case 'position':
+        const positionStyle = {bottom: bottomHeight};
+        const { contentContainerStyle } = this.props;
+
+        return (
+          <View ref={viewRef} style={style} onLayout={this._onLayout} {...props}>
+            <View style={[contentContainerStyle, positionStyle]}>
+              {children}
+            </View>
+          </View>
+        );
+
+      case 'padding':
+        const paddingStyle = {paddingBottom: bottomHeight};
+        return (
+          <View ref={viewRef} style={[style, paddingStyle]} onLayout={this._onLayout} {...props}>
+            {children}
+          </View>
+        );
+
+      default:
+        return (
+          <View ref={viewRef} onLayout={this._onLayout} style={style} {...props}>
+            {children}
+          </View>
+        );
+    }
+  },
+});
+
+module.exports = KeyboardAvoidingView;