react-native-tvos 0.73.7-1 → 0.74.0-0

package/Libraries/Components/Button.flow.js

@@ -1,265 +0,0 @@
-/**
- * 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
- * @flow
- * @generate-docs
- */
-
-'use strict';
-
-import type {PressEvent} from '../Types/CoreEventTypes';
-import type {
-  AccessibilityActionEvent,
-  AccessibilityActionInfo,
-  AccessibilityState,
-} from './View/ViewAccessibility';
-
-import {type ColorValue} from '../StyleSheet/StyleSheet';
-import * as React from 'react';
-
-type ButtonProps = $ReadOnly<{|
-  /**
-    Text to display inside the button. On Android the given title will be
-    converted to the uppercased form.
-   */
-  title: string,
-
-  /**
-    Handler to be called when the user taps the button. The first function
-    argument is an event in form of [PressEvent](pressevent).
-   */
-  onPress: (event?: PressEvent) => mixed,
-
-  /**
-    If `true`, doesn't play system sound on touch.
-
-    @platform android
-
-    @default false
-   */
-  touchSoundDisabled?: ?boolean,
-
-  /**
-    Color of the text (iOS), or background color of the button (Android).
-
-    @default {@platform android} '#2196F3'
-    @default {@platform ios} '#007AFF'
-   */
-  color?: ?ColorValue,
-
-  /**
-    TV preferred focus.
-
-    @platform tv
-
-    @default false
-   */
-  hasTVPreferredFocus?: ?boolean,
-
-  /**
-    Designates the next view to receive focus when the user navigates down. See
-    the [Android documentation][android:nextFocusDown].
-
-    [android:nextFocusDown]:
-    https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusDown
-
-    @platform android, tv
-   */
-  nextFocusDown?: ?number,
-
-  /**
-    Designates the next view to receive focus when the user navigates forward.
-    See the [Android documentation][android:nextFocusForward].
-
-    [android:nextFocusForward]:
-    https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusForward
-
-    @platform android, tv
-   */
-  nextFocusForward?: ?number,
-
-  /**
-    Designates the next view to receive focus when the user navigates left. See
-    the [Android documentation][android:nextFocusLeft].
-
-    [android:nextFocusLeft]:
-    https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusLeft
-
-    @platform android, tv
-   */
-  nextFocusLeft?: ?number,
-
-  /**
-    Designates the next view to receive focus when the user navigates right. See
-    the [Android documentation][android:nextFocusRight].
-
-    [android:nextFocusRight]:
-    https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusRight
-
-    @platform android, tv
-   */
-  nextFocusRight?: ?number,
-
-  /**
-    Designates the next view to receive focus when the user navigates up. See
-    the [Android documentation][android:nextFocusUp].
-
-    [android:nextFocusUp]:
-    https://developer.android.com/reference/android/view/View.html#attr_android:nextFocusUp
-
-    @platform android, tv
-   */
-  nextFocusUp?: ?number,
-
-  /**
-    Text to display for blindness accessibility features.
-   */
-  accessibilityLabel?: ?string,
-  /**
-   * Alias for accessibilityLabel  https://reactnative.dev/docs/view#accessibilitylabel
-   * https://github.com/facebook/react-native/issues/34424
-   */
-  'aria-label'?: ?string,
-  /**
-    If `true`, disable all interactions for this component.
-
-    @default false
-   */
-  disabled?: ?boolean,
-
-  /**
-    Used to locate this view in end-to-end tests.
-   */
-  testID?: ?string,
-
-  /**
-   * Accessibility props.
-   */
-  accessible?: ?boolean,
-  accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
-  onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
-  accessibilityState?: ?AccessibilityState,
-
-  /**
-   * [Android] Controlling if a view fires accessibility events and if it is reported to accessibility services.
-   */
-  importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
-  accessibilityHint?: ?string,
-  accessibilityLanguage?: ?Stringish,
-|}>;
-
-/**
-  A basic button component that should render nicely on any platform. Supports a
-  minimal level of customization.
-
-  If this button doesn't look right for your app, you can build your own button
-  using [TouchableOpacity](touchableopacity) or
-  [TouchableWithoutFeedback](touchablewithoutfeedback). For inspiration, look at
-  the [source code for this button component][button:source]. Or, take a look at
-  the [wide variety of button components built by the community]
-  [button:examples].
-
-  [button:source]:
-  https://github.com/facebook/react-native/blob/HEAD/Libraries/Components/Button.js
-
-  [button:examples]:
-  https://js.coach/?menu%5Bcollections%5D=React%20Native&page=1&query=button
-
-  ```jsx
-  <Button
-    onPress={onPressLearnMore}
-    title="Learn More"
-    color="#841584"
-    accessibilityLabel="Learn more about this purple button"
-  />
-  ```
-
-  ```SnackPlayer name=Button%20Example
-  import React from 'react';
-  import { StyleSheet, Button, View, SafeAreaView, Text, Alert } from 'react-native';
-
-  const Separator = () => (
-    <View style={styles.separator} />
-  );
-
-  const App = () => (
-    <SafeAreaView style={styles.container}>
-      <View>
-        <Text style={styles.title}>
-          The title and onPress handler are required. It is recommended to set accessibilityLabel to help make your app usable by everyone.
-        </Text>
-        <Button
-          title="Press me"
-          onPress={() => Alert.alert('Simple Button pressed')}
-        />
-      </View>
-      <Separator />
-      <View>
-        <Text style={styles.title}>
-          Adjust the color in a way that looks standard on each platform. On  iOS, the color prop controls the color of the text. On Android, the color adjusts the background color of the button.
-        </Text>
-        <Button
-          title="Press me"
-          color="#f194ff"
-          onPress={() => Alert.alert('Button with adjusted color pressed')}
-        />
-      </View>
-      <Separator />
-      <View>
-        <Text style={styles.title}>
-          All interaction for the component are disabled.
-        </Text>
-        <Button
-          title="Press me"
-          disabled
-          onPress={() => Alert.alert('Cannot press this one')}
-        />
-      </View>
-      <Separator />
-      <View>
-        <Text style={styles.title}>
-          This layout strategy lets the title define the width of the button.
-        </Text>
-        <View style={styles.fixToText}>
-          <Button
-            title="Left button"
-            onPress={() => Alert.alert('Left button pressed')}
-          />
-          <Button
-            title="Right button"
-            onPress={() => Alert.alert('Right button pressed')}
-          />
-        </View>
-      </View>
-    </SafeAreaView>
-  );
-
-  const styles = StyleSheet.create({
-    container: {
-      flex: 1,
-      justifyContent: 'center',
-      marginHorizontal: 16,
-    },
-    title: {
-      textAlign: 'center',
-      marginVertical: 8,
-    },
-    fixToText: {
-      flexDirection: 'row',
-      justifyContent: 'space-between',
-    },
-    separator: {
-      marginVertical: 8,
-      borderBottomColor: '#737373',
-      borderBottomWidth: StyleSheet.hairlineWidth,
-    },
-  });
-
-  export default App;
-  ```
- */
-export type Button = React.ComponentType<ButtonProps>;

