react-native-tvos 0.81.3-0 → 0.81.4-1

package/types_generated/Libraries/Components/TextInput/TextInputState.d.ts

@@ -1,54 +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.
- *
- * @generated SignedSource<<b569abc0d196e023c230a066a12fb982>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Components/TextInput/TextInputState.js
- */
-
-import type { HostInstance } from "../../../src/private/types/HostInstance";
-declare function currentlyFocusedInput(): null | undefined | HostInstance;
-/**
- * Returns the ID of the currently focused text field, if one exists
- * If no text field is focused it returns null
- */
-declare function currentlyFocusedField(): null | undefined | number;
-declare function focusInput(textField: null | undefined | HostInstance): void;
-declare function blurInput(textField: null | undefined | HostInstance): void;
-declare function focusField(textFieldID: null | undefined | number): void;
-declare function blurField(textFieldID: null | undefined | number): void;
-/**
- * @param {number} TextInputID id of the text field to focus
- * Focuses the specified text field
- * noop if the text field was already focused or if the field is not editable
- */
-declare function focusTextInput(textField: null | undefined | HostInstance): void;
-/**
- * @param {number} textFieldID id of the text field to unfocus
- * Unfocuses the specified text field
- * noop if it wasn't focused
- */
-declare function blurTextInput(textField: null | undefined | HostInstance): void;
-declare function registerInput(textField: HostInstance): void;
-declare function unregisterInput(textField: HostInstance): void;
-declare function isTextInput(textField: HostInstance): boolean;
-declare const TextInputState: {
-  currentlyFocusedInput: typeof currentlyFocusedInput;
-  focusInput: typeof focusInput;
-  blurInput: typeof blurInput;
-  currentlyFocusedField: typeof currentlyFocusedField;
-  focusField: typeof focusField;
-  blurField: typeof blurField;
-  focusTextInput: typeof focusTextInput;
-  blurTextInput: typeof blurTextInput;
-  registerInput: typeof registerInput;
-  unregisterInput: typeof unregisterInput;
-  isTextInput: typeof isTextInput;
-};
-declare const $$TextInputState: typeof TextInputState;
-declare type $$TextInputState = typeof $$TextInputState;
-export default $$TextInputState;

package/types_generated/Libraries/Components/ToastAndroid/ToastAndroid.d.ts

