@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/exports/Image/index.js.flow

@@ -0,0 +1,225 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * 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
+ */
+
+'use client';
+
+import type { ImageProps } from './types';
+import * as React from 'react';
+import createElement from '../createElement';
+import { getAssetByID } from '../../modules/AssetRegistry';
+import { createBoxShadowValue } from '../StyleSheet/preprocess';
+import ImageLoader from '../../modules/ImageLoader';
+import PixelRatio from '../PixelRatio';
+import StyleSheet from '../StyleSheet';
+import TextAncestorContext from '../Text/TextAncestorContext';
+import View from '../View';
+import { warnOnce } from '../../modules/warnOnce';
+export type { ImageProps };
+const ERRORED = 'ERRORED';
+const LOADED = 'LOADED';
+const LOADING = 'LOADING';
+const IDLE = 'IDLE';
+let _filterId = 0;
+const svgDataUriPattern = /^(data:image\/svg\+xml;utf8,)(.*)/;
+declare function createTintColorSVG(tintColor: any, id: any): any;
+declare function extractNonStandardStyleProps(style: any, blurRadius: any, filterId: any, tintColorProp: any): any;
+declare function resolveAssetDimensions(source: any): any;
+declare function resolveAssetUri(source: any): ?string;
+interface ImageStatics {
+  getSize: (uri: string, success: (width: number, height: number) => void, failure: () => void) => void,
+  prefetch: (uri: string) => Promise<void>,
+  queryCache: (uris: Array<string>) => Promise<{|
+    [uri: string]: 'disk/memory'
+  |}>,
+}
+const Image: React.AbstractComponent<ImageProps, React.ElementRef<typeof View>> = React.forwardRef((props, ref) => {
+  const {
+    'aria-label': _ariaLabel,
+    accessibilityLabel,
+    blurRadius,
+    defaultSource,
+    draggable,
+    onError,
+    onLayout,
+    onLoad,
+    onLoadEnd,
+    onLoadStart,
+    pointerEvents,
+    source,
+    style,
+    ...rest
+  } = props;
+  const ariaLabel = _ariaLabel || accessibilityLabel;
+  if (process.env.NODE_ENV !== 'production') {
+    if (props.children) {
+      throw new Error('The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.');
+    }
+  }
+  const [state, updateState] = React.useState(() => {
+    const uri = resolveAssetUri(source);
+    if (uri != null) {
+      const isLoaded = ImageLoader.has(uri);
+      if (isLoaded) {
+        return LOADED;
+      }
+    }
+    return IDLE;
+  });
+  const [layout, updateLayout] = React.useState({});
+  const hasTextAncestor = React.useContext(TextAncestorContext);
+  const hiddenImageRef = React.useRef(null);
+  const filterRef = React.useRef(_filterId++);
+  const requestRef = React.useRef(null);
+  const shouldDisplaySource = state === LOADED || state === LOADING && defaultSource == null;
+  const [_resizeMode, filter, _tintColor] = extractNonStandardStyleProps(style, blurRadius, filterRef.current, props.tintColor);
+  const resizeMode = props.resizeMode || _resizeMode || 'cover';
+  const tintColor = props.tintColor || _tintColor;
+  const selectedSource = shouldDisplaySource ? source : defaultSource;
+  const displayImageUri = resolveAssetUri(selectedSource);
+  const imageSizeStyle = resolveAssetDimensions(selectedSource);
+  const backgroundImage = displayImageUri ? `url("${displayImageUri}")` : null;
+  const backgroundSize = getBackgroundSize();
+
+  // Accessibility image allows users to trigger the browser's image context menu
+  const hiddenImage = displayImageUri ? createElement('img', {
+    alt: ariaLabel || '',
+    style: styles.accessibilityImage$raw,
+    draggable: draggable || false,
+    ref: hiddenImageRef,
+    src: displayImageUri
+  }) : null;
+  declare function getBackgroundSize(): ?string;
+  declare function handleLayout(e: any): any; // Image loading
+  const uri = resolveAssetUri(source);
+  React.useEffect(() => {
+    abortPendingRequest();
+    if (uri != null) {
+      updateState(LOADING);
+      if (onLoadStart) {
+        onLoadStart();
+      }
+      requestRef.current = ImageLoader.load(uri, function load(e) {
+        updateState(LOADED);
+        if (onLoad) {
+          onLoad(e);
+        }
+        if (onLoadEnd) {
+          onLoadEnd();
+        }
+      }, function error() {
+        updateState(ERRORED);
+        if (onError) {
+          onError({
+            nativeEvent: {
+              error: `Failed to load resource ${uri}`
+            }
+          });
+        }
+        if (onLoadEnd) {
+          onLoadEnd();
+        }
+      });
+    }
+    declare function abortPendingRequest(): any;
+    return abortPendingRequest;
+  }, [uri, requestRef, updateState, onError, onLoad, onLoadEnd, onLoadStart]);
+  return <View {...rest} aria-label={ariaLabel} onLayout={handleLayout} pointerEvents={pointerEvents} ref={ref} style={[styles.root, hasTextAncestor && styles.inline, imageSizeStyle, style, styles.undo,
+  // TEMP: avoid deprecated shadow props regression
+  // until Image refactored to use createElement.
+  {
+    boxShadow: null
+  }]}>
+      <View style={[styles.image, resizeModeStyles[resizeMode], {
+      backgroundImage,
+      filter
+    }, backgroundSize != null && {
+      backgroundSize
+    }]} suppressHydrationWarning={true} />
+      {hiddenImage}
+      {createTintColorSVG(tintColor, filterRef.current)}
+    </View>;
+});
+Image.displayName = 'Image';
+
+// $FlowIgnore: This is the correct type, but casting makes it unhappy since the variables aren't defined yet
+const ImageWithStatics = (Image: React.AbstractComponent<ImageProps, React.ElementRef<typeof View>> & ImageStatics);
+ImageWithStatics.getSize = function (uri, success, failure) {
+  ImageLoader.getSize(uri, success, failure);
+};
+ImageWithStatics.prefetch = function (uri) {
+  return ImageLoader.prefetch(uri);
+};
+ImageWithStatics.queryCache = function (uris) {
+  return ImageLoader.queryCache(uris);
+};
+const styles = StyleSheet.create({
+  root: {
+    flexBasis: 'auto',
+    overflow: 'hidden',
+    zIndex: 0
+  },
+  inline: {
+    display: 'inline-flex'
+  },
+  undo: {
+    // These styles are converted to CSS filters applied to the
+    // element displaying the background image.
+    blurRadius: null,
+    shadowColor: null,
+    shadowOpacity: null,
+    shadowOffset: null,
+    shadowRadius: null,
+    tintColor: null,
+    // These styles are not supported
+    overlayColor: null,
+    resizeMode: null
+  },
+  image: {
+    ...StyleSheet.absoluteFillObject,
+    backgroundColor: 'transparent',
+    backgroundPosition: 'center',
+    backgroundRepeat: 'no-repeat',
+    backgroundSize: 'cover',
+    height: '100%',
+    width: '100%',
+    zIndex: -1
+  },
+  accessibilityImage$raw: {
+    ...StyleSheet.absoluteFillObject,
+    height: '100%',
+    opacity: 0,
+    width: '100%',
+    zIndex: -1
+  }
+});
+const resizeModeStyles = StyleSheet.create({
+  center: {
+    backgroundSize: 'auto'
+  },
+  contain: {
+    backgroundSize: 'contain'
+  },
+  cover: {
+    backgroundSize: 'cover'
+  },
+  none: {
+    backgroundPosition: '0',
+    backgroundSize: 'auto'
+  },
+  repeat: {
+    backgroundPosition: '0',
+    backgroundRepeat: 'repeat',
+    backgroundSize: 'auto'
+  },
+  stretch: {
+    backgroundSize: '100% 100%'
+  }
+});
+export default ImageWithStatics;

