@kromatv/sdk 0.1.39-canary.3579809

package/types/react-native/types_DEPRECATED/public/ReactNativeRenderer.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.
+ *
+ * @format
+ */
+
+import {GestureResponderEvent} from '../Libraries/Types/CoreEventTypes';
+
+/**
+ * Gesture recognition on mobile devices is much more complicated than web.
+ * A touch can go through several phases as the app determines what the user's intention is.
+ * For example, the app needs to determine if the touch is scrolling, sliding on a widget, or tapping.
+ * This can even change during the duration of a touch. There can also be multiple simultaneous touches.
+ *
+ * The touch responder system is needed to allow components to negotiate these touch interactions
+ * without any additional knowledge about their parent or child components.
+ * This system is implemented in ResponderEventPlugin.js, which contains further details and documentation.
+ *
+ * Best Practices
+ * Users can feel huge differences in the usability of web apps vs. native, and this is one of the big causes.
+ * Every action should have the following attributes:
+ *      Feedback/highlighting- show the user what is handling their touch, and what will happen when they release the gesture
+ *      Cancel-ability- when making an action, the user should be able to abort it mid-touch by dragging their finger away
+ *
+ * These features make users more comfortable while using an app,
+ * because it allows people to experiment and interact without fear of making mistakes.
+ *
+ * TouchableHighlight and Touchable*
+ * The responder system can be complicated to use.
+ * So we have provided an abstract Touchable implementation for things that should be "tappable".
+ * This uses the responder system and allows you to easily configure tap interactions declaratively.
+ * Use TouchableHighlight anywhere where you would use a button or link on web.
+ */
+export interface GestureResponderHandlers {
+  /**
+   * A view can become the touch responder by implementing the correct negotiation methods.
+   * There are two methods to ask the view if it wants to become responder:
+   */
+
+  /**
+   * Does this view want to become responder on the start of a touch?
+   */
+  onStartShouldSetResponder?:
+    ((event: GestureResponderEvent) => boolean) | undefined;
+
+  /**
+   * Called for every touch move on the View when it is not the responder: does this view want to "claim" touch responsiveness?
+   */
+  onMoveShouldSetResponder?:
+    ((event: GestureResponderEvent) => boolean) | undefined;
+
+  /**
+   * If the View returns true and attempts to become the responder, one of the following will happen:
+   */
+
+  onResponderEnd?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * The View is now responding for touch events.
+   * This is the time to highlight and show the user what is happening
+   */
+  onResponderGrant?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * Something else is the responder right now and will not release it
+   */
+  onResponderReject?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * If the view is responding, the following handlers can be called:
+   */
+
+  /**
+   * The user is moving their finger
+   */
+  onResponderMove?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * Fired at the end of the touch, ie "touchUp"
+   */
+  onResponderRelease?: ((event: GestureResponderEvent) => void) | undefined;
+
+  onResponderStart?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   *  Something else wants to become responder.
+   *  Should this view release the responder? Returning true allows release
+   */
+  onResponderTerminationRequest?:
+    ((event: GestureResponderEvent) => boolean) | undefined;
+
+  /**
+   * The responder has been taken from the View.
+   * Might be taken by other views after a call to onResponderTerminationRequest,
+   * or might be taken by the OS without asking (happens with control center/ notification center on iOS)
+   */
+  onResponderTerminate?: ((event: GestureResponderEvent) => void) | undefined;
+
+  /**
+   * onStartShouldSetResponder and onMoveShouldSetResponder are called with a bubbling pattern,
+   * where the deepest node is called first.
+   * That means that the deepest component will become responder when multiple Views return true for *ShouldSetResponder handlers.
+   * This is desirable in most cases, because it makes sure all controls and buttons are usable.
+   *
+   * However, sometimes a parent will want to make sure that it becomes responder.
+   * This can be handled by using the capture phase.
+   * Before the responder system bubbles up from the deepest component,
+   * it will do a capture phase, firing on*ShouldSetResponderCapture.
+   * So if a parent View wants to prevent the child from becoming responder on a touch start,
+   * it should have a onStartShouldSetResponderCapture handler which returns true.
+   */
+  onStartShouldSetResponderCapture?:
+    ((event: GestureResponderEvent) => boolean) | undefined;
+
+  /**
+   * onStartShouldSetResponder and onMoveShouldSetResponder are called with a bubbling pattern,
+   * where the deepest node is called first.
+   * That means that the deepest component will become responder when multiple Views return true for *ShouldSetResponder handlers.
+   * This is desirable in most cases, because it makes sure all controls and buttons are usable.
+   *
+   * However, sometimes a parent will want to make sure that it becomes responder.
+   * This can be handled by using the capture phase.
+   * Before the responder system bubbles up from the deepest component,
+   * it will do a capture phase, firing on*ShouldSetResponderCapture.
+   * So if a parent View wants to prevent the child from becoming responder on a touch start,
+   * it should have a onStartShouldSetResponderCapture handler which returns true.
+   */
+  onMoveShouldSetResponderCapture?:
+    ((event: GestureResponderEvent) => boolean) | undefined;
+}
+
+/**
+ * React Native also implements unstable_batchedUpdates
+ */
+export function unstable_batchedUpdates<A, R>(callback: (a: A) => R, a: A): R;
+export function unstable_batchedUpdates<R>(callback: () => R): R;

