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

package/src/exports/InteractionManager/TaskQueue.js

@@ -0,0 +1,115 @@
+/**
+ * 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);
+
+class TaskQueue {
+  constructor({ onMoreTasks }: { onMoreTasks: () => void, ... }) {
+    this._onMoreTasks = onMoreTasks;
+    this._queueStack = [{ tasks: [], popable: true }];
+  }
+
+  enqueue(task: Task): void {
+    this._getCurrentQueue().push(task);
+  }
+
+  enqueueTasks(tasks: Array<Task>): void {
+    tasks.forEach((task) => this.enqueue(task));
+  }
+
+  cancelTasks(tasksToCancel: Array<Task>): void {
+    this._queueStack = this._queueStack
+      .map((queue) => ({
+        ...queue,
+        tasks: queue.tasks.filter((task) => tasksToCancel.indexOf(task) === -1)
+      }))
+      .filter((queue, idx) => queue.tasks.length > 0 || idx === 0);
+  }
+
+  hasTasksToProcess(): boolean {
+    return this._getCurrentQueue().length > 0;
+  }
+
+  /**
+   * Executes the next task in the queue.
+   */
+  processNext(): void {
+    const queue = this._getCurrentQueue();
+    if (queue.length) {
+      const 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;
+      }
+    }
+  }
+
+  _queueStack: Array<{
+    tasks: Array<Task>,
+    popable: boolean,
+    ...
+  }>;
+  _onMoreTasks: () => void;
+
+  _getCurrentQueue(): Array<Task> {
+    const stackIdx = this._queueStack.length - 1;
+    const 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: PromiseTask) {
+    const length = this._queueStack.push({ tasks: [], popable: false });
+    const stackIdx = length - 1;
+    const 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/src/exports/InteractionManager/index.js

@@ -0,0 +1,142 @@
+/**
+ * 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';
+import type { Task } from './TaskQueue';
+import TaskQueue from './TaskQueue';
+import type { EventSubscription } from '../../vendor/react-native/vendor/emitter/EventEmitter';
+import EventEmitter from '../../vendor/react-native/vendor/emitter/EventEmitter';
+import requestIdleCallback from '../../modules/requestIdleCallback';
+
+const _emitter = new EventEmitter<{
+  interactionComplete: [],
+  interactionStart: []
+}>();
+
+const InteractionManager = {
+  Events: {
+    interactionStart: 'interactionStart',
+    interactionComplete: 'interactionComplete'
+  },
+
+  /**
+   * Schedule a function to run after all interactions have completed.
+   */
+  runAfterInteractions(task: ?Task): {
+    then: Function,
+    done: Function,
+    cancel: Function
+  } {
+    const tasks: Array<Task> = [];
+    const 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(): number {
+    _scheduleUpdate();
+    const handle = ++_inc;
+    _addInteractionSet.add(handle);
+    return handle;
+  },
+
+  /**
+   * Notify manager that an interaction has completed.
+   */
+  clearInteractionHandle(handle: number) {
+    invariant(!!handle, 'Must provide a handle to clear.');
+    _scheduleUpdate();
+    _addInteractionSet.delete(handle);
+    _deleteInteractionSet.add(handle);
+  },
+
+  addListener: (_emitter.addListener.bind(_emitter): EventSubscription),
+
+  /**
+   *
+   * @param deadline
+   */
+  setDeadline(deadline: number) {
+    _deadline = deadline;
+  }
+};
+
+const _interactionSet = new Set();
+const _addInteractionSet = new Set();
+const _deleteInteractionSet = new Set();
+const _taskQueue = new TaskQueue({ onMoreTasks: _scheduleUpdate });
+let _nextUpdateHandle: TimeoutID | number = 0;
+let _inc = 0;
+let _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;
+  const interactionCount = _interactionSet.size;
+  _addInteractionSet.forEach((handle) => _interactionSet.add(handle));
+  _deleteInteractionSet.forEach((handle) => _interactionSet.delete(handle));
+  const 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.
+    const begin = Date.now();
+    while (_taskQueue.hasTasksToProcess()) {
+      _taskQueue.processNext();
+      if (_deadline > 0 && Date.now() - begin >= _deadline) {
+        _scheduleUpdate();
+        break;
+      }
+    }
+  }
+  _addInteractionSet.clear();
+  _deleteInteractionSet.clear();
+}
+
+export default InteractionManager;

package/src/exports/Keyboard/index.js