package/dist/exports/Image/types.js.flow

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * 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
+ */
+
+import type { ColorValue, GenericStyleProp } from '../../types';
+import type { ViewProps, ViewStyle } from '../View/types';
+type SourceObject = {
+  /**
+   * `body` is the HTTP body to send with the request. This must be a valid
+   * UTF-8 string, and will be sent exactly as specified, with no
+   * additional encoding (e.g. URL-escaping or base64) applied.
+   */
+  body?: string,
+  /**
+   * `cache` determines how the requests handles potentially cached
+   * responses.
+   *
+   * - `default`: Use the native platforms default strategy. `useProtocolCachePolicy` on iOS.
+   *
+   * - `reload`: The data for the URL will be loaded from the originating source.
+   * No existing cache data should be used to satisfy a URL load request.
+   *
+   * - `force-cache`: The existing cached data will be used to satisfy the request,
+   * regardless of its age or expiration date. If there is no existing data in the cache
+   * corresponding the request, the data is loaded from the originating source.
+   *
+   * - `only-if-cached`: The existing cache data will be used to satisfy a request, regardless of
+   * its age or expiration date. If there is no existing data in the cache corresponding
+   * to a URL load request, no attempt is made to load the data from the originating source,
+   * and the load is considered to have failed.
+   *
+   * @platform ios
+   */
+  cache?: 'default' | 'reload' | 'force-cache' | 'only-if-cached',
+  /**
+   * `headers` is an object representing the HTTP headers to send along with the
+   * request for a remote image.
+   */
+  headers?: {
+    [key: string]: string
+  },
+  /**
+   * `method` is the HTTP Method to use. Defaults to GET if not specified.
+   */
+  method?: string,
+  /**
+   * `scale` is used to indicate the scale factor of the image. Defaults to 1.0 if
+   * unspecified, meaning that one image pixel equates to one display point / DIP.
+   */
+  scale?: number,
+  /**
+   * `uri` is a string representing the resource identifier for the image, which
+   * could be an http address, a local file path, or the name of a static image
+   * resource (which should be wrapped in the `require('./path/to/image.png')`
+   * function).
+   */
+  uri: string,
+  /**
+   * `width` and `height` can be specified if known at build time, in which case
+   * these will be used to set the default `<Image/>` component dimensions.
+   */
+  height?: number,
+  width?: number,
+};
+export type ResizeMode = 'center' | 'contain' | 'cover' | 'none' | 'repeat' | 'stretch';
+export type Source = number | string | SourceObject | Array<SourceObject>;
+export type ImageStyle = {
+  ...ViewStyle,
+  // @deprecated
+  resizeMode?: ResizeMode,
+  tintColor?: ColorValue,
+};
+export type ImageProps = {
+  ...ViewProps,
+  blurRadius?: number,
+  defaultSource?: Source,
+  draggable?: boolean,
+  onError?: (e: any) => void,
+  onLayout?: (e: any) => void,
+  onLoad?: (e: any) => void,
+  onLoadEnd?: (e: any) => void,
+  onLoadStart?: (e: any) => void,
+  onProgress?: (e: any) => void,
+  resizeMode?: ResizeMode,
+  source?: Source,
+  style?: GenericStyleProp<ImageStyle>,
+  tintColor?: ColorValue,
+};