@@ -1,99 +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.
- *
- * @generated SignedSource<<2f7b484b159b00477b7f99abdbeaaacc>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Components/ToastAndroid/ToastAndroid.js.flow
- */
-
-/**
- * This exposes the native ToastAndroid module as a JS module. This has a function 'show'
- * which takes the following parameters:
- *
- * 1. String message: A string with the text to toast
- * 2. int duration: The duration of the toast. May be ToastAndroid.SHORT or ToastAndroid.LONG
- *
- * There is also a function `showWithGravity` to specify the layout gravity. May be
- * ToastAndroid.TOP, ToastAndroid.BOTTOM, ToastAndroid.CENTER
- *
- * **Note**: Starting from Android API level 30 (Android R) or higher, for apps targeting
- * that API level, setting toast gravity is a no-op for text toasts.
- * This means that in many cases `TOP`, `BOTTOM`, `CENTER`, or offsets may not have
- * any visible effect on actual toast positioning.
- *
- * Reference: https://developer.android.com/reference/android/widget/Toast#setGravity(int,%20int,%20int)
- */
-declare const ToastAndroid: {
-  /**
-   * Indicates a short duration on the screen.
-   *
-   * Value: 2000 milliseconds (2 seconds).
-   */
-  SHORT: number;
-  /**
-   * Indicates a long duration on the screen.
-   *
-   * Value: 3500 milliseconds (3.5 seconds).
-   */
-  LONG: number;
-  /**
-   * Indicates that the toast message should appear at the top of the screen.
-   *
-   * **Note**: On Android R or later, this may not have any visible effect.
-   */
-  TOP: number;
-  /**
-   * Indicates that the toast message should appear at the bottom of the screen.
-   *
-   * **Note**: On Android R or later, this may not have any visible effect.
-   */
-  BOTTOM: number;
-  /**
-   * Indicates that the toast message should appear at the center of the screen.
-   *
-   * **Note**: On Android R or later, this may not have any visible effect.
-   */
-  CENTER: number;
-  /**
-   * Display a toast message for a specified duration.
-   *
-   * @param message A string with the text to toast.
-   * @param duration The duration of the toast–either ToastAndroid.SHORT or ToastAndroid.LONG
-   */
-  show: (message: string, duration: number) => void;
-  /**
-   * Display a toast message for a specified duration with a given gravity.
-   *
-   * @param message A string with the text to display in the toast.
-   * @param duration The duration of the toast.
-   *                 May be `ToastAndroid.SHORT` or `ToastAndroid.LONG`.
-   * @param gravity Positioning on the screen, e.g.,
-   *                `ToastAndroid.TOP`, `ToastAndroid.BOTTOM`, or `ToastAndroid.CENTER`.
-   *
-   * **Note**: On Android R (API 30) or later (when targeting API 30+), this setting may
-   * not have any effect on text toast placement due to `setGravity` becoming a no-op.
-   */
-  showWithGravity: (message: string, duration: number, gravity: number) => void;
-  /**
-   * Display a toast message for a specified duration with a given gravity and custom offsets.
-   *
-   * @param message A string with the text to display in the toast.
-   * @param duration The duration of the toast.
-   *                 May be `ToastAndroid.SHORT` or `ToastAndroid.LONG`.
-   * @param gravity Positioning on the screen, e.g.,
-   *                `ToastAndroid.TOP`, `ToastAndroid.BOTTOM`, or `ToastAndroid.CENTER`.
-   * @param xOffset Horizontal offset from the given gravity.
-   * @param yOffset Vertical offset from the given gravity.
-   *
-   * **Note**: On Android R (API 30) or later (when targeting API 30+), setting gravity
-   * and offsets may not visibly affect the placement of text toasts.
-   */
-  showWithGravityAndOffset: (message: string, duration: number, gravity: number, xOffset: number, yOffset: number) => void;
-};
-declare const $$ToastAndroid: typeof ToastAndroid;
-declare type $$ToastAndroid = typeof $$ToastAndroid;
-export default $$ToastAndroid;

package/types_generated/Libraries/Components/Touchable/Touchable.d.ts

@@ -1,257 +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.
- *
- * @generated SignedSource<<1af44b16dca54d57161f4497cc56ef3e>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Components/Touchable/Touchable.js
- */
-
-import type { EdgeInsetsProp } from "../../StyleSheet/EdgeInsetsPropType";
-import type { ColorValue } from "../../StyleSheet/StyleSheet";
-import type { BlurEvent, FocusEvent, GestureResponderEvent } 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.
- */
-
-declare const States: {
-  NOT_RESPONDER: "NOT_RESPONDER";
-  RESPONDER_INACTIVE_PRESS_IN: "RESPONDER_INACTIVE_PRESS_IN";
-  RESPONDER_INACTIVE_PRESS_OUT: "RESPONDER_INACTIVE_PRESS_OUT";
-  RESPONDER_ACTIVE_PRESS_IN: "RESPONDER_ACTIVE_PRESS_IN";
-  RESPONDER_ACTIVE_PRESS_OUT: "RESPONDER_ACTIVE_PRESS_OUT";
-  RESPONDER_ACTIVE_LONG_PRESS_IN: "RESPONDER_ACTIVE_LONG_PRESS_IN";
-  RESPONDER_ACTIVE_LONG_PRESS_OUT: "RESPONDER_ACTIVE_LONG_PRESS_OUT";
-  ERROR: "ERROR";
-};
-type TouchableState = 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
- */
-declare const TouchableMixinImpl: {
-  /**
-   * 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: TouchableState | undefined;
-      responderID: GestureResponderEvent["currentTarget"] | undefined;
-    };
-  };
-  /**
-   * 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 {NativeSyntheticEvent} e Synthetic event from event system.
-   *
-   */
-  touchableHandleResponderGrant: (e: GestureResponderEvent) => void;
-  /**
-   * Place as callback for a DOM element's `onResponderRelease` event.
-   */
-  touchableHandleResponderRelease: (e: GestureResponderEvent) => void;
-  /**
-   * Place as callback for a DOM element's `onResponderTerminate` event.
-   */
-  touchableHandleResponderTerminate: (e: GestureResponderEvent) => void;
-  /**
-   * Place as callback for a DOM element's `onResponderMove` event.
-   */
-  touchableHandleResponderMove: (e: GestureResponderEvent) => void;
-  /**
-   * 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: FocusEvent) => 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: BlurEvent) => void;
-  withoutDefaultFocusAndBlur: {};
-};
-declare const TouchableImpl: {
-  Mixin: typeof TouchableMixinImpl;
-  /**
-   * Renders a debugging overlay to visualize touch target with hitSlop (might not work on Android).
-   */
-  renderDebugView: ($$PARAM_0$$: {
-    color: ColorValue;
-    hitSlop?: EdgeInsetsProp;
-  }) => null | React.ReactNode;
-};
-declare const $$Touchable: typeof TouchableImpl;
-declare type $$Touchable = typeof $$Touchable;
-export default $$Touchable;

