react-native-tvos 0.87.1-0 → 0.87.1-1

package/types_generated/Libraries/Interaction/PanResponder.d.ts

@@ -0,0 +1,234 @@
+/**
+ * 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<<024745c9b89bcc133029d932f2a194da>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Interaction/PanResponder.js
+ */
+
+import type { GestureResponderEvent } from "../Types/CoreEventTypes";
+export type PanResponderGestureState = {
+  /**
+   * ID of the gestureState - persisted as long as there at least one touch on screen
+   */
+  stateID: number;
+  /**
+   * The latest screen coordinates of the recently-moved touch
+   */
+  moveX: number;
+  /**
+   * The latest screen coordinates of the recently-moved touch
+   */
+  moveY: number;
+  /**
+   * The screen coordinates of the responder grant
+   */
+  x0: number;
+  /**
+   * The screen coordinates of the responder grant
+   */
+  y0: number;
+  /**
+   * Accumulated distance of the gesture since the touch started
+   */
+  dx: number;
+  /**
+   * Accumulated distance of the gesture since the touch started
+   */
+  dy: number;
+  /**
+   * Current velocity of the gesture
+   */
+  vx: number;
+  /**
+   * Current velocity of the gesture
+   */
+  vy: number;
+  /**
+   * Number of touches currently on screen
+   */
+  numberActiveTouches: number;
+};
+type ActiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => boolean;
+type PassiveCallback = (event: GestureResponderEvent, gestureState: PanResponderGestureState) => unknown;
+export type GestureResponderHandlerMethods = {
+  onMoveShouldSetResponder: (event: GestureResponderEvent) => boolean;
+  onMoveShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+  onResponderEnd: (event: GestureResponderEvent) => void;
+  onResponderGrant: (event: GestureResponderEvent) => boolean;
+  onResponderMove: (event: GestureResponderEvent) => void;
+  onResponderReject: (event: GestureResponderEvent) => void;
+  onResponderRelease: (event: GestureResponderEvent) => void;
+  onResponderStart: (event: GestureResponderEvent) => void;
+  onResponderTerminate: (event: GestureResponderEvent) => void;
+  onResponderTerminationRequest: (event: GestureResponderEvent) => boolean;
+  onStartShouldSetResponder: (event: GestureResponderEvent) => boolean;
+  onStartShouldSetResponderCapture: (event: GestureResponderEvent) => boolean;
+};
+export type PanResponderCallbacks = Readonly<{
+  onMoveShouldSetPanResponder?: ActiveCallback | undefined;
+  onMoveShouldSetPanResponderCapture?: ActiveCallback | undefined;
+  onStartShouldSetPanResponder?: ActiveCallback | undefined;
+  onStartShouldSetPanResponderCapture?: ActiveCallback | undefined;
+  /**
+   * The body of `onResponderGrant` returns a bool, but the vast majority of
+   * callsites return void and this TODO notice is found in it:
+   *   TODO: t7467124 investigate if this can be removed
+   */
+  onPanResponderGrant?: (PassiveCallback | ActiveCallback) | undefined;
+  onPanResponderReject?: PassiveCallback | undefined;
+  onPanResponderStart?: PassiveCallback | undefined;
+  onPanResponderEnd?: PassiveCallback | undefined;
+  onPanResponderRelease?: PassiveCallback | undefined;
+  onPanResponderMove?: PassiveCallback | undefined;
+  onPanResponderTerminate?: PassiveCallback | undefined;
+  onPanResponderTerminationRequest?: ActiveCallback | undefined;
+  onShouldBlockNativeResponder?: ActiveCallback | undefined;
+}>;
+declare const PanResponder: {
+  /**
+   * Create a `PanResponder` instance with a config of gesture callback
+   * handlers.
+   *
+   * @param {object} config Enhanced versions of all of the responder callbacks
+   * that provide not only the typical `ResponderSyntheticEvent`, but also the
+   * `PanResponder` gesture state.  Simply replace the word `Responder` with
+   * `PanResponder` in each of the typical `onResponder*` callbacks. For
+   * example, the `config` object looks like:
+   *
+   *  - `onMoveShouldSetPanResponder: (e, gestureState) => {...}`
+   *  - `onMoveShouldSetPanResponderCapture: (e, gestureState) => {...}`
+   *  - `onStartShouldSetPanResponder: (e, gestureState) => {...}`
+   *  - `onStartShouldSetPanResponderCapture: (e, gestureState) => {...}`
+   *  - `onPanResponderReject: (e, gestureState) => {...}`
+   *  - `onPanResponderGrant: (e, gestureState) => {...}`
+   *  - `onPanResponderStart: (e, gestureState) => {...}`
+   *  - `onPanResponderEnd: (e, gestureState) => {...}`
+   *  - `onPanResponderRelease: (e, gestureState) => {...}`
+   *  - `onPanResponderMove: (e, gestureState) => {...}`
+   *  - `onPanResponderTerminate: (e, gestureState) => {...}`
+   *  - `onPanResponderTerminationRequest: (e, gestureState) => {...}`
+   *  - `onShouldBlockNativeResponder: (e, gestureState) => {...}`
+   *
+   *  In general, for events that have capture equivalents, we update the
+   *  gestureState once in the capture phase and can use it in the bubble phase
+   *  as well.
+   *
+   *  Be careful with onStartShould* callbacks. They only reflect updated
+   *  `gestureState` for start/end events that bubble/capture to the Node.
+   *  Once the node is the responder, you can rely on every start/end event
+   *  being processed by the gesture and `gestureState` being updated
+   *  accordingly. (numberActiveTouches) may not be totally accurate unless you
+   *  are the responder.
+   */
+  create(config: PanResponderCallbacks): {
+    getInteractionHandle: () => number | undefined;
+    panHandlers: GestureResponderHandlerMethods;
+  };
+};
+export type PanResponderInstance = ReturnType<(typeof PanResponder)["create"]>;
+/**
+ * Reconciles several touches into a single gesture. Makes single-touch
+ * gestures resilient to extra touches and can recognize basic multi-touch
+ * gestures.
+ *
+ * It provides a predictable wrapper of the responder handlers provided by the
+ * [gesture responder system](docs/gesture-responder-system.html).
+ * For each handler, it provides a new `gestureState` object alongside the
+ * native event object:
+ *
+ * ```
+ * onPanResponderMove: (event, gestureState) => {}
+ * ```
+ *
+ * A native event is a synthetic touch event with the following form:
+ *
+ *  - `nativeEvent`
+ *      + `changedTouches` - Array of all touch events that have changed since the last event
+ *      + `identifier` - The ID of the touch
+ *      + `locationX` - The X position of the touch, relative to the element
+ *      + `locationY` - The Y position of the touch, relative to the element
+ *      + `pageX` - The X position of the touch, relative to the root element
+ *      + `pageY` - The Y position of the touch, relative to the root element
+ *      + `target` - The node id of the element receiving the touch event
+ *      + `timestamp` - A time identifier for the touch, useful for velocity calculation
+ *      + `touches` - Array of all current touches on the screen
+ *
+ * A `gestureState` object has the following:
+ *
+ *  - `stateID` - ID of the gestureState- persisted as long as there at least
+ *     one touch on screen
+ *  - `moveX` - the latest screen coordinates of the recently-moved touch
+ *  - `moveY` - the latest screen coordinates of the recently-moved touch
+ *  - `x0` - the screen coordinates of the responder grant
+ *  - `y0` - the screen coordinates of the responder grant
+ *  - `dx` - accumulated distance of the gesture since the touch started
+ *  - `dy` - accumulated distance of the gesture since the touch started
+ *  - `vx` - current velocity of the gesture
+ *  - `vy` - current velocity of the gesture
+ *  - `numberActiveTouches` - Number of touches currently on screen
+ *
+ * ### Basic Usage
+ *
+ * Example:
+ *
+ * ```tsx
+ *   componentWillMount: function() {
+ *     this._panResponder = PanResponder.create({
+ *       // Ask to be the responder:
+ *       onStartShouldSetPanResponder: (evt, gestureState) => true,
+ *       onStartShouldSetPanResponderCapture: (evt, gestureState) => true,
+ *       onMoveShouldSetPanResponder: (evt, gestureState) => true,
+ *       onMoveShouldSetPanResponderCapture: (evt, gestureState) => true,
+ *
+ *       onPanResponderGrant: (evt, gestureState) => {
+ *         // The gesture has started. Show visual feedback so the user knows
+ *         // what is happening!
+ *
+ *         // gestureState.d{x,y} will be set to zero now
+ *       },
+ *       onPanResponderMove: (evt, gestureState) => {
+ *         // The most recent move distance is gestureState.move{X,Y}
+ *
+ *         // The accumulated gesture distance since becoming responder is
+ *         // gestureState.d{x,y}
+ *       },
+ *       onPanResponderTerminationRequest: (evt, gestureState) => true,
+ *       onPanResponderRelease: (evt, gestureState) => {
+ *         // The user has released all touches while this view is the
+ *         // responder. This typically means a gesture has succeeded
+ *       },
+ *       onPanResponderTerminate: (evt, gestureState) => {
+ *         // Another component has become the responder, so this gesture
+ *         // should be cancelled
+ *       },
+ *       onShouldBlockNativeResponder: (evt, gestureState) => {
+ *         // Returns whether this component should block native components from becoming the JS
+ *         // responder. Returns true by default. Is currently only supported on android.
+ *         return true;
+ *       },
+ *     });
+ *   },
+ *
+ *   render: function() {
+ *     return (
+ *       <View {...this._panResponder.panHandlers} />
+ *     );
+ *   },
+ *
+ * ```
+ *
+ * ### Working Example
+ *
+ * To see it in action, try the
+ * [PanResponder example in RNTester](https://github.com/facebook/react-native/blob/HEAD/packages/rn-tester/js/examples/PanResponder/PanResponderExample.js)
+ *
+ * @see https://reactnative.dev/docs/panresponder
+ */
+declare const $$PanResponder: typeof PanResponder;
+declare type $$PanResponder = typeof $$PanResponder;
+export default $$PanResponder;