package/dist/exports/ImageBackground/index.js

@@ -0,0 +1,53 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+var _excluded = ["children", "style", "imageStyle", "imageRef"];
+/**
+ * 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.
+ *
+ * 
+ */
+
+import * as React from 'react';
+import { forwardRef } from 'react';
+import Image from '../Image';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+var emptyObject = {};
+
+/**
+ * Very simple drop-in replacement for <Image> which supports nesting views.
+ */
+var ImageBackground = /*#__PURE__*/forwardRef((props, forwardedRef) => {
+  var children = props.children,
+    _props$style = props.style,
+    style = _props$style === void 0 ? emptyObject : _props$style,
+    imageStyle = props.imageStyle,
+    imageRef = props.imageRef,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  var _StyleSheet$flatten = StyleSheet.flatten(style),
+    height = _StyleSheet$flatten.height,
+    width = _StyleSheet$flatten.width;
+  return /*#__PURE__*/React.createElement(View, {
+    ref: forwardedRef,
+    style: style
+  }, /*#__PURE__*/React.createElement(Image, _extends({}, rest, {
+    ref: imageRef,
+    style: [{
+      // Temporary Workaround:
+      // Current (imperfect yet) implementation of <Image> overwrites width and height styles
+      // (which is not quite correct), and these styles conflict with explicitly set styles
+      // of <ImageBackground> and with our internal layout model here.
+      // So, we have to proxy/reapply these styles explicitly for actual <Image> component.
+      // This workaround should be removed after implementing proper support of
+      // intrinsic content size of the <Image>.
+      width,
+      height,
+      zIndex: -1
+    }, StyleSheet.absoluteFill, imageStyle]
+  })), children);
+});
+ImageBackground.displayName = 'ImageBackground';
+export default ImageBackground;

package/dist/exports/ImageBackground/index.js.flow