package/types/react-native/types_DEPRECATED/public/ReactNativeTVTypes.d.ts

@@ -0,0 +1,273 @@
+import * as React from 'react';
+import type { View, ScrollViewProps, HostComponent, EventSubscription, TVParallaxProperties, FocusEvent, BlurEvent } from 'react-native';
+
+declare module 'react-native' {
+  export type FocusDestination = null | number | React.Component<any, any> | React.ComponentClass<any>;
+
+  interface ScrollViewProps {
+    /**
+     * Padding applied when snapping to items using `snapToAlignment="item"`.
+     * Set on the parent scroll view, not directly on child items.
+     * Only used when `snapToAlignment` is set to `'item'`.
+     */
+    snapToItemPadding?: number | undefined;
+
+    /**
+     * When false, the scroll view will jump to the correct offset without animation
+     * when focus changes. Defaults to true.
+     *
+     * @platform tv
+     */
+    scrollAnimationEnabled?: boolean | undefined;
+
+    /**
+     * Duration in milliseconds of the animated scroll that runs when focus moves to
+     * another item. Applies to the snap scroll (`snapToAlignment="item"` with
+     * per-item `scrollSnapAlign`/`scrollSnapOffset` markers) and to animated
+     * `scrollTo` commands; other focus scrolls are instant. When unset or <= 0, the platform default (~250ms) is used.
+     * On tvOS the focus engine owns this animation and the prop has no effect.
+     *
+     * @platform android
+     */
+    scrollAnimationDuration?: number | undefined;
+
+    /**
+     * Easing curve of that animation, either a CSS easing keyword or explicit
+     * cubic-bezier control points `[x1, y1, x2, y2]`. When unset, the platform
+     * default curve (`AccelerateDecelerateInterpolator`) is used.
+     * On tvOS the focus engine owns this animation and the prop has no effect.
+     *
+     * @platform android
+     */
+    scrollAnimationEasing?:
+      | 'linear'
+      | 'ease'
+      | 'ease-in'
+      | 'ease-out'
+      | 'ease-in-out'
+      | [number, number, number, number]
+      | undefined;
+  }
+
+  interface ViewProps {
+  /**
+   * Controls the scroll snap alignment when this view receives focus inside a ScrollView.
+   * Used with snapToAlignment="item" on the parent ScrollView.
+   *
+   * @platform tv
+   */
+  scrollSnapAlign?: 'start' | 'center' | 'end' | undefined;
+
+  /**
+   * Per-item scroll snap offset in dp/pt. When set, the focus engine lands
+   * this view's top at viewport y = scrollSnapOffset. Standalone alternative
+   * to `scrollSnapAlign`; takes precedence if both are set on the same View.
+   *
+   * @platform tv
+   */
+  scrollSnapOffset?: number | undefined;
+
+  /**
+   * Android TV only prop
+   */
+  tvFocusable?: boolean | undefined,
+  /**
+   * TV next focus down (see documentation for the View component).
+   */
+  nextFocusDown?: FocusDestination | undefined,
+
+  /**
+   * TV next focus forward (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusForward?: FocusDestination | undefined,
+
+  /**
+   * TV next focus left (see documentation for the View component).
+   */
+  nextFocusLeft?: FocusDestination | undefined,
+
+  /**
+   * TV next focus right (see documentation for the View component).
+   */
+  nextFocusRight?: FocusDestination | undefined,
+
+  /**
+   * TV next focus up (see documentation for the View component).
+   */
+  nextFocusUp?: FocusDestination | undefined,
+  }
+
+  export interface NativeMethods {
+    requestTVFocus(): void;
+  }
+
+  export const useTVEventHandler: (handleEvent: (event: HWEvent) => void) => void;
+
+  export const TVEventControl: {
+    enableTVMenuKey(): void;
+    disableTVMenuKey(): void;
+    enableTVPanGesture(): void;
+    disableTVPanGesture(): void;
+    enableGestureHandlersCancelTouches(): void;
+    disableGestureHandlersCancelTouches(): void;
+  };
+
+  /**
+   * Hardware event received from TVEventHandler
+   *
+   * Note: The 'blur' and 'focus' event types are deprecated and will no longer be
+   * emitted on new architecture (Fabric). Use onFocus/onBlur component props instead.
+   * See: https://github.com/react-native-tvos/react-native-tvos/issues/1037
+   */
+  export type HWEvent = {
+    eventType: 'up' | 'down' | 'right' | 'left' | 'longUp' | 'longDown' | 'longRight' | 'longLeft' | 'blur' | 'focus' | 'pan' | string;
+    eventKeyAction?: -1 | 1 | 0 | number | undefined;
+    tag?: number | undefined;
+    body?: {
+      state: 'Began' | 'Changed' | 'Ended',
+      x: number,
+      y: number,
+      velocityX: number,
+      velocityY: number
+    } | undefined
+  };
+
+  export const TVEventHandler: {
+    addListener: (listener: (event: HWEvent) => void) => EventSubscription | undefined
+  };
+
+  export interface FocusGuideProps extends ViewProps {
+     /**
+     * If the view should be "visible". display "flex" if visible, otherwise "none".
+     * Defaults to true
+     */
+    enabled?: boolean | undefined;
+    /**
+     * Array of `Component`s to register as destinations with `UIFocusGuide`
+     */
+    destinations?: FocusDestination[] | undefined;
+    /**
+     * If true, `TVFocusGuide` will automatically manage focus for you.
+     * It will redirect the focus to the first focusable child on the first visit.
+     * It also remembers the last focused child and redirects the focus
+     * to it on the subsequent visits.
+     *
+     * `destinations` prop takes precedence over this prop when used together.
+     *
+     * @default false
+     */
+    autoFocus?: boolean | undefined;
+    /**
+     * Enables focus trapping for the focus guide (see README).
+     */
+    trapFocusUp?: boolean | undefined;
+    /**
+     * Enables focus trapping for the focus guide (see README).
+     */
+    trapFocusDown?: boolean | undefined;
+    /**
+     * Enables focus trapping for the focus guide (see README).
+     */
+    trapFocusLeft?: boolean | undefined;
+    /**
+     * Enables focus trapping for the focus guide (see README).
+     */
+    trapFocusRight?: boolean | undefined;
+    /**
+     * @deprecated Don't use it, no longer necessary.
+     */
+    safePadding?: 'both' | 'vertical' | 'horizontal' | null | undefined;
+    /**
+     * Fires once when focus enters this focus guide's subtree from outside.
+     * Unlike `onFocus`, which bubbles and fires for every descendant, this
+     * does not fire again when focus moves between descendants.
+     */
+    onFocusEnter?: ((event: FocusEvent) => void) | undefined;
+    /**
+     * Fires once when focus leaves this focus guide's subtree entirely. Does
+     * not fire when focus moves between descendants. Pairs with `onFocusEnter`.
+     */
+    onFocusLeave?: ((event: BlurEvent) => void) | undefined;
+  }
+
+  export type FocusGuideMethods = {
+    setDestinations: (
+      destinations: FocusDestination[],
+    ) => void;
+  }
+
+  /**
+   * This component provides support for Apple's `UIFocusGuide` API,
+   * to help ensure that focusable controls can be navigated to,
+   * even if they are not directly in line with other controls on both tvOS and Android.
+   * An example is provided in `RNTester` that shows different ways of using this component.
+   * https://github.com/react-native-tvos/react-native-tvos/blob/tvos-v0.69.8/packages/rn-tester/js/examples/TVFocusGuide/TVFocusGuideAutoFocusExample.js
+   */
+  export const TVFocusGuideView: React.ForwardRefExoticComponent<FocusGuideProps & React.RefAttributes<View & FocusGuideMethods>>;
+  export interface TVTextScrollViewProps extends Omit<ScrollViewProps, 'onFocus' | 'onBlur'> {
+    /**
+     * The duration of the scroll animation when a swipe is detected.
+     * Default value is 0.3 s
+     */
+    scrollDuration?: number | undefined;
+    /**
+     * Scrolling distance when a swipe is detected
+     * Default value is half the visible height (vertical scroller)
+     * or width (horizontal scroller)
+     */
+    pageSize?: number | undefined;
+    /**
+     * If true, will scroll to start when focus moves out past the beginning
+     * of the scroller
+     * Defaults to true
+     */
+    snapToStart?: boolean | undefined;
+    /**
+     * If true, will scroll to end when focus moves out past the end of the
+     * scroller
+     * Defaults to true
+     */
+    snapToEnd?: boolean | undefined;
+    /**
+     * Called when the scroller comes into focus (e.g. for highlighting)
+     */
+    onFocus?(evt: HWEvent): void;
+    /**
+     * Called when the scroller goes out of focus
+     */
+    onBlur?(evt: HWEvent): void;
+  }
+
+  export class TVTextScrollView extends React.Component<TVTextScrollViewProps> {}
+
+  export interface PressableStateCallbackType {
+    readonly focused: boolean;
+  }
+
+  export interface TouchableWithoutFeedbackPropsIOS {
+    /**
+     * *(Apple TV only)* TV preferred focus (see documentation for the View component).
+     *
+     * @platform ios
+     */
+    hasTVPreferredFocus?: boolean | undefined;
+
+    /**
+     * *(Apple TV only)* Object with properties to control Apple TV parallax effects.
+     *
+     * enabled: If true, parallax effects are enabled.  Defaults to true.
+     * shiftDistanceX: Defaults to 2.0.
+     * shiftDistanceY: Defaults to 2.0.
+     * tiltAngle: Defaults to 0.05.
+     * magnification: Defaults to 1.0.
+     * pressMagnification: Defaults to 1.0.
+     * pressDuration: Defaults to 0.3.
+     * pressDelay: Defaults to 0.0.
+     *
+     * @platform ios
+     */
+    tvParallaxProperties?: TVParallaxProperties | undefined;
+  }
+}

