first commit

node_modules/react-native/Libraries/Components/Keyboard/Keyboard.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import {NativeEventEmitter} from '../../EventEmitter/NativeEventEmitter';
+import {EmitterSubscription} from '../../vendor/emitter/EventEmitter';
+
+export type KeyboardEventName =
+  | 'keyboardWillShow'
+  | 'keyboardDidShow'
+  | 'keyboardWillHide'
+  | 'keyboardDidHide'
+  | 'keyboardWillChangeFrame'
+  | 'keyboardDidChangeFrame';
+
+export type KeyboardEventEasing =
+  | 'easeIn'
+  | 'easeInEaseOut'
+  | 'easeOut'
+  | 'linear'
+  | 'keyboard';
+
+type KeyboardMetrics = {
+  screenX: number;
+  screenY: number;
+  width: number;
+  height: number;
+};
+
+interface KeyboardEventIOS {
+  /**
+   * @platform ios
+   */
+  startCoordinates: KeyboardMetrics;
+  /**
+   * @platform ios
+   */
+  isEventFromThisApp: boolean;
+}
+
+export interface KeyboardEvent extends Partial<KeyboardEventIOS> {
+  /**
+   * Always set to 0 on Android.
+   */
+  duration: number;
+  /**
+   * Always set to "keyboard" on Android.
+   */
+  easing: KeyboardEventEasing;
+  endCoordinates: KeyboardMetrics;
+}
+
+type KeyboardEventListener = (event: KeyboardEvent) => void;
+
+export interface KeyboardStatic extends NativeEventEmitter {
+  /**
+   * Dismisses the active keyboard and removes focus.
+   */
+  dismiss: () => void;
+  /**
+   * The `addListener` function connects a JavaScript function to an identified native
+   * keyboard notification event.
+   *
+   * This function then returns the reference to the listener.
+   *
+   * {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.
+   *
+   * {function} callback function to be called when the event fires.
+   */
+  addListener: (
+    eventType: KeyboardEventName,
+    listener: KeyboardEventListener,
+  ) => EmitterSubscription;
+  /**
+   * Useful for syncing TextInput (or other keyboard accessory view) size of
+   * position changes with keyboard movements.
+   */
+  scheduleLayoutAnimation: (event: KeyboardEvent) => void;
+
+  /**
+   * Whether the keyboard is last known to be visible.
+   */
+  isVisible(): boolean;
+
+  /**
+   * Return the metrics of the soft-keyboard if visible.
+   */
+  metrics(): KeyboardMetrics | undefined;
+}
+
+export const Keyboard: KeyboardStatic;

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