@@ -0,0 +1,57 @@
+/**
+ * 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
+ */
+
+import type { ImageProps } from '../Image';
+import type { ViewProps } from '../View';
+import * as React from 'react';
+import { forwardRef } from 'react';
+import Image from '../Image';
+import StyleSheet from '../StyleSheet';
+import View from '../View';
+type ImageBackgroundProps = {
+  ...ImageProps,
+  imageRef?: any,
+  imageStyle?: $PropertyType<ImageProps, 'style'>,
+  style?: $PropertyType<ViewProps, 'style'>,
+};
+const emptyObject = {};
+
+/**
+ * Very simple drop-in replacement for <Image> which supports nesting views.
+ */
+const ImageBackground: React.AbstractComponent<ImageBackgroundProps, React.ElementRef<typeof View>> = forwardRef((props, forwardedRef) => {
+  const {
+    children,
+    style = emptyObject,
+    imageStyle,
+    imageRef,
+    ...rest
+  } = props;
+  const {
+    height,
+    width
+  } = StyleSheet.flatten(style);
+  return <View ref={forwardedRef} style={style}>
+      <Image {...rest} ref={imageRef} style={[{
+      // Temporary Workaround:
+      // Current (imperfect yet) implementation of <Image> overwrites width and height styles
+      // (which is not quite correct), and these styles conflict with explicitly set styles
+      // of <ImageBackground> and with our internal layout model here.
+      // So, we have to proxy/reapply these styles explicitly for actual <Image> component.
+      // This workaround should be removed after implementing proper support of
+      // intrinsic content size of the <Image>.
+      width,
+      height,
+      zIndex: -1
+    }, StyleSheet.absoluteFill, imageStyle]} />
+      {children}
+    </View>;
+});
+ImageBackground.displayName = 'ImageBackground';
+export default ImageBackground;

package/dist/exports/InputAccessoryView/index.js

@@ -0,0 +1,2 @@
+import UnimplementedView from '../../modules/UnimplementedView';
+export default UnimplementedView;

package/dist/exports/InteractionManager/TaskQueue.js

@@ -0,0 +1,87 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * 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.
+ *
+ * 
+ */
+
+import invariant from 'fbjs/lib/invariant';
+class TaskQueue {
+  constructor(_ref) {
+    var onMoreTasks = _ref.onMoreTasks;
+    this._onMoreTasks = onMoreTasks;
+    this._queueStack = [{
+      tasks: [],
+      popable: true
+    }];
+  }
+  enqueue(task) {
+    this._getCurrentQueue().push(task);
+  }
+  enqueueTasks(tasks) {
+    tasks.forEach(task => this.enqueue(task));
+  }
+  cancelTasks(tasksToCancel) {
+    this._queueStack = this._queueStack.map(queue => _objectSpread(_objectSpread({}, queue), {}, {
+      tasks: queue.tasks.filter(task => tasksToCancel.indexOf(task) === -1)
+    })).filter((queue, idx) => queue.tasks.length > 0 || idx === 0);
+  }
+  hasTasksToProcess() {
+    return this._getCurrentQueue().length > 0;
+  }
+
+  /**
+   * Executes the next task in the queue.
+   */
+  processNext() {
+    var queue = this._getCurrentQueue();
+    if (queue.length) {
+      var task = queue.shift();
+      try {
+        if (typeof task === 'object' && task.gen) {
+          this._genPromise(task);
+        } else if (typeof task === 'object' && task.run) {
+          task.run();
+        } else {
+          invariant(typeof task === 'function', 'Expected Function, SimpleTask, or PromiseTask, but got:\n' + JSON.stringify(task, null, 2));
+          task();
+        }
+      } catch (e) {
+        e.message = 'TaskQueue: Error with task ' + (task.name || '') + ': ' + e.message;
+        throw e;
+      }
+    }
+  }
+  _getCurrentQueue() {
+    var stackIdx = this._queueStack.length - 1;
+    var queue = this._queueStack[stackIdx];
+    if (queue.popable && queue.tasks.length === 0 && stackIdx > 0) {
+      this._queueStack.pop();
+      return this._getCurrentQueue();
+    } else {
+      return queue.tasks;
+    }
+  }
+  _genPromise(task) {
+    var length = this._queueStack.push({
+      tasks: [],
+      popable: false
+    });
+    var stackIdx = length - 1;
+    var stackItem = this._queueStack[stackIdx];
+    task.gen().then(() => {
+      stackItem.popable = true;
+      this.hasTasksToProcess() && this._onMoreTasks();
+    }).catch(ex => {
+      setTimeout(() => {
+        ex.message = "TaskQueue: Error resolving Promise in task " + task.name + ": " + ex.message;
+        throw ex;
+      }, 0);
+    });
+  }
+}
+export default TaskQueue;

