react-native-web-tv 0.21.2-tv.10

package/dist/exports/Linking/index.js

@@ -0,0 +1,103 @@
+/**
+ * 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 canUseDOM from '../../modules/canUseDom';
+var initialURL = canUseDOM ? window.location.href : '';
+class Linking {
+  constructor() {
+    /**
+     * An object mapping of event name
+     * and all the callbacks subscribing to it
+     */
+    this._eventCallbacks = {};
+  }
+  _dispatchEvent(event) {
+    for (var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      data[_key - 1] = arguments[_key];
+    }
+    var 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, callback) {
+    var _this = this;
+    if (!_this._eventCallbacks[eventType]) {
+      _this._eventCallbacks[eventType] = [callback];
+    }
+    _this._eventCallbacks[eventType].push(callback);
+    return {
+      remove() {
+        var callbacks = _this._eventCallbacks[eventType];
+        var 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, callback) {
+    console.error("Linking.removeEventListener('" + eventType + "', ...): Method has been " + 'deprecated. Please instead use `remove()` on the subscription ' + 'returned by `Linking.addEventListener`.');
+    var callbacks = this._eventCallbacks[eventType];
+    var filteredCallbacks = callbacks.filter(c => c.toString() !== callback.toString());
+    this._eventCallbacks[eventType] = filteredCallbacks;
+  }
+  canOpenURL() {
+    return Promise.resolve(true);
+  }
+  getInitialURL() {
+    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, target) {
+    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) {
+    invariant(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
+    invariant(url, 'Invalid URL: cannot be empty');
+  }
+}
+var open = (url, target) => {
+  if (canUseDOM) {
+    var 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();

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

@@ -0,0 +1,30 @@
+/**
+ * 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;
+declare class Linking {
+  _eventCallbacks: {
+    [key: string]: Array<Callback>
+  },
+  _dispatchEvent(event: string, ...data: any): any,
+  addEventListener(eventType: string, callback: Callback): {|
+    remove(): void
+  |},
+  removeEventListener(eventType: string, callback: Callback): void,
+  canOpenURL(): Promise<boolean>,
+  getInitialURL(): Promise<string>,
+  openURL(url: string, target?: string): Promise<Object | void>,
+  _validateURL(url: string): any,
+}
+declare var open: (url: any, target: any) => any;
+export default (new Linking(): Linking);

package/dist/exports/LogBox/index.js

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ *
+ * 
+ */
+
+var LogBox = {
+  ignoreLogs() {},
+  ignoreAllLogs() {},
+  uninstall() {},
+  install() {}
+};
+export default LogBox;

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

@@ -0,0 +1,16 @@
+/**
+ * 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/dist/exports/Modal/ModalAnimation.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.
+ *
+ * 
+ */
+
+import * as React from 'react';
+import StyleSheet from '../StyleSheet';
+import createElement from '../createElement';
+var 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;
+}
+function ModalAnimation(props) {
+  var animationType = props.animationType,
+    children = props.children,
+    onDismiss = props.onDismiss,
+    onShow = props.onShow,
+    visible = props.visible;
+  var _React$useState = React.useState(false),
+    isRendering = _React$useState[0],
+    setIsRendering = _React$useState[1];
+  var wasVisible = React.useRef(false);
+  var wasRendering = React.useRef(false);
+  var isAnimated = animationType && animationType !== 'none';
+  var animationEndCallback = React.useCallback(e => {
+    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;
+}
+var 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
+  }
+});
+var animatedSlideInStyles = [styles.container, styles.animatedIn, styles.slideIn];
+var animatedSlideOutStyles = [styles.container, styles.animatedOut, styles.slideOut];
+var animatedFadeInStyles = [styles.container, styles.animatedIn, styles.fadeIn];
+var animatedFadeOutStyles = [styles.container, styles.animatedOut, styles.fadeOut];
+export default ModalAnimation;

package/dist/exports/Modal/ModalAnimation.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 * as React from 'react';
+import StyleSheet from '../StyleSheet';
+import createElement from '../createElement';
+const ANIMATION_DURATION = 250;
+declare function getAnimationStyle(animationType: any, visible: any): any;
+export type ModalAnimationProps = {|
+  animationType?: ?('none' | 'slide' | 'fade'),
+  children?: any,
+  onDismiss?: ?() => void,
+  onShow?: ?() => void,
+  visible?: ?boolean,
+|};
+declare function ModalAnimation(props: ModalAnimationProps): React.Node;
+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;

package/dist/exports/Modal/ModalContent.js

@@ -0,0 +1,72 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+var _excluded = ["active", "children", "onRequestClose", "transparent"];
+/**
+ * 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 * as React from 'react';
+import View from '../View';
+import StyleSheet from '../StyleSheet';
+import canUseDOM from '../../modules/canUseDom';
+import { jsx as _jsx } from "react/jsx-runtime";
+var ModalContent = /*#__PURE__*/React.forwardRef((props, forwardedRef) => {
+  var active = props.active,
+    children = props.children,
+    onRequestClose = props.onRequestClose,
+    transparent = props.transparent,
+    rest = _objectWithoutPropertiesLoose(props, _excluded);
+  React.useEffect(() => {
+    if (canUseDOM) {
+      var closeOnEscape = e => {
+        if (active && e.key === 'Escape') {
+          e.stopPropagation();
+          if (onRequestClose) {
+            onRequestClose();
+          }
+        }
+      };
+      document.addEventListener('keyup', closeOnEscape, false);
+      return () => document.removeEventListener('keyup', closeOnEscape, false);
+    }
+  }, [active, onRequestClose]);
+  var style = React.useMemo(() => {
+    return [styles.modal, transparent ? styles.modalTransparent : styles.modalOpaque];
+  }, [transparent]);
+  return /*#__PURE__*/_jsx(View, _objectSpread(_objectSpread({}, rest), {}, {
+    "aria-modal": true,
+    ref: forwardedRef,
+    role: active ? 'dialog' : null,
+    style: style,
+    children: /*#__PURE__*/_jsx(View, {
+      style: styles.container,
+      children: children
+    })
+  }));
+});
+var styles = StyleSheet.create({
+  modal: {
+    position: 'fixed',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  },
+  modalTransparent: {
+    backgroundColor: 'transparent'
+  },
+  modalOpaque: {
+    backgroundColor: 'white'
+  },
+  container: {
+    top: 0,
+    flex: 1
+  }
+});
+export default ModalContent;

package/dist/exports/Modal/ModalContent.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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 { ViewProps } from '../View';
+import * as React from 'react';
+import View from '../View';
+import StyleSheet from '../StyleSheet';
+import canUseDOM from '../../modules/canUseDom';
+export type ModalContentProps = {
+  ...ViewProps,
+  active?: ?(boolean | (() => boolean)),
+  children?: any,
+  onRequestClose?: ?() => void,
+  transparent?: ?boolean,
+};
+const ModalContent: React.AbstractComponent<ModalContentProps, React.ElementRef<typeof View>> = React.forwardRef((props, forwardedRef) => {
+  const {
+    active,
+    children,
+    onRequestClose,
+    transparent,
+    ...rest
+  } = props;
+  React.useEffect(() => {
+    if (canUseDOM) {
+      declare var closeOnEscape: (e: KeyboardEvent) => any;
+      document.addEventListener('keyup', closeOnEscape, false);
+      return () => document.removeEventListener('keyup', closeOnEscape, false);
+    }
+  }, [active, onRequestClose]);
+  const style = React.useMemo(() => {
+    return [styles.modal, transparent ? styles.modalTransparent : styles.modalOpaque];
+  }, [transparent]);
+  return <View {...rest} aria-modal={true} ref={forwardedRef} role={active ? 'dialog' : null} style={style}>
+      <View style={styles.container}>{children}</View>
+    </View>;
+});
+const styles = StyleSheet.create({
+  modal: {
+    position: 'fixed',
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0
+  },
+  modalTransparent: {
+    backgroundColor: 'transparent'
+  },
+  modalOpaque: {
+    backgroundColor: 'white'
+  },
+  container: {
+    top: 0,
+    flex: 1
+  }
+});
+export default ModalContent;

package/dist/exports/Modal/ModalFocusTrap.js

@@ -0,0 +1,135 @@
+/**
+ * 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 * as React from 'react';
+import View from '../View';
+import createElement from '../createElement';
+import StyleSheet from '../StyleSheet';
+import UIManager from '../UIManager';
+import canUseDOM from '../../modules/canUseDom';
+
+/**
+ * This Component is used to "wrap" the modal we're opening
+ * so that changing focus via tab will never leave the document.
+ *
+ * This allows us to properly trap the focus within a modal
+ * even if the modal is at the start or end of a document.
+ */
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+var FocusBracket = () => {
+  return createElement('div', {
+    role: 'none',
+    tabIndex: 0,
+    style: styles.focusBracket
+  });
+};
+function attemptFocus(element) {
+  if (!canUseDOM) {
+    return false;
+  }
+  try {
+    element.focus();
+  } catch (e) {
+    // Do nothing
+  }
+  return document.activeElement === element;
+}
+function focusFirstDescendant(element) {
+  for (var i = 0; i < element.childNodes.length; i++) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusFirstDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function focusLastDescendant(element) {
+  for (var i = element.childNodes.length - 1; i >= 0; i--) {
+    var child = element.childNodes[i];
+    if (attemptFocus(child) || focusLastDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+var ModalFocusTrap = _ref => {
+  var active = _ref.active,
+    children = _ref.children;
+  var trapElementRef = React.useRef();
+  var focusRef = React.useRef({
+    trapFocusInProgress: false,
+    lastFocusedElement: null
+  });
+  React.useEffect(() => {
+    if (canUseDOM) {
+      var trapFocus = () => {
+        // We should not trap focus if:
+        // - The modal hasn't fully initialized with an HTMLElement ref
+        // - Focus is already in the process of being trapped (e.g., we're refocusing)
+        // - isTrapActive prop being falsey tells us to do nothing
+        if (trapElementRef.current == null || focusRef.current.trapFocusInProgress || !active) {
+          return;
+        }
+        try {
+          focusRef.current.trapFocusInProgress = true;
+          if (document.activeElement instanceof Node && !trapElementRef.current.contains(document.activeElement)) {
+            // To handle keyboard focusing we can make an assumption here.
+            // If you're tabbing through the focusable elements, the previously
+            // active element will either be the first or the last.
+            // If the previously selected element is the "first" descendant
+            // and we're leaving it - this means that we should be looping
+            // around to the other side of the modal.
+            var hasFocused = focusFirstDescendant(trapElementRef.current);
+            if (focusRef.current.lastFocusedElement === document.activeElement) {
+              hasFocused = focusLastDescendant(trapElementRef.current);
+            }
+            // If we couldn't focus a new element then we need to focus onto the trap target
+            if (!hasFocused && trapElementRef.current != null && document.activeElement) {
+              UIManager.focus(trapElementRef.current);
+            }
+          }
+        } finally {
+          focusRef.current.trapFocusInProgress = false;
+        }
+        focusRef.current.lastFocusedElement = document.activeElement;
+      };
+
+      // Call the trapFocus callback at least once when this modal has been activated.
+      trapFocus();
+      document.addEventListener('focus', trapFocus, true);
+      return () => document.removeEventListener('focus', trapFocus, true);
+    }
+  }, [active]);
+
+  // To be fully compliant with WCAG we need to refocus element that triggered opening modal
+  // after closing it
+  React.useEffect(function () {
+    if (canUseDOM) {
+      var lastFocusedElementOutsideTrap = document.activeElement;
+      return function () {
+        if (lastFocusedElementOutsideTrap && document.contains(lastFocusedElementOutsideTrap)) {
+          UIManager.focus(lastFocusedElementOutsideTrap);
+        }
+      };
+    }
+  }, []);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(FocusBracket, {}), /*#__PURE__*/_jsx(View, {
+      ref: trapElementRef,
+      children: children
+    }), /*#__PURE__*/_jsx(FocusBracket, {})]
+  });
+};
+export default ModalFocusTrap;
+var styles = StyleSheet.create({
+  focusBracket: {
+    outlineStyle: 'none'
+  }
+});