package/types_generated/Libraries/Components/Touchable/TouchableHighlight.d.ts

@@ -1,71 +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.
- *
- * @generated SignedSource<<6dc38a5e12e1f4557de4fdac05cc9ca5>>
- *
- * This file was translated from Flow by scripts/build-types/index.js.
- * Original file: packages/react-native/Libraries/Components/Touchable/TouchableHighlight.js
- */
-
-import type { ColorValue } from "../../StyleSheet/StyleSheet";
-import type { TVParallaxPropertiesType } from "../TV/TVViewPropTypes";
-import type { TouchableWithoutFeedbackProps } from "./TouchableWithoutFeedback";
-import View from "../../Components/View/View";
-import { type ViewStyleProp } from "../../StyleSheet/StyleSheet";
-import * as React from "react";
-type AndroidProps = Readonly<{
-  nextFocusDown?: number | undefined;
-  nextFocusForward?: number | undefined;
-  nextFocusLeft?: number | undefined;
-  nextFocusRight?: number | undefined;
-  nextFocusUp?: number | undefined;
-}>;
-type IOSProps = Readonly<{
-  /**
-   * @deprecated Use `focusable` instead
-   */
-  hasTVPreferredFocus?: boolean | undefined;
-  isTVSelectable?: boolean | undefined;
-  tvParallaxProperties?: TVParallaxPropertiesType;
-  nextFocusDown?: number | undefined;
-  nextFocusForward?: number | undefined;
-  nextFocusLeft?: number | undefined;
-  nextFocusRight?: number | undefined;
-  nextFocusUp?: number | undefined;
-}>;
-type TouchableHighlightBaseProps = Readonly<{
-  /**
-   * Determines what the opacity of the wrapped view should be when touch is active.
-   */
-  activeOpacity?: number | undefined;
-  /**
-   * The color of the underlay that will show through when the touch is active.
-   */
-  underlayColor?: ColorValue | undefined;
-  /**
-   * @see https://reactnative.dev/docs/view#style
-   */
-  style?: ViewStyleProp | undefined;
-  /**
-   * Called immediately after the underlay is shown
-   */
-  onShowUnderlay?: (() => void) | undefined;
-  /**
-   * Called immediately after the underlay is hidden
-   */
-  onHideUnderlay?: (() => void) | undefined;
-  testOnly_pressed?: boolean | undefined;
-  hostRef?: React.Ref<React.ComponentRef<typeof View>>;
-}>;
-export type TouchableHighlightProps = Readonly<Omit<TouchableWithoutFeedbackProps, keyof AndroidProps | keyof IOSProps | keyof TouchableHighlightBaseProps | keyof {}> & Omit<AndroidProps, keyof IOSProps | keyof TouchableHighlightBaseProps | keyof {}> & Omit<IOSProps, keyof TouchableHighlightBaseProps | keyof {}> & Omit<TouchableHighlightBaseProps, keyof {}> & {}>;
-declare const TouchableHighlight: (props: Omit<Readonly<Omit<TouchableHighlightProps, "hostRef">>, keyof {
-  ref?: React.Ref<React.ComponentRef<typeof View>>;
-}> & {
-  ref?: React.Ref<React.ComponentRef<typeof View>>;
-}) => React.ReactNode;
-declare const $$TouchableHighlight: typeof TouchableHighlight;
-declare type $$TouchableHighlight = typeof $$TouchableHighlight;
-export default $$TouchableHighlight;