package/dist/exports/InteractionManager/TaskQueue.js.flow

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * 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
+ */
+
+import invariant from 'fbjs/lib/invariant';
+type SimpleTask = {|
+  name: string,
+  run: () => void,
+|};
+type PromiseTask = {|
+  name: string,
+  gen: () => Promise<void>,
+|};
+export type Task = SimpleTask | PromiseTask | (() => void);
+declare class TaskQueue {
+  constructor(arg0: {
+    onMoreTasks: () => void,
+    ...
+  }): any,
+  enqueue(task: Task): void,
+  enqueueTasks(tasks: Array<Task>): void,
+  cancelTasks(tasksToCancel: Array<Task>): void,
+  hasTasksToProcess(): boolean,
+  processNext(): void,
+  _queueStack: Array<{
+    tasks: Array<Task>,
+    popable: boolean,
+    ...
+  }>,
+  _onMoreTasks: () => void,
+  _getCurrentQueue(): Array<Task>,
+  _genPromise(task: PromiseTask): any,
+}
+export default TaskQueue;

package/dist/exports/InteractionManager/index.js

@@ -0,0 +1,124 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ * 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.
+ *
+ * 
+ */
+
+import invariant from 'fbjs/lib/invariant';
+import TaskQueue from './TaskQueue';
+import EventEmitter from '../../vendor/react-native/vendor/emitter/EventEmitter';
+import requestIdleCallback from '../../modules/requestIdleCallback';
+var _emitter = new EventEmitter();
+var InteractionManager = {
+  Events: {
+    interactionStart: 'interactionStart',
+    interactionComplete: 'interactionComplete'
+  },
+  /**
+   * Schedule a function to run after all interactions have completed.
+   */
+  runAfterInteractions(task) {
+    var tasks = [];
+    var promise = new Promise(resolve => {
+      _scheduleUpdate();
+      if (task) {
+        tasks.push(task);
+      }
+      tasks.push({
+        run: resolve,
+        name: 'resolve ' + (task && task.name || '?')
+      });
+      _taskQueue.enqueueTasks(tasks);
+    });
+    return {
+      then: promise.then.bind(promise),
+      done: promise.then.bind(promise),
+      cancel: () => {
+        _taskQueue.cancelTasks(tasks);
+      }
+    };
+  },
+  /**
+   * Notify manager that an interaction has started.
+   */
+  createInteractionHandle() {
+    _scheduleUpdate();
+    var handle = ++_inc;
+    _addInteractionSet.add(handle);
+    return handle;
+  },
+  /**
+   * Notify manager that an interaction has completed.
+   */
+  clearInteractionHandle(handle) {
+    invariant(!!handle, 'Must provide a handle to clear.');
+    _scheduleUpdate();
+    _addInteractionSet.delete(handle);
+    _deleteInteractionSet.add(handle);
+  },
+  addListener: _emitter.addListener.bind(_emitter),
+  /**
+   *
+   * @param deadline
+   */
+  setDeadline(deadline) {
+    _deadline = deadline;
+  }
+};
+var _interactionSet = new Set();
+var _addInteractionSet = new Set();
+var _deleteInteractionSet = new Set();
+var _taskQueue = new TaskQueue({
+  onMoreTasks: _scheduleUpdate
+});
+var _nextUpdateHandle = 0;
+var _inc = 0;
+var _deadline = -1;
+
+/**
+ * Schedule an asynchronous update to the interaction state.
+ */
+function _scheduleUpdate() {
+  if (!_nextUpdateHandle) {
+    if (_deadline > 0) {
+      _nextUpdateHandle = setTimeout(_processUpdate);
+    } else {
+      _nextUpdateHandle = requestIdleCallback(_processUpdate);
+    }
+  }
+}
+
+/**
+ * Notify listeners, process queue, etc
+ */
+function _processUpdate() {
+  _nextUpdateHandle = 0;
+  var interactionCount = _interactionSet.size;
+  _addInteractionSet.forEach(handle => _interactionSet.add(handle));
+  _deleteInteractionSet.forEach(handle => _interactionSet.delete(handle));
+  var nextInteractionCount = _interactionSet.size;
+  if (interactionCount !== 0 && nextInteractionCount === 0) {
+    _emitter.emit(InteractionManager.Events.interactionComplete);
+  } else if (interactionCount === 0 && nextInteractionCount !== 0) {
+    _emitter.emit(InteractionManager.Events.interactionStart);
+  }
+  if (nextInteractionCount === 0) {
+    // It seems that we can't know the running time of the current event loop,
+    // we can only calculate the running time of the current task queue.
+    var begin = Date.now();
+    while (_taskQueue.hasTasksToProcess()) {
+      _taskQueue.processNext();
+      if (_deadline > 0 && Date.now() - begin >= _deadline) {
+        _scheduleUpdate();
+        break;
+      }
+    }
+  }
+  _addInteractionSet.clear();
+  _deleteInteractionSet.clear();
+}
+export default InteractionManager;