@@ -0,0 +1,28 @@
+/**
+ * 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 dismissKeyboard from '../../modules/dismissKeyboard';
+
+// in the future we can use https://github.com/w3c/virtual-keyboard
+const Keyboard = {
+  isVisible(): boolean {
+    return false;
+  },
+  addListener(): {| remove: () => void |} {
+    return { remove: () => {} };
+  },
+  dismiss() {
+    dismissKeyboard();
+  },
+  removeAllListeners() {},
+  removeListener() {}
+};
+
+export default Keyboard;

package/src/exports/KeyboardAvoidingView/index.js

@@ -0,0 +1,59 @@
+/**
+ * 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 { LayoutEvent, LayoutValue } from '../../types';
+import type { ViewProps } from '../View';
+
+import * as React from 'react';
+import View from '../View';
+
+type KeyboardAvoidingViewProps = {
+  ...ViewProps,
+  behavior?: 'height' | 'padding' | 'position',
+  contentContainerStyle?: $PropertyType<ViewProps, 'style'>,
+  keyboardVerticalOffset: number
+};
+
+class KeyboardAvoidingView extends React.Component<KeyboardAvoidingViewProps> {
+  frame: ?LayoutValue = null;
+
+  relativeKeyboardHeight(keyboardFrame: Object): number {
+    const frame = this.frame;
+    if (!frame || !keyboardFrame) {
+      return 0;
+    }
+    const keyboardY =
+      keyboardFrame.screenY - (this.props.keyboardVerticalOffset || 0);
+    return Math.max(frame.y + frame.height - keyboardY, 0);
+  }
+
+  onKeyboardChange(event: Object) {}
+
+  onLayout: (event: LayoutEvent) => void = (event: LayoutEvent) => {
+    this.frame = event.nativeEvent.layout;
+  };
+
+  render(): React.Node {
+    const {
+      /* eslint-disable */
+      behavior,
+      contentContainerStyle,
+      keyboardVerticalOffset,
+      /* eslint-enable */
+      ...rest
+    } = this.props;
+
+    return <View onLayout={this.onLayout} {...rest} />;
+  }
+}
+
+export default KeyboardAvoidingView;

package/src/exports/LayoutAnimation/index.js