package/types_generated/Libraries/LayoutAnimation/LayoutAnimation.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 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<<4715d2a28e31147b787c6ae93773b238>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/LayoutAnimation/LayoutAnimation.js
+ */
+
+import type { LayoutAnimationConfig, LayoutAnimationProperty, LayoutAnimationType } from "../Renderer/shims/ReactNativeTypes";
+export type { LayoutAnimationType, LayoutAnimationProperty, LayoutAnimationAnimationConfig as LayoutAnimationAnim } from "../Renderer/shims/ReactNativeTypes";
+export type { LayoutAnimationConfig } from "../Renderer/shims/ReactNativeTypes";
+export type LayoutAnimationTypes = Readonly<{ [type in LayoutAnimationType]: type }>;
+export type LayoutAnimationProperties = Readonly<{ [prop in LayoutAnimationProperty]: prop }>;
+type OnAnimationDidEndCallback = () => void;
+type OnAnimationDidFailCallback = () => void;
+declare function setLayoutAnimationEnabled(value: boolean): void;
+/**
+ * Configures the next commit to be animated.
+ *
+ * onAnimationDidEnd is guaranteed to be called when the animation completes.
+ * onAnimationDidFail is *never* called in the classic, pre-Fabric renderer,
+ * and never has been. In the new renderer (Fabric) it is called only if configuration
+ * parsing fails.
+ */
+declare function configureNext(config: LayoutAnimationConfig, onAnimationDidEnd?: OnAnimationDidEndCallback, onAnimationDidFail?: OnAnimationDidFailCallback): void;
+declare function createLayoutAnimation(duration: number, type?: LayoutAnimationType, property?: LayoutAnimationProperty): LayoutAnimationConfig;
+declare const Presets: {
+  easeInEaseOut: LayoutAnimationConfig;
+  linear: LayoutAnimationConfig;
+  spring: LayoutAnimationConfig;
+};
+declare const LayoutAnimation: {
+  /**
+   * Schedule an animation for the next layout. Config includes duration,
+   * create/update/delete sub-configs.
+   *
+   * @param config Specifies animation properties:
+   *
+   *   - `duration` in milliseconds
+   *   - `create`, `AnimationConfig` for animating in new views
+   *   - `update`, `AnimationConfig` for animating views that have been updated
+   *
+   * @param onAnimationDidEnd Called when the animation finished.
+   * Only supported on iOS.
+   * @param onError Called on error. Only supported on iOS.
+   */
+  configureNext: typeof configureNext;
+  /**
+   * Helper that creates a config object for `configureNext`.
+   */
+  create: typeof createLayoutAnimation;
+  /**
+   * Enum of animation types (spring, linear, easeInEaseOut, easeIn, easeOut,
+   * keyboard).
+   */
+  Types: LayoutAnimationTypes;
+  /**
+   * Enum of layout properties to animate (opacity, scaleX, scaleY, scaleXY).
+   */
+  Properties: LayoutAnimationProperties;
+  checkConfig(...args: Array<unknown>): void;
+  /**
+   * Predefined configs (easeInEaseOut, linear, spring).
+   */
+  Presets: typeof Presets;
+  easeInEaseOut: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  linear: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  spring: (onAnimationDidEnd?: OnAnimationDidEndCallback) => void;
+  setEnabled: typeof setLayoutAnimationEnabled;
+};
+/**
+ * Automatically animates views to their new positions when the next layout
+ * happens. Call before updating state to animate the transition.
+ *
+ * Note that in order to get this to work on **Android** you need to set the following flags via `UIManager`:
+ *
+ *     UIManager.setLayoutAnimationEnabledExperimental && UIManager.setLayoutAnimationEnabledExperimental(true);
+ *
+ * @see https://reactnative.dev/docs/layoutanimation
+ */
+declare const $$LayoutAnimation: typeof LayoutAnimation;
+declare type $$LayoutAnimation = typeof $$LayoutAnimation;
+export default $$LayoutAnimation;

