react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/types_generated/Libraries/PermissionsAndroid/PermissionsAndroid.d.ts

@@ -0,0 +1,139 @@
+/**
+ * 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<<691f77a6fe276e14f15dd37227eaf2ae>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/PermissionsAndroid/PermissionsAndroid.js
+ */
+
+export type Rationale = {
+  title: string;
+  message: string;
+  buttonPositive?: string | undefined;
+  buttonNegative?: string | undefined;
+  buttonNeutral?: string | undefined;
+};
+type PermissionsType = Readonly<{
+  READ_CALENDAR: "android.permission.READ_CALENDAR";
+  WRITE_CALENDAR: "android.permission.WRITE_CALENDAR";
+  CAMERA: "android.permission.CAMERA";
+  READ_CONTACTS: "android.permission.READ_CONTACTS";
+  WRITE_CONTACTS: "android.permission.WRITE_CONTACTS";
+  GET_ACCOUNTS: "android.permission.GET_ACCOUNTS";
+  ACCESS_FINE_LOCATION: "android.permission.ACCESS_FINE_LOCATION";
+  ACCESS_COARSE_LOCATION: "android.permission.ACCESS_COARSE_LOCATION";
+  ACCESS_BACKGROUND_LOCATION: "android.permission.ACCESS_BACKGROUND_LOCATION";
+  RECORD_AUDIO: "android.permission.RECORD_AUDIO";
+  READ_PHONE_STATE: "android.permission.READ_PHONE_STATE";
+  CALL_PHONE: "android.permission.CALL_PHONE";
+  READ_CALL_LOG: "android.permission.READ_CALL_LOG";
+  WRITE_CALL_LOG: "android.permission.WRITE_CALL_LOG";
+  ADD_VOICEMAIL: "com.android.voicemail.permission.ADD_VOICEMAIL";
+  READ_VOICEMAIL: "com.android.voicemail.permission.READ_VOICEMAIL";
+  WRITE_VOICEMAIL: "com.android.voicemail.permission.WRITE_VOICEMAIL";
+  USE_SIP: "android.permission.USE_SIP";
+  PROCESS_OUTGOING_CALLS: "android.permission.PROCESS_OUTGOING_CALLS";
+  BODY_SENSORS: "android.permission.BODY_SENSORS";
+  BODY_SENSORS_BACKGROUND: "android.permission.BODY_SENSORS_BACKGROUND";
+  SEND_SMS: "android.permission.SEND_SMS";
+  RECEIVE_SMS: "android.permission.RECEIVE_SMS";
+  READ_SMS: "android.permission.READ_SMS";
+  RECEIVE_WAP_PUSH: "android.permission.RECEIVE_WAP_PUSH";
+  RECEIVE_MMS: "android.permission.RECEIVE_MMS";
+  READ_EXTERNAL_STORAGE: "android.permission.READ_EXTERNAL_STORAGE";
+  READ_MEDIA_IMAGES: "android.permission.READ_MEDIA_IMAGES";
+  READ_MEDIA_VIDEO: "android.permission.READ_MEDIA_VIDEO";
+  READ_MEDIA_AUDIO: "android.permission.READ_MEDIA_AUDIO";
+  READ_MEDIA_VISUAL_USER_SELECTED: "android.permission.READ_MEDIA_VISUAL_USER_SELECTED";
+  WRITE_EXTERNAL_STORAGE: "android.permission.WRITE_EXTERNAL_STORAGE";
+  BLUETOOTH_CONNECT: "android.permission.BLUETOOTH_CONNECT";
+  BLUETOOTH_SCAN: "android.permission.BLUETOOTH_SCAN";
+  BLUETOOTH_ADVERTISE: "android.permission.BLUETOOTH_ADVERTISE";
+  ACCESS_MEDIA_LOCATION: "android.permission.ACCESS_MEDIA_LOCATION";
+  ACCEPT_HANDOVER: "android.permission.ACCEPT_HANDOVER";
+  ACTIVITY_RECOGNITION: "android.permission.ACTIVITY_RECOGNITION";
+  ANSWER_PHONE_CALLS: "android.permission.ANSWER_PHONE_CALLS";
+  READ_PHONE_NUMBERS: "android.permission.READ_PHONE_NUMBERS";
+  UWB_RANGING: "android.permission.UWB_RANGING";
+  POST_NOTIFICATIONS: "android.permission.POST_NOTIFICATIONS";
+  NEARBY_WIFI_DEVICES: "android.permission.NEARBY_WIFI_DEVICES";
+  ACCESS_LOCAL_NETWORK: "android.permission.ACCESS_LOCAL_NETWORK";
+}>;
+export type PermissionStatus = "granted" | "denied" | "never_ask_again";
+export type Permission = PermissionsType[keyof PermissionsType];
+declare class PermissionsAndroidImpl {
+  /**
+   * A list of specified "dangerous" permissions that require prompting the user.
+   */
+  PERMISSIONS: PermissionsType;
+  /**
+   * Possible results of a permission request.
+   */
+  RESULTS: Readonly<{
+    DENIED: "denied";
+    GRANTED: "granted";
+    NEVER_ASK_AGAIN: "never_ask_again";
+  }>;
+  /**
+   * DEPRECATED - use check
+   *
+   * Returns a promise resolving to a boolean value as to whether the specified
+   * permissions has been granted
+   *
+   * @deprecated
+   */
+  checkPermission(permission: Permission): Promise<boolean>;
+  /**
+   * Check whether the specified permission has been granted. Returns a
+   * `Promise` resolving to a boolean.
+   */
+  check(permission: Permission): Promise<boolean>;
+  /**
+   * DEPRECATED - use request
+   *
+   * Prompts the user to enable a permission and returns a promise resolving to a
+   * boolean value indicating whether the user allowed or denied the request
+   *
+   * If the optional rationale argument is included (which is an object with a
+   * `title` and `message`), this function checks with the OS whether it is
+   * necessary to show a dialog explaining why the permission is needed
+   * (https://developer.android.com/training/permissions/requesting#explain)
+   * and then shows the system permission dialog
+   *
+   * @deprecated
+   */
+  requestPermission(permission: Permission, rationale?: Rationale): Promise<boolean>;
+  /**
+   * Prompt the user to enable a permission. Returns a `Promise` resolving to a
+   * `PermissionStatus` string indicating whether the user allowed or denied the
+   * request.
+   *
+   * If the optional `rationale` argument is provided, this function first
+   * checks with the OS whether it is necessary to show an explanatory dialog
+   * before presenting the system permission prompt.
+   */
+  request(permission: Permission, rationale?: Rationale): Promise<PermissionStatus>;
+  /**
+   * Prompt the user to enable multiple permissions in a single dialog. Returns
+   * a `Promise` resolving to an object mapping each requested permission to its
+   * `PermissionStatus`.
+   */
+  requestMultiple(permissions: Array<Permission>): Promise<{ [permission in Permission]: PermissionStatus }>;
+}
+declare const PermissionsAndroidInstance: PermissionsAndroidImpl;
+/**
+ * Provides access to Android M's (API 23+) permissions model. Handles prompts
+ * for "dangerous" permissions that require explicit user approval. On devices
+ * before SDK 23, permissions are automatically granted if listed in the
+ * manifest.
+ *
+ * @see https://reactnative.dev/docs/permissionsandroid
+ * @platform android
+ */
+declare const $$PermissionsAndroid: typeof PermissionsAndroidInstance;
+declare type $$PermissionsAndroid = typeof $$PermissionsAndroid;
+export default $$PermissionsAndroid;