@@ -0,0 +1,12 @@
+/**
+ * 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 LayoutAnimation from '../../vendor/react-native/LayoutAnimation';
+export default LayoutAnimation;

package/src/exports/Linking/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.
+ *
+ * @flow
+ */
+
+import invariant from 'fbjs/lib/invariant';
+import canUseDOM from '../../modules/canUseDom';
+
+const initialURL = canUseDOM ? window.location.href : '';
+
+type Callback = (...args: any) => void;
+
+class Linking {
+  /**
+   * An object mapping of event name
+   * and all the callbacks subscribing to it
+   */
+  _eventCallbacks: { [key: string]: Array<Callback> } = {};
+
+  _dispatchEvent(event: string, ...data: any) {
+    const listeners = this._eventCallbacks[event];
+    if (listeners != null && Array.isArray(listeners)) {
+      listeners.map((listener) => {
+        listener(...data);
+      });
+    }
+  }
+
+  /**
+   * Adds a event listener for the specified event. The callback will be called when the
+   * said event is dispatched.
+   */
+  addEventListener(
+    eventType: string,
+    callback: Callback
+  ): {| remove(): void |} {
+    const _this = this;
+
+    if (!_this._eventCallbacks[eventType]) {
+      _this._eventCallbacks[eventType] = [callback];
+    }
+    _this._eventCallbacks[eventType].push(callback);
+
+    return {
+      remove() {
+        const callbacks = _this._eventCallbacks[eventType];
+        const filteredCallbacks = callbacks.filter(
+          (c) => c.toString() !== callback.toString()
+        );
+        _this._eventCallbacks[eventType] = filteredCallbacks;
+      }
+    };
+  }
+
+  /**
+   * Removes a previously added event listener for the specified event. The callback must
+   * be the same object as the one passed to `addEventListener`.
+   */
+  removeEventListener(eventType: string, callback: Callback): void {
+    console.error(
+      `Linking.removeEventListener('${eventType}', ...): Method has been ` +
+        'deprecated. Please instead use `remove()` on the subscription ' +
+        'returned by `Linking.addEventListener`.'
+    );
+    const callbacks = this._eventCallbacks[eventType];
+    const filteredCallbacks = callbacks.filter(
+      (c) => c.toString() !== callback.toString()
+    );
+    this._eventCallbacks[eventType] = filteredCallbacks;
+  }
+
+  canOpenURL(): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+
+  getInitialURL(): Promise<string> {
+    return Promise.resolve(initialURL);
+  }
+
+  /**
+   * Try to open the given url in a secure fashion. The method returns a Promise object.
+   * If a target is passed (including undefined) that target will be used, otherwise '_blank'.
+   * If the url opens, the promise is resolved. If not, the promise is rejected.
+   * Dispatches the `onOpen` event if `url` is opened successfully.
+   */
+  openURL(url: string, target?: string): Promise<Object | void> {
+    if (arguments.length === 1) {
+      target = '_blank';
+    }
+    try {
+      open(url, target);
+      this._dispatchEvent('onOpen', url);
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  _validateURL(url: string) {
+    invariant(
+      typeof url === 'string',
+      'Invalid URL: should be a string. Was: ' + url
+    );
+    invariant(url, 'Invalid URL: cannot be empty');
+  }
+}
+
+const open = (url, target) => {
+  if (canUseDOM) {
+    const urlToOpen = new URL(url, window.location).toString();
+    if (urlToOpen.indexOf('tel:') === 0) {
+      window.location = urlToOpen;
+    } else {
+      window.open(urlToOpen, target, 'noopener');
+    }
+  }
+};
+
+export default (new Linking(): Linking);

package/src/exports/LogBox/index.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2016-present, Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+const LogBox = {
+  ignoreLogs() {},
+  ignoreAllLogs() {},
+  uninstall() {},
+  install() {}
+};
+
+export default LogBox;

package/src/exports/Modal/ModalAnimation.js

@@ -0,0 +1,164 @@
+/**
+ * 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 * as React from 'react';
+import StyleSheet from '../StyleSheet';
+import createElement from '../createElement';
+
+const ANIMATION_DURATION = 250;
+
+function getAnimationStyle(animationType, visible) {
+  if (animationType === 'slide') {
+    return visible ? animatedSlideInStyles : animatedSlideOutStyles;
+  }
+  if (animationType === 'fade') {
+    return visible ? animatedFadeInStyles : animatedFadeOutStyles;
+  }
+  return visible ? styles.container : styles.hidden;
+}
+
+export type ModalAnimationProps = {|
+  animationType?: ?('none' | 'slide' | 'fade'),
+  children?: any,
+  onDismiss?: ?() => void,
+  onShow?: ?() => void,
+  visible?: ?boolean
+|};
+
+function ModalAnimation(props: ModalAnimationProps): React.Node {
+  const { animationType, children, onDismiss, onShow, visible } = props;
+
+  const [isRendering, setIsRendering] = React.useState(false);
+  const wasVisible = React.useRef(false);
+  const wasRendering = React.useRef(false);
+
+  const isAnimated = animationType && animationType !== 'none';
+
+  const animationEndCallback = React.useCallback(
+    (e: any) => {
+      if (e && e.currentTarget !== e.target) {
+        // If the event was generated for something NOT this element we
+        // should ignore it as it's not relevant to us
+        return;
+      }
+
+      if (visible) {
+        if (onShow) {
+          onShow();
+        }
+      } else {
+        setIsRendering(false);
+      }
+    },
+    [onShow, visible]
+  );
+
+  React.useEffect(() => {
+    if (wasRendering.current && !isRendering && onDismiss) {
+      onDismiss();
+    }
+    wasRendering.current = isRendering;
+  }, [isRendering, onDismiss]);
+
+  React.useEffect(() => {
+    if (visible) {
+      setIsRendering(true);
+    }
+    if (visible !== wasVisible.current && !isAnimated) {
+      // Manually call `animationEndCallback` if no animation is used
+      animationEndCallback();
+    }
+    wasVisible.current = visible;
+  }, [isAnimated, visible, animationEndCallback]);
+
+  return isRendering || visible
+    ? createElement('div', {
+        style: isRendering
+          ? getAnimationStyle(animationType, visible)
+          : styles.hidden,
+        onAnimationEnd: animationEndCallback,
+        children
+      })
+    : null;
+}
+
+const styles = StyleSheet.create({
+  container: {
+    position: 'fixed',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    zIndex: 9999
+  },
+  animatedIn: {
+    animationDuration: `${ANIMATION_DURATION}ms`,
+    animationTimingFunction: 'cubic-bezier(0.215, 0.61, 0.355, 1)'
+  },
+  animatedOut: {
+    pointerEvents: 'none',
+    animationDuration: `${ANIMATION_DURATION}ms`,
+    animationTimingFunction: 'cubic-bezier(0.47, 0, 0.745, 0.715)'
+  },
+  fadeIn: {
+    opacity: 1,
+    animationKeyframes: {
+      '0%': { opacity: 0 },
+      '100%': { opacity: 1 }
+    }
+  },
+  fadeOut: {
+    opacity: 0,
+    animationKeyframes: {
+      '0%': { opacity: 1 },
+      '100%': { opacity: 0 }
+    }
+  },
+  slideIn: {
+    transform: 'translateY(0%)',
+    animationKeyframes: {
+      '0%': { transform: 'translateY(100%)' },
+      '100%': { transform: 'translateY(0%)' }
+    }
+  },
+  slideOut: {
+    transform: 'translateY(100%)',
+    animationKeyframes: {
+      '0%': { transform: 'translateY(0%)' },
+      '100%': { transform: 'translateY(100%)' }
+    }
+  },
+  hidden: {
+    opacity: 0
+  }
+});
+
+const animatedSlideInStyles = [
+  styles.container,
+  styles.animatedIn,
+  styles.slideIn
+];
+const animatedSlideOutStyles = [
+  styles.container,
+  styles.animatedOut,
+  styles.slideOut
+];
+const animatedFadeInStyles = [
+  styles.container,
+  styles.animatedIn,
+  styles.fadeIn
+];
+const animatedFadeOutStyles = [
+  styles.container,
+  styles.animatedOut,
+  styles.fadeOut
+];
+
+export default ModalAnimation;