@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {EventSubscription} from '../../vendor/emitter/EventEmitter';
+
+import NativeEventEmitter from '../../EventEmitter/NativeEventEmitter';
+import LayoutAnimation from '../../LayoutAnimation/LayoutAnimation';
+import dismissKeyboard from '../../Utilities/dismissKeyboard';
+import Platform from '../../Utilities/Platform';
+import NativeKeyboardObserver from './NativeKeyboardObserver';
+
+export type KeyboardEventName = $Keys<KeyboardEventDefinitions>;
+
+export type KeyboardEventEasing =
+  | 'easeIn'
+  | 'easeInEaseOut'
+  | 'easeOut'
+  | 'linear'
+  | 'keyboard';
+
+export type KeyboardMetrics = $ReadOnly<{
+  screenX: number,
+  screenY: number,
+  width: number,
+  height: number,
+}>;
+
+export type KeyboardEvent = AndroidKeyboardEvent | IOSKeyboardEvent;
+
+type BaseKeyboardEvent = {
+  duration: number,
+  easing: KeyboardEventEasing,
+  endCoordinates: KeyboardMetrics,
+};
+
+export type AndroidKeyboardEvent = $ReadOnly<{
+  ...BaseKeyboardEvent,
+  duration: 0,
+  easing: 'keyboard',
+}>;
+
+export type IOSKeyboardEvent = $ReadOnly<{
+  ...BaseKeyboardEvent,
+  startCoordinates: KeyboardMetrics,
+  isEventFromThisApp: boolean,
+}>;
+
+type KeyboardEventDefinitions = {
+  keyboardWillShow: [KeyboardEvent],
+  keyboardDidShow: [KeyboardEvent],
+  keyboardWillHide: [KeyboardEvent],
+  keyboardDidHide: [KeyboardEvent],
+  keyboardWillChangeFrame: [KeyboardEvent],
+  keyboardDidChangeFrame: [KeyboardEvent],
+};
+
+/**
+ * `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}
+ *       />
+ *     );
+ *   }
+ * }
+ *```
+ */
+
+class KeyboardImpl {
+  _currentlyShowing: ?KeyboardEvent;
+
+  _emitter: NativeEventEmitter<KeyboardEventDefinitions> =
+    new NativeEventEmitter(
+      // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+      // If you want to use the native module on other platforms, please remove this condition and test its behavior
+      Platform.OS !== 'ios' ? null : NativeKeyboardObserver,
+    );
+
+  constructor() {
+    this.addListener('keyboardDidShow', ev => {
+      this._currentlyShowing = ev;
+    });
+    this.addListener('keyboardDidHide', _ev => {
+      this._currentlyShowing = null;
+    });
+  }
+
+  /**
+   * 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`
+   *
+   * Android versions prior to API 30 rely on observing layout changes when
+   * `android:windowSoftInputMode` is set to `adjustResize` or `adjustPan`.
+   *
+   * `keyboardWillShow` as well as `keyboardWillHide` are not available on Android since there is
+   * no native corresponding event.
+   *
+   * @param {function} callback function to be called when the event fires.
+   */
+  addListener<K: $Keys<KeyboardEventDefinitions>>(
+    eventType: K,
+    listener: (...KeyboardEventDefinitions[K]) => mixed,
+    context?: mixed,
+  ): EventSubscription {
+    return this._emitter.addListener(eventType, listener);
+  }
+
+  /**
+   * Removes all listeners for a specific event type.
+   *
+   * @param {string} eventType The native event string listeners are watching which will be removed.
+   */
+  removeAllListeners<K: $Keys<KeyboardEventDefinitions>>(eventType: ?K): void {
+    this._emitter.removeAllListeners(eventType);
+  }
+
+  /**
+   * Dismisses the active keyboard and removes focus.
+   */
+  dismiss(): void {
+    dismissKeyboard();
+  }
+
+  /**
+   * Whether the keyboard is last known to be visible.
+   */
+  isVisible(): boolean {
+    return !!this._currentlyShowing;
+  }
+
+  /**
+   * Return the metrics of the soft-keyboard if visible.
+   */
+  metrics(): ?KeyboardMetrics {
+    return this._currentlyShowing?.endCoordinates;
+  }
+
+  /**
+   * Useful for syncing TextInput (or other keyboard accessory view) size of
+   * position changes with keyboard movements.
+   */
+  scheduleLayoutAnimation(event: KeyboardEvent): void {
+    const {duration, easing} = event;
+    if (duration != null && duration !== 0) {
+      LayoutAnimation.configureNext({
+        duration: duration,
+        update: {
+          duration: duration,
+          type: (easing != null && LayoutAnimation.Types[easing]) || 'keyboard',
+        },
+      });
+    }
+  }
+}
+
+const Keyboard: KeyboardImpl = new KeyboardImpl();
+
+export default Keyboard;

node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import type * as React from 'react';
+import {Constructor} from '../../../types/private/Utilities';
+import {TimerMixin} from '../../../types/private/TimerMixin';
+import {StyleProp} from '../../StyleSheet/StyleSheet';
+import {ViewStyle} from '../../StyleSheet/StyleSheetTypes';
+import {ViewProps} from '../View/ViewPropTypes';
+
+/**
+ * It 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 position or bottom padding based on the position of the keyboard.
+ */
+declare class KeyboardAvoidingViewComponent extends React.Component<KeyboardAvoidingViewProps> {}
+declare const KeyboardAvoidingViewBase: Constructor<TimerMixin> &
+  typeof KeyboardAvoidingViewComponent;
+export class KeyboardAvoidingView extends KeyboardAvoidingViewBase {}
+
+export interface KeyboardAvoidingViewProps extends ViewProps {
+  behavior?: 'height' | 'position' | 'padding' | undefined;
+
+  /**
+   * The style of the content container(View) when behavior is 'position'.
+   */
+  contentContainerStyle?: StyleProp<ViewStyle> | undefined;
+
+  /**
+   * This is the distance between the top of the user screen and the react native view,
+   * may be non-zero in some use cases.
+   */
+  keyboardVerticalOffset?: number | undefined;
+
+  /**
+   * Enables or disables the KeyboardAvoidingView.
+   *
+   * Default is true
+   */
+  enabled?: boolean | undefined;
+}

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