package/types_generated/Libraries/Pressability/Pressability.d.ts

@@ -0,0 +1,241 @@
+/**
+ * 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<<05ea5170fb5ed65dcc127c92c932863a>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Pressability/Pressability.js
+ */
+
+import type { BlurEvent, FocusEvent, GestureResponderEvent, MouseEvent } from "../Types/CoreEventTypes";
+import { type RectOrSize } from "../StyleSheet/Rect";
+import { type PointerEvent } from "../Types/CoreEventTypes";
+export type PressabilityConfig = Readonly<{
+  /**
+   * Whether a press gesture can be interrupted by a parent gesture such as a
+   * scroll event. Defaults to true.
+   */
+  cancelable?: boolean | undefined;
+  /**
+   * Whether to disable initialization of the press gesture.
+   */
+  disabled?: boolean | undefined;
+  /**
+   * Amount to extend the `VisualRect` by to create `HitRect`.
+   */
+  hitSlop?: RectOrSize | undefined;
+  /**
+   * Amount to extend the `HitRect` by to create `PressRect`.
+   */
+  pressRectOffset?: RectOrSize | undefined;
+  /**
+   * Whether to disable the systemm sound when `onPress` fires on Android.
+   **/
+  android_disableSound?: boolean | undefined;
+  /**
+   * Duration to wait after hover in before calling `onHoverIn`.
+   */
+  delayHoverIn?: number | undefined;
+  /**
+   * Duration to wait after hover out before calling `onHoverOut`.
+   */
+  delayHoverOut?: number | undefined;
+  /**
+   * Duration (in addition to `delayPressIn`) after which a press gesture is
+   * considered a long press gesture. Defaults to 500 (milliseconds).
+   */
+  delayLongPress?: number | undefined;
+  /**
+   * Duration to wait after press down before calling `onPressIn`.
+   */
+  delayPressIn?: number | undefined;
+  /**
+   * Duration to wait after letting up before calling `onPressOut`.
+   */
+  delayPressOut?: number | undefined;
+  /**
+   * Minimum duration to wait between calling `onPressIn` and `onPressOut`.
+   */
+  minPressDuration?: number | undefined;
+  /**
+   * Called after the element loses focus.
+   */
+  onBlur?: ((event: BlurEvent) => unknown) | undefined;
+  /**
+   * Called after the element is focused.
+   */
+  onFocus?: ((event: FocusEvent) => unknown) | undefined;
+  /**
+   * Called when the hover is activated to provide visual feedback.
+   */
+  onHoverIn?: ((event: MouseEvent) => unknown) | undefined;
+  /**
+   * Called when the hover is deactivated to undo visual feedback.
+   */
+  onHoverOut?: ((event: MouseEvent) => unknown) | undefined;
+  /**
+   * Called when a long press gesture has been triggered.
+   */
+  onLongPress?: ((event: GestureResponderEvent) => unknown) | undefined;
+  /**
+   * Called when a press gesture has been triggered.
+   */
+  onPress?: ((event: GestureResponderEvent) => unknown) | undefined;
+  /**
+   * Called when the press is activated to provide visual feedback.
+   */
+  onPressIn?: ((event: GestureResponderEvent) => unknown) | undefined;
+  /**
+   * Called when the press location moves. (This should rarely be used.)
+   */
+  onPressMove?: ((event: GestureResponderEvent) => unknown) | undefined;
+  /**
+   * Called when the press is deactivated to undo visual feedback.
+   */
+  onPressOut?: ((event: GestureResponderEvent) => unknown) | undefined;
+  /**
+   * Called when a TV event is passed to the config.
+   */
+  onTVEvent?: ((event: any) => void) | undefined;
+  /**
+   * Whether to prevent any other native components from becoming responder
+   * while this pressable is responder.
+   */
+  blockNativeResponder?: boolean | undefined;
+}>;
+export type EventHandlers = Readonly<{
+  onBlur: (event: BlurEvent) => void;
+  onClick: (event: GestureResponderEvent) => void;
+  onFocus: (event: FocusEvent) => void;
+  onMouseEnter?: ((event: MouseEvent) => void) | undefined;
+  onMouseLeave?: ((event: MouseEvent) => void) | undefined;
+  onPointerEnter?: ((event: PointerEvent) => void) | undefined;
+  onPointerLeave?: ((event: PointerEvent) => void) | undefined;
+  onResponderGrant: (event: GestureResponderEvent) => void | boolean;
+  onResponderMove: (event: GestureResponderEvent) => void;
+  onResponderRelease: (event: GestureResponderEvent) => void;
+  onResponderTerminate: (event: GestureResponderEvent) => void;
+  onResponderTerminationRequest: () => boolean;
+  onStartShouldSetResponder: () => boolean;
+  onPressIn: (event: any) => void;
+  onPressOut: (event: any) => void;
+}>;
+/**
+ * Pressability implements press handling capabilities.
+ *
+ * =========================== Pressability Tutorial ===========================
+ *
+ * The `Pressability` class helps you create press interactions by analyzing the
+ * geometry of elements and observing when another responder (e.g. ScrollView)
+ * has stolen the touch lock. It offers hooks for your component to provide
+ * interaction feedback to the user:
+ *
+ * - When a press has activated (e.g. highlight an element)
+ * - When a press has deactivated (e.g. un-highlight an element)
+ * - When a press should trigger an action, meaning it activated and deactivated
+ *   while within the geometry of the element without the lock being stolen.
+ *
+ * A high quality interaction isn't as simple as you might think. There should
+ * be a slight delay before activation. Moving your finger beyond an element's
+ * bounds should trigger deactivation, but moving the same finger back within an
+ * element's bounds should trigger reactivation.
+ *
+ * This should be consumed by functional components using `usePressability`. The
+ * following steps are only relevant for using `Pressability` in classes:
+ *
+ * 1. Instantiate `Pressability` and store it on your component's state.
+ *
+ *    state = {
+ *      pressability: new Pressability({
+ *        // ...
+ *      }),
+ *    };
+ *
+ * 2. Choose the rendered component who should collect the press events. On that
+ *    element, spread `pressability.getEventHandlers()` into its props.
+ *
+ *    return (
+ *      <View {...this.state.pressability.getEventHandlers()} />
+ *    );
+ *
+ * 3. Update `Pressability` when your component mounts, updates, and unmounts.
+ *
+ *    componentDidMount() {
+ *      this.state.pressability.configure(...);
+ *    }
+ *
+ *    componentDidUpdate() {
+ *      this.state.pressability.configure(...);
+ *    }
+ *
+ *    componentWillUnmount() {
+ *      this.state.pressability.reset();
+ *    }
+ *
+ * ==================== Pressability Implementation Details ====================
+ *
+ * `Pressability` only assumes that there exists a `HitRect` node. The `PressRect`
+ * is an abstract box that is extended beyond the `HitRect`.
+ *
+ * # Geometry
+ *
+ *  ┌────────────────────────┐
+ *  │  ┌──────────────────┐  │ - Presses start anywhere within `HitRect`, which
+ *  │  │  ┌────────────┐  │  │   is expanded via the prop `hitSlop`.
+ *  │  │  │ VisualRect │  │  │
+ *  │  │  └────────────┘  │  │ - When pressed down for sufficient amount of time
+ *  │  │    HitRect       │  │   before letting up, `VisualRect` activates for
+ *  │  └──────────────────┘  │   as long as the press stays within `PressRect`.
+ *  │       PressRect    o   │
+ *  └────────────────────│───┘
+ *          Out Region   └────── `PressRect`, which is expanded via the prop
+ *                               `pressRectOffset`, allows presses to move
+ *                               beyond `HitRect` while maintaining activation
+ *                               and being eligible for a "press".
+ *
+ * # State Machine
+ *
+ * ┌───────────────┐ ◀──── RESPONDER_RELEASE
+ * │ NOT_RESPONDER │
+ * └───┬───────────┘ ◀──── RESPONDER_TERMINATED
+ *     │
+ *     │ RESPONDER_GRANT (HitRect)
+ *     │
+ *     ▼
+ * ┌─────────────────────┐          ┌───────────────────┐              ┌───────────────────┐
+ * │ RESPONDER_INACTIVE_ │  DELAY   │ RESPONDER_ACTIVE_ │  T + DELAY   │ RESPONDER_ACTIVE_ │
+ * │ PRESS_IN            ├────────▶ │ PRESS_IN          ├────────────▶ │ LONG_PRESS_IN     │
+ * └─┬───────────────────┘          └─┬─────────────────┘              └─┬─────────────────┘
+ *   │           ▲                    │           ▲                      │           ▲
+ *   │LEAVE_     │                    │LEAVE_     │                      │LEAVE_     │
+ *   │PRESS_RECT │ENTER_              │PRESS_RECT │ENTER_                │PRESS_RECT │ENTER_
+ *   │           │PRESS_RECT          │           │PRESS_RECT            │           │PRESS_RECT
+ *   ▼           │                    ▼           │                      ▼           │
+ * ┌─────────────┴───────┐          ┌─────────────┴─────┐              ┌─────────────┴─────┐
+ * │ RESPONDER_INACTIVE_ │  DELAY   │ RESPONDER_ACTIVE_ │              │ RESPONDER_ACTIVE_ │
+ * │ PRESS_OUT           ├────────▶ │ PRESS_OUT         │              │ LONG_PRESS_OUT    │
+ * └─────────────────────┘          └───────────────────┘              └───────────────────┘
+ *
+ * T + DELAY => LONG_PRESS_DELAY + DELAY
+ *
+ * Not drawn are the side effects of each transition. The most important side
+ * effect is the invocation of `onPress` and `onLongPress` that occur when a
+ * responder is release while in the "press in" states.
+ */
+declare class Pressability {
+  constructor(config: PressabilityConfig);
+  configure(config: PressabilityConfig): void;
+  /**
+   * Resets any pending timers. This should be called on unmount.
+   */
+  reset(): void;
+  /**
+   * Returns a set of props to spread into the interactive element.
+   */
+  getEventHandlers(): EventHandlers;
+  static setLongPressDeactivationDistance(distance: number): void;
+}
+export default Pressability;

package/types_generated/Libraries/Pressability/usePressability.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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<<679a6d7be762fc192387af04838933c3>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/Pressability/usePressability.js
+ */
+
+import { type EventHandlers, type PressabilityConfig } from "./Pressability";
+/**
+ * Creates a persistent instance of `Pressability` that automatically configures
+ * itself and resets. Accepts null `config` to support lazy initialization. Once
+ * initialized, will not un-initialize until the component has been unmounted.
+ *
+ * In order to use `usePressability`, do the following:
+ *
+ *   const config = useMemo(...);
+ *   const eventHandlers = usePressability(config);
+ *   const pressableView = <View {...eventHandlers} />;
+ *
+ */
+declare function usePressability(config: null | undefined | PressabilityConfig): null | EventHandlers;
+export default usePressability;