package/Libraries/Components/ScrollView/ScrollViewViewConfig.js

@@ -1,86 +0,0 @@
-/**
- * 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
- */
-
-'use strict';
-
-import type {PartialViewConfig} from '../../Renderer/shims/ReactNativeTypes';
-
-const ScrollViewViewConfig = {
-  uiViewClassName: 'RCTScrollView',
-  bubblingEventTypes: {},
-  directEventTypes: {
-    topScrollToTop: {
-      registrationName: 'onScrollToTop',
-    },
-  },
-  validAttributes: {
-    alwaysBounceHorizontal: true,
-    alwaysBounceVertical: true,
-    automaticallyAdjustContentInsets: true,
-    automaticallyAdjustKeyboardInsets: true,
-    automaticallyAdjustsScrollIndicatorInsets: true,
-    bounces: true,
-    bouncesZoom: true,
-    canCancelContentTouches: true,
-    centerContent: true,
-    contentInset: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    contentOffset: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    contentInsetAdjustmentBehavior: true,
-    decelerationRate: true,
-    directionalLockEnabled: true,
-    disableIntervalMomentum: true,
-    endFillColor: {
-      process: require('../../StyleSheet/processColor').default,
-    },
-    fadingEdgeLength: true,
-    indicatorStyle: true,
-    inverted: true,
-    isInvertedVirtualizedList: true,
-    keyboardDismissMode: true,
-    maintainVisibleContentPosition: true,
-    maximumZoomScale: true,
-    minimumZoomScale: true,
-    nestedScrollEnabled: true,
-    onMomentumScrollBegin: true,
-    onMomentumScrollEnd: true,
-    onScroll: true,
-    onScrollBeginDrag: true,
-    onScrollEndDrag: true,
-    onScrollToTop: true,
-    overScrollMode: true,
-    pagingEnabled: true,
-    persistentScrollbar: true,
-    pinchGestureEnabled: true,
-    scrollEnabled: true,
-    scrollEventThrottle: true,
-    scrollIndicatorInsets: {
-      diff: require('../../Utilities/differ/pointsDiffer'),
-    },
-    scrollPerfTag: true,
-    scrollToOverflowEnabled: true,
-    scrollsToTop: true,
-    sendMomentumEvents: true,
-    showsHorizontalScrollIndicator: true,
-    showsScrollIndex: true,
-    showsVerticalScrollIndicator: true,
-    snapToAlignment: true,
-    snapToEnd: true,
-    snapToInterval: true,
-    snapToOffsets: true,
-    snapToStart: true,
-    zoomScale: true,
-  },
-};
-
-module.exports = (ScrollViewViewConfig: PartialViewConfig);