package/types_generated/Libraries/Linking/Linking.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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<<b8f320cb25e2a554df59f533e83264fc>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Linking/Linking.js
+ */
+
+import type { EventSubscription } from "../vendor/emitter/EventEmitter";
+import NativeEventEmitter from "../EventEmitter/NativeEventEmitter";
+type LinkingEventDefinitions = {
+  url: [{
+    url: string;
+  }];
+};
+declare class LinkingImpl extends NativeEventEmitter<LinkingEventDefinitions> {
+  constructor();
+  /**
+   * Listen for incoming URL changes.
+   */
+  addEventListener<K extends keyof LinkingEventDefinitions>(eventType: K, listener: (...$$REST$$: LinkingEventDefinitions[K]) => unknown): EventSubscription;
+  /**
+   * Open the given URL with any installed app that can handle it. This
+   * includes URLs such as locations (e.g. "geo:37.484847,-122.148386"),
+   * contacts, or any other URL that can be opened with installed apps.
+   *
+   * This method will fail if the system doesn't know how to open the
+   * specified URL. If you're passing in a non-http(s) URL, it's best to
+   * check `canOpenURL` first. For web URLs, the protocol ("http://",
+   * "https://") must be set accordingly.
+   */
+  openURL(url: string): Promise<void>;
+  /**
+   * Check whether an installed app can handle a given URL. For web URLs,
+   * the protocol ("http://", "https://") must be set accordingly. As of
+   * iOS 9, your app needs to provide the `LSApplicationQueriesSchemes`
+   * key inside Info.plist.
+   */
+  canOpenURL(url: string): Promise<boolean>;
+  /**
+   * Open the device Settings app and display the app’s custom settings, if
+   * it has any.
+   */
+  openSettings(): Promise<void>;
+  /**
+   * Get the URL that launched the app, or `null` if it was not launched from
+   * a link. To support deep linking on Android, see
+   * https://developer.android.com/training/app-indexing/deep-linking.html#handling-intents.
+   */
+  getInitialURL(): Promise<null | undefined | string>;
+  /**
+   * Launch an Android intent with optional extras. Useful for deep-linking
+   * to settings pages, opening an SMS app with a message draft in place,
+   * and more. See https://developer.android.com/reference/kotlin/android/content/Intent.
+   *
+   * @platform android
+   */
+  sendIntent(action: string, extras?: Array<{
+    key: string;
+    value: string | number | boolean;
+  }>): Promise<void>;
+}
+declare const Linking: LinkingImpl;
+/**
+ * General interface to interact with both incoming and outgoing app links,
+ * including deep links and universal links.
+ *
+ * @see https://reactnative.dev/docs/linking
+ */
+declare const $$Linking: typeof Linking;
+declare type $$Linking = typeof $$Linking;
+export default $$Linking;