@@ -0,0 +1,300 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {
+  ViewLayout,
+  ViewLayoutEvent,
+  ViewProps,
+} from '../View/ViewPropTypes';
+import type {KeyboardEvent, KeyboardMetrics} from './Keyboard';
+
+import LayoutAnimation from '../../LayoutAnimation/LayoutAnimation';
+import StyleSheet from '../../StyleSheet/StyleSheet';
+import Platform from '../../Utilities/Platform';
+import {type EventSubscription} from '../../vendor/emitter/EventEmitter';
+import AccessibilityInfo from '../AccessibilityInfo/AccessibilityInfo';
+import View from '../View/View';
+import Keyboard from './Keyboard';
+import * as React from 'react';
+import {createRef} from 'react';
+
+export type KeyboardAvoidingViewProps = $ReadOnly<{
+  ...ViewProps,
+
+  /**
+   * Specify how to react to the presence of the keyboard.
+   */
+  behavior?: ?('height' | 'position' | 'padding'),
+
+  /**
+   * Style of the content container when `behavior` is 'position'.
+   */
+  contentContainerStyle?: ?ViewStyleProp,
+
+  /**
+   * Controls whether this `KeyboardAvoidingView` instance should take effect.
+   * This is useful when more than one is on the screen. Defaults to true.
+   */
+  enabled?: ?boolean,
+
+  /**
+   * Distance between the top of the user screen and the React Native view. This
+   * may be non-zero in some cases. Defaults to 0.
+   */
+  keyboardVerticalOffset?: number,
+}>;
+
+type KeyboardAvoidingViewState = {
+  bottom: number,
+};
+
+/**
+ * View that moves out of the way when the keyboard appears by automatically
+ * adjusting its height, position, or bottom padding.
+ */
+class KeyboardAvoidingView extends React.Component<
+  KeyboardAvoidingViewProps,
+  KeyboardAvoidingViewState,
+> {
+  _frame: ?ViewLayout = null;
+  _keyboardEvent: ?KeyboardEvent = null;
+  _subscriptions: Array<EventSubscription> = [];
+  viewRef: {current: React.ElementRef<typeof View> | null, ...};
+  _initialFrameHeight: number = 0;
+  _bottom: number = 0;
+
+  constructor(props: KeyboardAvoidingViewProps) {
+    super(props);
+    this.state = {bottom: 0};
+    this.viewRef = createRef();
+  }
+
+  async _relativeKeyboardHeight(
+    keyboardFrame: KeyboardMetrics,
+  ): Promise<number> {
+    const frame = this._frame;
+    if (!frame || !keyboardFrame) {
+      return 0;
+    }
+
+    // On iOS when Prefer Cross-Fade Transitions is enabled, the keyboard position
+    // & height is reported differently (0 instead of Y position value matching height of frame)
+    if (
+      Platform.OS === 'ios' &&
+      keyboardFrame.screenY === 0 &&
+      (await AccessibilityInfo.prefersCrossFadeTransitions())
+    ) {
+      return 0;
+    }
+
+    const keyboardY =
+      keyboardFrame.screenY - (this.props.keyboardVerticalOffset ?? 0);
+
+    if (this.props.behavior === 'height') {
+      return Math.max(
+        this.state.bottom + frame.y + frame.height - keyboardY,
+        0,
+      );
+    }
+
+    // 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: ?KeyboardEvent) => {
+    this._keyboardEvent = event;
+    // $FlowFixMe[unused-promise]
+    this._updateBottomIfNecessary();
+  };
+
+  _onKeyboardHide = (event: ?KeyboardEvent) => {
+    this._keyboardEvent = null;
+    // $FlowFixMe[unused-promise]
+    this._updateBottomIfNecessary();
+  };
+
+  _onLayout = async (event: ViewLayoutEvent) => {
+    event.persist();
+
+    const oldFrame = this._frame;
+    this._frame = event.nativeEvent.layout;
+    if (!this._initialFrameHeight) {
+      // save the initial frame height, before the keyboard is visible
+      this._initialFrameHeight = this._frame.height;
+    }
+
+    // update bottom height for the first time or when the height is changed
+    if (!oldFrame || oldFrame.height !== this._frame.height) {
+      await this._updateBottomIfNecessary();
+    }
+
+    if (this.props.onLayout) {
+      this.props.onLayout(event);
+    }
+  };
+
+  // Avoid unnecessary renders if the KeyboardAvoidingView is disabled.
+  _setBottom = (value: number) => {
+    const enabled = this.props.enabled ?? true;
+    this._bottom = value;
+    if (enabled) {
+      this.setState({bottom: value});
+    }
+  };
+
+  _updateBottomIfNecessary = async () => {
+    if (this._keyboardEvent == null) {
+      this._setBottom(0);
+      return;
+    }
+
+    const {duration, easing, endCoordinates} = this._keyboardEvent;
+    const height = await this._relativeKeyboardHeight(endCoordinates);
+
+    if (this._bottom === height) {
+      return;
+    }
+
+    this._setBottom(height);
+
+    const enabled = this.props.enabled ?? true;
+    if (enabled && duration && easing) {
+      LayoutAnimation.configureNext({
+        // We have to pass the duration equal to minimal accepted duration defined here: RCTLayoutAnimation.m
+        duration: duration > 10 ? duration : 10,
+        update: {
+          duration: duration > 10 ? duration : 10,
+          type: LayoutAnimation.Types[easing] || 'keyboard',
+        },
+      });
+    }
+  };
+
+  componentDidUpdate(
+    _: KeyboardAvoidingViewProps,
+    prevState: KeyboardAvoidingViewState,
+  ): void {
+    const enabled = this.props.enabled ?? true;
+    if (enabled && this._bottom !== prevState.bottom) {
+      this.setState({bottom: this._bottom});
+    }
+  }
+
+  componentDidMount(): void {
+    if (!Keyboard.isVisible()) {
+      this._keyboardEvent = null;
+      this._setBottom(0);
+    }
+
+    if (Platform.OS === 'ios') {
+      this._subscriptions = [
+        // When undocked, split or floating, iOS will emit
+        // UIKeyboardWillHideNotification notification.
+        // UIKeyboardWillChangeFrameNotification will be emitted before
+        // UIKeyboardWillHideNotification, so we need to listen to
+        // keyboardWillHide and keyboardWillShow instead of
+        // keyboardWillChangeFrame.
+        Keyboard.addListener('keyboardWillHide', this._onKeyboardHide),
+        Keyboard.addListener('keyboardWillShow', this._onKeyboardChange),
+      ];
+    } else {
+      this._subscriptions = [
+        Keyboard.addListener('keyboardDidHide', this._onKeyboardChange),
+        Keyboard.addListener('keyboardDidShow', this._onKeyboardChange),
+      ];
+    }
+  }
+
+  componentWillUnmount(): void {
+    this._subscriptions.forEach(subscription => {
+      subscription.remove();
+    });
+  }
+
+  render(): React.Node {
+    const {
+      behavior,
+      children,
+      contentContainerStyle,
+      enabled = true,
+      // eslint-disable-next-line no-unused-vars
+      keyboardVerticalOffset = 0,
+      style,
+      onLayout,
+      ...props
+    } = this.props;
+    const bottomHeight = enabled === true ? this.state.bottom : 0;
+    switch (behavior) {
+      case 'height':
+        let heightStyle;
+        if (this._frame != null && this.state.bottom > 0) {
+          // 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._initialFrameHeight - bottomHeight,
+            flex: 0,
+          };
+        }
+        return (
+          <View
+            ref={this.viewRef}
+            style={StyleSheet.compose(style, heightStyle)}
+            onLayout={this._onLayout}
+            {...props}>
+            {children}
+          </View>
+        );
+
+      case 'position':
+        return (
+          <View
+            ref={this.viewRef}
+            style={style}
+            onLayout={this._onLayout}
+            {...props}>
+            <View
+              style={StyleSheet.compose(contentContainerStyle, {
+                bottom: bottomHeight,
+              })}>
+              {children}
+            </View>
+          </View>
+        );
+
+      case 'padding':
+        return (
+          <View
+            ref={this.viewRef}
+            style={StyleSheet.compose(style, {paddingBottom: bottomHeight})}
+            onLayout={this._onLayout}
+            {...props}>
+            {children}
+          </View>
+        );
+
+      default:
+        return (
+          <View
+            ref={this.viewRef}
+            onLayout={this._onLayout}
+            style={style}
+            {...props}>
+            {children}
+          </View>
+        );
+    }
+  }
+}
+
+export default KeyboardAvoidingView;

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

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+export * from '../../../src/private/specs_DEPRECATED/modules/NativeKeyboardObserver';
+export {default} from '../../../src/private/specs_DEPRECATED/modules/NativeKeyboardObserver';