package/Libraries/Components/TV/NativeTVNavigationEventEmitter.js

@@ -1,24 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its 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
- */
-
-'use strict';
-
-import type {TurboModule} from '../../TurboModule/RCTExport';
-import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
-
-export interface Spec extends TurboModule {
-  +addListener: (eventName: string) => void;
-  +removeListeners: (count: number) => void;
-}
-
-export default (TurboModuleRegistry.get<Spec>(
-  'TVNavigationEventEmitter',
-): ?Spec);
-

package/Libraries/Components/Touchable/Touchable.flow.js

@@ -1,284 +0,0 @@
-/**
- * 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
- * @format
- */
-
-import type {EdgeInsetsProp} from '../../StyleSheet/EdgeInsetsPropType';
-import type {ColorValue} from '../../StyleSheet/StyleSheet';
-import type {PressEvent} from '../../Types/CoreEventTypes';
-
-import * as React from 'react';
-
-/**
- * `Touchable`: Taps done right.
- *
- * You hook your `ResponderEventPlugin` events into `Touchable`. `Touchable`
- * will measure time/geometry and tells you when to give feedback to the user.
- *
- * ====================== Touchable Tutorial ===============================
- * The `Touchable` mixin helps you handle the "press" interaction. It analyzes
- * the geometry of elements, and observes when another responder (scroll view
- * etc) has stolen the touch lock. It notifies your component when it should
- * give feedback to the user. (bouncing/highlighting/unhighlighting).
- *
- * - When a touch was activated (typically you highlight)
- * - When a touch was deactivated (typically you unhighlight)
- * - When a touch was "pressed" - a touch ended while still within the geometry
- *   of the element, and no other element (like scroller) has "stolen" touch
- *   lock ("responder") (Typically you bounce the element).
- *
- * A good tap interaction isn't as simple as you might think. There should be a
- * slight delay before showing a highlight when starting a touch. If a
- * subsequent touch move exceeds the boundary of the element, it should
- * unhighlight, but if that same touch is brought back within the boundary, it
- * should rehighlight again. A touch can move in and out of that boundary
- * several times, each time toggling highlighting, but a "press" is only
- * triggered if that touch ends while within the element's boundary and no
- * scroller (or anything else) has stolen the lock on touches.
- *
- * To create a new type of component that handles interaction using the
- * `Touchable` mixin, do the following:
- *
- * - Initialize the `Touchable` state.
- *
- *   getInitialState: function() {
- *     return merge(this.touchableGetInitialState(), yourComponentState);
- *   }
- *
- * - Choose the rendered component who's touches should start the interactive
- *   sequence. On that rendered node, forward all `Touchable` responder
- *   handlers. You can choose any rendered node you like. Choose a node whose
- *   hit target you'd like to instigate the interaction sequence:
- *
- *   // In render function:
- *   return (
- *     <View
- *       onStartShouldSetResponder={this.touchableHandleStartShouldSetResponder}
- *       onResponderTerminationRequest={this.touchableHandleResponderTerminationRequest}
- *       onResponderGrant={this.touchableHandleResponderGrant}
- *       onResponderMove={this.touchableHandleResponderMove}
- *       onResponderRelease={this.touchableHandleResponderRelease}
- *       onResponderTerminate={this.touchableHandleResponderTerminate}>
- *       <View>
- *         Even though the hit detection/interactions are triggered by the
- *         wrapping (typically larger) node, we usually end up implementing
- *         custom logic that highlights this inner one.
- *       </View>
- *     </View>
- *   );
- *
- * - You may set up your own handlers for each of these events, so long as you
- *   also invoke the `touchable*` handlers inside of your custom handler.
- *
- * - Implement the handlers on your component class in order to provide
- *   feedback to the user. See documentation for each of these class methods
- *   that you should implement.
- *
- *   touchableHandlePress: function() {
- *      this.performBounceAnimation();  // or whatever you want to do.
- *   },
- *   touchableHandleActivePressIn: function() {
- *     this.beginHighlighting(...);  // Whatever you like to convey activation
- *   },
- *   touchableHandleActivePressOut: function() {
- *     this.endHighlighting(...);  // Whatever you like to convey deactivation
- *   },
- *
- * - There are more advanced methods you can implement (see documentation below):
- *   touchableGetHighlightDelayMS: function() {
- *     return 20;
- *   }
- *   // In practice, *always* use a predeclared constant (conserve memory).
- *   touchableGetPressRectOffset: function() {
- *     return {top: 20, left: 20, right: 20, bottom: 100};
- *   }
- */
-
-/**
- * Touchable states.
- */
-
-const States = {
-  NOT_RESPONDER: 'NOT_RESPONDER', // Not the responder
-  RESPONDER_INACTIVE_PRESS_IN: 'RESPONDER_INACTIVE_PRESS_IN', // Responder, inactive, in the `PressRect`
-  RESPONDER_INACTIVE_PRESS_OUT: 'RESPONDER_INACTIVE_PRESS_OUT', // Responder, inactive, out of `PressRect`
-  RESPONDER_ACTIVE_PRESS_IN: 'RESPONDER_ACTIVE_PRESS_IN', // Responder, active, in the `PressRect`
-  RESPONDER_ACTIVE_PRESS_OUT: 'RESPONDER_ACTIVE_PRESS_OUT', // Responder, active, out of `PressRect`
-  RESPONDER_ACTIVE_LONG_PRESS_IN: 'RESPONDER_ACTIVE_LONG_PRESS_IN', // Responder, active, in the `PressRect`, after long press threshold
-  RESPONDER_ACTIVE_LONG_PRESS_OUT: 'RESPONDER_ACTIVE_LONG_PRESS_OUT', // Responder, active, out of `PressRect`, after long press threshold
-  ERROR: 'ERROR',
-};
-
-type State =
-  | typeof States.NOT_RESPONDER
-  | typeof States.RESPONDER_INACTIVE_PRESS_IN
-  | typeof States.RESPONDER_INACTIVE_PRESS_OUT
-  | typeof States.RESPONDER_ACTIVE_PRESS_IN
-  | typeof States.RESPONDER_ACTIVE_PRESS_OUT
-  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_IN
-  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_OUT
-  | typeof States.ERROR;
-
-/**
- * By convention, methods prefixed with underscores are meant to be @private,
- * and not @protected. Mixers shouldn't access them - not even to provide them
- * as callback handlers.
- *
- *
- * ========== Geometry =========
- * `Touchable` only assumes that there exists a `HitRect` node. The `PressRect`
- * is an abstract box that is extended beyond the `HitRect`.
- *
- *  +--------------------------+
- *  |                          | - "Start" events in `HitRect` cause `HitRect`
- *  |  +--------------------+  |   to become the responder.
- *  |  |  +--------------+  |  | - `HitRect` is typically expanded around
- *  |  |  |              |  |  |   the `VisualRect`, but shifted downward.
- *  |  |  |  VisualRect  |  |  | - After pressing down, after some delay,
- *  |  |  |              |  |  |   and before letting up, the Visual React
- *  |  |  +--------------+  |  |   will become "active". This makes it eligible
- *  |  |     HitRect        |  |   for being highlighted (so long as the
- *  |  +--------------------+  |   press remains in the `PressRect`).
- *  |        PressRect     o   |
- *  +----------------------|---+
- *           Out Region    |
- *                         +-----+ This gap between the `HitRect` and
- *                                 `PressRect` allows a touch to move far away
- *                                 from the original hit rect, and remain
- *                                 highlighted, and eligible for a "Press".
- *                                 Customize this via
- *                                 `touchableGetPressRectOffset()`.
- *
- *
- *
- * ======= State Machine =======
- *
- * +-------------+ <---+ RESPONDER_RELEASE
- * |NOT_RESPONDER|
- * +-------------+ <---+ RESPONDER_TERMINATED
- *     +
- *     | RESPONDER_GRANT (HitRect)
- *     v
- * +---------------------------+  DELAY   +-------------------------+  T + DELAY     +------------------------------+
- * |RESPONDER_INACTIVE_PRESS_IN|+-------->|RESPONDER_ACTIVE_PRESS_IN| +------------> |RESPONDER_ACTIVE_LONG_PRESS_IN|
- * +---------------------------+          +-------------------------+                +------------------------------+
- *     +            ^                         +           ^                                 +           ^
- *     |LEAVE_      |ENTER_                   |LEAVE_     |ENTER_                           |LEAVE_     |ENTER_
- *     |PRESS_RECT  |PRESS_RECT               |PRESS_RECT |PRESS_RECT                       |PRESS_RECT |PRESS_RECT
- *     |            |                         |           |                                 |           |
- *     v            +                         v           +                                 v           +
- * +----------------------------+  DELAY  +--------------------------+               +-------------------------------+
- * |RESPONDER_INACTIVE_PRESS_OUT|+------->|RESPONDER_ACTIVE_PRESS_OUT|               |RESPONDER_ACTIVE_LONG_PRESS_OUT|
- * +----------------------------+         +--------------------------+               +-------------------------------+
- *
- * T + DELAY => LONG_PRESS_DELAY_MS + DELAY
- *
- * Not drawn are the side effects of each transition. The most important side
- * effect is the `touchableHandlePress` abstract method invocation that occurs
- * when a responder is released while in either of the "Press" states.
- *
- * The other important side effects are the highlight abstract method
- * invocations (internal callbacks) to be implemented by the mixer.
- *
- *
- * @lends Touchable.prototype
- */
-interface TouchableMixinType {
-  /**
-   * Invoked when the item receives focus. Mixers might override this to
-   * visually distinguish the `VisualRect` so that the user knows that it
-   * currently has the focus. Most platforms only support a single element being
-   * focused at a time, in which case there may have been a previously focused
-   * element that was blurred just prior to this. This can be overridden when
-   * using `Touchable.Mixin.withoutDefaultFocusAndBlur`.
-   */
-  touchableHandleFocus: (e: Event) => void;
-
-  /**
-   * Invoked when the item loses focus. Mixers might override this to
-   * visually distinguish the `VisualRect` so that the user knows that it
-   * no longer has focus. Most platforms only support a single element being
-   * focused at a time, in which case the focus may have moved to another.
-   * This can be overridden when using
-   * `Touchable.Mixin.withoutDefaultFocusAndBlur`.
-   */
-  touchableHandleBlur: (e: Event) => void;
-
-  componentDidMount: () => void;
-
-  /**
-   * Clear all timeouts on unmount
-   */
-  componentWillUnmount: () => void;
-
-  /**
-   * It's prefer that mixins determine state in this way, having the class
-   * explicitly mix the state in the one and only `getInitialState` method.
-   *
-   * @return {object} State object to be placed inside of
-   * `this.state.touchable`.
-   */
-  touchableGetInitialState: () => {
-    touchable: {
-      touchState: ?State,
-      responderID: ?PressEvent['currentTarget'],
-    },
-  };
-
-  // ==== Hooks to Gesture Responder system ====
-  /**
-   * Must return true if embedded in a native platform scroll view.
-   */
-  touchableHandleResponderTerminationRequest: () => any;
-
-  /**
-   * Must return true to start the process of `Touchable`.
-   */
-  touchableHandleStartShouldSetResponder: () => any;
-
-  /**
-   * Return true to cancel press on long press.
-   */
-  touchableLongPressCancelsPress: () => boolean;
-
-  /**
-   * Place as callback for a DOM element's `onResponderGrant` event.
-   * @param {SyntheticEvent} e Synthetic event from event system.
-   *
-   */
-  touchableHandleResponderGrant: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderRelease` event.
-   */
-  touchableHandleResponderRelease: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderTerminate` event.
-   */
-  touchableHandleResponderTerminate: (e: PressEvent) => void;
-
-  /**
-   * Place as callback for a DOM element's `onResponderMove` event.
-   */
-  touchableHandleResponderMove: (e: PressEvent) => void;
-
-  withoutDefaultFocusAndBlur: {...};
-}
-
-export type TouchableType = {
-  Mixin: TouchableMixinType,
-  /**
-   * Renders a debugging overlay to visualize touch target with hitSlop (might not work on Android).
-   */
-  renderDebugView: ({
-    color: ColorValue,
-    hitSlop: EdgeInsetsProp,
-    ...
-  }) => null | React.Node,
-};