package/types/react-native/types_DEPRECATED/public/ReactNativeTypes.d.ts

@@ -0,0 +1,253 @@
+/**
+ * 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';
+
+export type MeasureOnSuccessCallback = (
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+  pageX: number,
+  pageY: number,
+) => void;
+
+export type MeasureInWindowOnSuccessCallback = (
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+) => void;
+
+export type MeasureLayoutOnSuccessCallback = (
+  left: number,
+  top: number,
+  width: number,
+  height: number,
+) => void;
+
+/**
+ * NativeMethods provides methods to access the underlying native component directly.
+ * This can be useful in cases when you want to focus a view or measure its on-screen dimensions,
+ * for example.
+ * The methods described here are available on most of the default components provided by React Native.
+ * Note, however, that they are not available on composite components that aren't directly backed by a
+ * native view. This will generally include most components that you define in your own app.
+ * For more information, see [Direct Manipulation](https://reactnative.dev/docs/the-new-architecture/direct-manipulation-new-architecture).
+ * @see https://github.com/facebook/react-native/blob/master/Libraries/Renderer/shims/ReactNativeTypes.js#L87
+ *
+ * @deprecated Use HostInstance instead.
+ */
+export interface NativeMethods {
+  /**
+   * Determines the location on screen, width, and height of the given view and
+   * returns the values via an async callback. If successful, the callback will
+   * be called with the following arguments:
+   *
+   *  - x
+   *  - y
+   *  - width
+   *  - height
+   *  - pageX
+   *  - pageY
+   *
+   * Note that these measurements are not available until after the rendering
+   * has been completed in native. If you need the measurements as soon as
+   * possible, consider using the [`onLayout`
+   * prop](docs/view.html#onlayout) instead.
+   */
+  measure(callback: MeasureOnSuccessCallback): void;
+
+  /**
+   * Determines the location of the given view in the window and returns the
+   * values via an async callback. If the React root view is embedded in
+   * another native view, this will give you the absolute coordinates. If
+   * successful, the callback will be called with the following
+   * arguments:
+   *
+   *  - x
+   *  - y
+   *  - width
+   *  - height
+   *
+   * Note that these measurements are not available until after the rendering
+   * has been completed in native.
+   */
+  measureInWindow(callback: MeasureInWindowOnSuccessCallback): void;
+
+  /**
+   * Like [`measure()`](#measure), but measures the view relative an ancestor,
+   * specified as `relativeToNativeComponentRef`. This means that the returned x, y
+   * are relative to the origin x, y of the ancestor view.
+   * _Can also be called with a relativeNativeNodeHandle but is deprecated._
+   */
+  measureLayout(
+    relativeToNativeComponentRef: HostInstance | number,
+    onSuccess: MeasureLayoutOnSuccessCallback,
+    onFail?: () => void,
+  ): void;
+
+  /**
+   * This function sends props straight to native. They will not participate in
+   * future diff process - this means that if you do not include them in the
+   * next render, they will remain active (see [Direct
+   * Manipulation](https://reactnative.dev/docs/the-new-architecture/direct-manipulation-new-architecture)).
+   */
+  setNativeProps(nativeProps: object): void;
+
+  /**
+   * Requests focus for the given input or view. The exact behavior triggered
+   * will depend on the platform and type of view.
+   */
+  focus(): void;
+
+  /**
+   * Removes focus from an input or view. This is the opposite of `focus()`.
+   */
+  blur(): void;
+}
+
+/**
+ * @deprecated Use HostInstance instead.
+ */
+export type NativeMethodsMixin = NativeMethods;
+/**
+ * @deprecated Use HostInstance instead.
+ */
+export type NativeMethodsMixinType = NativeMethods;
+
+/**
+ * Represents a native component, such as those returned from `requireNativeComponent`.
+ *
+ * @see https://github.com/facebook/react-native/blob/v0.62.0-rc.5/Libraries/Renderer/shims/ReactNativeTypes.js
+ *
+ * @todo This should eventually be defined as an AbstractComponent, but that
+ *       should first be introduced in the React typings.
+ */
+export interface HostComponent<P> extends Pick<
+  React.ComponentClass<P>,
+  Exclude<keyof React.ComponentClass<P>, 'new'>
+> {
+  new (props: P, context?: any): React.Component<P> & HostInstance;
+}
+
+export interface ArrayLike<T> extends Iterable<T> {
+  [indexer: number]: T;
+  readonly length: number;
+}
+
+export interface HTMLCollection<T> extends Iterable<T>, ArrayLike<T> {
+  [index: number]: T;
+  readonly length: number;
+  item(index: number): null | T;
+  namedItem(name: string): null | T;
+  [Symbol.iterator](): Iterator<T>;
+}
+
+export interface NodeList<T> extends Iterable<T>, ArrayLike<T> {
+  [index: number]: T;
+  readonly length: number;
+  entries(): Iterator<[number, T]>;
+  forEach<ThisType>(
+    callbackFn: (value: T, index: number, array: NodeList<T>) => unknown,
+    thisArg?: ThisType,
+  ): void;
+  item(index: number): null | T;
+  keys(): Iterator<number>;
+  values(): Iterator<T>;
+  [Symbol.iterator](): Iterator<T>;
+}
+
+export interface ReadOnlyNode {
+  get childNodes(): NodeList<ReadOnlyNode>;
+  compareDocumentPosition(otherNode: ReadOnlyNode): number;
+  contains(otherNode: ReadOnlyNode): boolean;
+  get firstChild(): null | ReadOnlyNode;
+  getRootNode(): ReadOnlyNode;
+  hasChildNodes(): boolean;
+  get isConnected(): boolean;
+  get lastChild(): null | ReadOnlyNode;
+  get nextSibling(): null | ReadOnlyNode;
+  get nodeName(): string;
+  get nodeType(): number;
+  get nodeValue(): null | string;
+  get ownerDocument(): null | ReactNativeDocument;
+  get parentElement(): null | ReadOnlyElement;
+  get parentNode(): null | ReadOnlyNode;
+  get previousSibling(): null | ReadOnlyNode;
+  get textContent(): string;
+}
+
+export interface ReactNativeDocument extends ReadOnlyNode {
+  get childElementCount(): number;
+  get children(): HTMLCollection<ReadOnlyElement>;
+  get documentElement(): ReactNativeElement;
+  get firstElementChild(): null | ReadOnlyElement;
+  getElementById(id: string): null | ReadOnlyElement;
+  get lastElementChild(): null | ReadOnlyElement;
+  get nodeName(): string;
+  get nodeType(): number;
+  get nodeValue(): null;
+}
+
+export interface ReadOnlyElement extends ReadOnlyNode {
+  get childElementCount(): number;
+  get children(): HTMLCollection<ReadOnlyElement>;
+  get clientHeight(): number;
+  get clientLeft(): number;
+  get clientTop(): number;
+  get clientWidth(): number;
+  get firstElementChild(): null | ReadOnlyElement;
+  getBoundingClientRect(): DOMRect;
+  hasPointerCapture(pointerId: number): boolean;
+  get id(): string;
+  get lastElementChild(): null | ReadOnlyElement;
+  get nextElementSibling(): null | ReadOnlyElement;
+  get nodeName(): string;
+  get nodeType(): number;
+  get nodeValue(): null | string;
+  set nodeValue(value: string);
+  get previousElementSibling(): null | ReadOnlyElement;
+  releasePointerCapture(pointerId: number): void;
+  get scrollHeight(): number;
+  get scrollLeft(): number;
+  get scrollTop(): number;
+  get scrollWidth(): number;
+  setPointerCapture(pointerId: number): void;
+  get tagName(): string;
+  get textContent(): string;
+}
+
+export interface ReactNativeElement extends ReadOnlyElement, NativeMethods {
+  blur(): void;
+  focus(): void;
+  get offsetHeight(): number;
+  get offsetLeft(): number;
+  get offsetParent(): null | ReadOnlyElement;
+  get offsetTop(): number;
+  get offsetWidth(): number;
+  setNativeProps(nativeProps: {}): void;
+}
+
+export interface ReadOnlyCharacterData extends ReadOnlyNode {
+  get data(): string;
+  get length(): number;
+  get nextElementSibling(): null | ReadOnlyElement;
+  get nodeValue(): string;
+  get previousElementSibling(): null | ReadOnlyElement;
+  substringData(offset: number, count: number): string;
+  get textContent(): string;
+}
+
+export interface ReadOnlyText extends ReadOnlyCharacterData {
+  get nodeName(): string;
+  get nodeType(): number;
+}
+
+export type HostInstance = ReactNativeElement;