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

package/dist/modules/unitlessNumbers/index.js

@@ -0,0 +1,75 @@
+/**
+ * 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.
+ *
+ * 
+ */
+
+var unitlessNumbers = {
+  animationIterationCount: true,
+  aspectRatio: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  flex: true,
+  flexGrow: true,
+  flexOrder: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  fontWeight: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowGap: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnGap: true,
+  gridColumnStart: true,
+  lineClamp: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true,
+  // transform types
+  scale: true,
+  scaleX: true,
+  scaleY: true,
+  scaleZ: true,
+  // RN properties
+  shadowOpacity: true
+};
+
+/**
+ * Support style names that may come passed in prefixed by adding permutations
+ * of vendor prefixes.
+ */
+var prefixes = ['ms', 'Moz', 'O', 'Webkit'];
+var prefixKey = (prefix, key) => {
+  return prefix + key.charAt(0).toUpperCase() + key.substring(1);
+};
+Object.keys(unitlessNumbers).forEach(prop => {
+  prefixes.forEach(prefix => {
+    unitlessNumbers[prefixKey(prefix, prop)] = unitlessNumbers[prop];
+  });
+});
+export default unitlessNumbers;

package/dist/modules/unitlessNumbers/index.js.flow

@@ -0,0 +1,73 @@
+/**
+ * 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
+ */
+
+const unitlessNumbers = {
+  animationIterationCount: true,
+  aspectRatio: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  flex: true,
+  flexGrow: true,
+  flexOrder: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  fontWeight: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowGap: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnGap: true,
+  gridColumnStart: true,
+  lineClamp: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true,
+  // transform types
+  scale: true,
+  scaleX: true,
+  scaleY: true,
+  scaleZ: true,
+  // RN properties
+  shadowOpacity: true
+};
+
+/**
+ * Support style names that may come passed in prefixed by adding permutations
+ * of vendor prefixes.
+ */
+const prefixes = ['ms', 'Moz', 'O', 'Webkit'];
+declare var prefixKey: (prefix: string, key: string) => any;
+Object.keys(unitlessNumbers).forEach(prop => {
+  prefixes.forEach(prefix => {
+    unitlessNumbers[prefixKey(prefix, prop)] = unitlessNumbers[prop];
+  });
+});
+export default unitlessNumbers;

package/dist/modules/useElementLayout/index.js

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import useLayoutEffect from '../useLayoutEffect';
+import UIManager from '../../exports/UIManager';
+import canUseDOM from '../canUseDom';
+var DOM_LAYOUT_HANDLER_NAME = '__reactLayoutHandler';
+var didWarn = !canUseDOM;
+var resizeObserver = null;
+function getResizeObserver() {
+  if (canUseDOM && typeof window.ResizeObserver !== 'undefined') {
+    if (resizeObserver == null) {
+      resizeObserver = new window.ResizeObserver(function (entries) {
+        entries.forEach(entry => {
+          var node = entry.target;
+          var onLayout = node[DOM_LAYOUT_HANDLER_NAME];
+          if (typeof onLayout === 'function') {
+            // We still need to measure the view because browsers don't yet provide
+            // border-box dimensions in the entry
+            UIManager.measure(node, (x, y, width, height, left, top) => {
+              var event = {
+                // $FlowFixMe
+                nativeEvent: {
+                  layout: {
+                    x,
+                    y,
+                    width,
+                    height,
+                    left,
+                    top
+                  }
+                },
+                timeStamp: Date.now()
+              };
+              Object.defineProperty(event.nativeEvent, 'target', {
+                enumerable: true,
+                get: () => entry.target
+              });
+              onLayout(event);
+            });
+          }
+        });
+      });
+    }
+  } else if (!didWarn) {
+    if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test') {
+      console.warn('onLayout relies on ResizeObserver which is not supported by your browser. ' + 'Please include a polyfill, e.g., https://github.com/que-etc/resize-observer-polyfill.');
+      didWarn = true;
+    }
+  }
+  return resizeObserver;
+}
+export default function useElementLayout(ref, onLayout) {
+  var observer = getResizeObserver();
+  useLayoutEffect(() => {
+    var node = ref.current;
+    if (node != null) {
+      node[DOM_LAYOUT_HANDLER_NAME] = onLayout;
+    }
+  }, [ref, onLayout]);
+
+  // Observing is done in a separate effect to avoid this effect running
+  // when 'onLayout' changes.
+  useLayoutEffect(() => {
+    var node = ref.current;
+    if (node != null && observer != null) {
+      if (typeof node[DOM_LAYOUT_HANDLER_NAME] === 'function') {
+        observer.observe(node);
+      } else {
+        observer.unobserve(node);
+      }
+    }
+    return () => {
+      if (node != null && observer != null) {
+        observer.unobserve(node);
+      }
+    };
+  }, [ref, observer]);
+}

package/dist/modules/useElementLayout/index.js.flow

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 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
+ */
+
+import type { ElementRef } from 'react';
+import type { LayoutEvent } from '../../types';
+import useLayoutEffect from '../useLayoutEffect';
+import UIManager from '../../exports/UIManager';
+import canUseDOM from '../canUseDom';
+const DOM_LAYOUT_HANDLER_NAME = '__reactLayoutHandler';
+let didWarn = !canUseDOM;
+let resizeObserver = null;
+declare function getResizeObserver(): ?ResizeObserver;
+declare export default function useElementLayout(ref: ElementRef<any>, onLayout?: ?(e: LayoutEvent) => void): any;

package/dist/modules/useEvent/index.js

@@ -0,0 +1,48 @@
+/**
+ * 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 { addEventListener } from '../addEventListener';
+import useLayoutEffect from '../useLayoutEffect';
+import useStable from '../useStable';
+/**
+ * This can be used with any event type include custom events.
+ *
+ * const click = useEvent('click', options);
+ * useEffect(() => {
+ *   click.setListener(target, onClick);
+ *   return () => click.clear();
+ * }).
+ */
+export default function useEvent(eventType, options) {
+  var targetListeners = useStable(() => new Map());
+  var addListener = useStable(() => {
+    return (target, callback) => {
+      var removeTargetListener = targetListeners.get(target);
+      if (removeTargetListener != null) {
+        removeTargetListener();
+      }
+      if (callback == null) {
+        targetListeners.delete(target);
+        callback = () => {};
+      }
+      var removeEventListener = addEventListener(target, eventType, callback, options);
+      targetListeners.set(target, removeEventListener);
+      return removeEventListener;
+    };
+  });
+  useLayoutEffect(() => {
+    return () => {
+      targetListeners.forEach(removeListener => {
+        removeListener();
+      });
+      targetListeners.clear();
+    };
+  }, [targetListeners]);
+  return addListener;
+}

package/dist/modules/useEvent/index.js.flow

@@ -0,0 +1,29 @@
+/**
+ * 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 { addEventListener } from '../addEventListener';
+import useLayoutEffect from '../useLayoutEffect';
+import useStable from '../useStable';
+type Callback = null | ((any) => void);
+type AddListener = (target: EventTarget, listener: null | ((any) => void)) => () => void;
+
+/**
+ * This can be used with any event type include custom events.
+ *
+ * const click = useEvent('click', options);
+ * useEffect(() => {
+ *   click.setListener(target, onClick);
+ *   return () => click.clear();
+ * }).
+ */
+declare export default function useEvent(eventType: string, options?: ?{
+  capture?: boolean,
+  passive?: boolean,
+  once?: boolean,
+}): AddListener;

package/dist/modules/useHover/index.js

@@ -0,0 +1,153 @@
+/**
+ * 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 { getModality } from '../modality';
+import useEvent from '../useEvent';
+import useLayoutEffect from '../useLayoutEffect';
+
+/**
+ * Types
+ */
+
+/**
+ * Implementation
+ */
+
+var emptyObject = {};
+var opts = {
+  passive: true
+};
+var lockEventType = 'react-gui:hover:lock';
+var unlockEventType = 'react-gui:hover:unlock';
+var supportsPointerEvent = () => !!(typeof window !== 'undefined' && window.PointerEvent != null);
+function dispatchCustomEvent(target, type, payload) {
+  var event = document.createEvent('CustomEvent');
+  var _ref = payload || emptyObject,
+    _ref$bubbles = _ref.bubbles,
+    bubbles = _ref$bubbles === void 0 ? true : _ref$bubbles,
+    _ref$cancelable = _ref.cancelable,
+    cancelable = _ref$cancelable === void 0 ? true : _ref$cancelable,
+    detail = _ref.detail;
+  event.initCustomEvent(type, bubbles, cancelable, detail);
+  target.dispatchEvent(event);
+}
+
+// This accounts for the non-PointerEvent fallback events.
+function getPointerType(event) {
+  var pointerType = event.pointerType;
+  return pointerType != null ? pointerType : getModality();
+}
+export default function useHover(targetRef, config) {
+  var contain = config.contain,
+    disabled = config.disabled,
+    onHoverStart = config.onHoverStart,
+    onHoverChange = config.onHoverChange,
+    onHoverUpdate = config.onHoverUpdate,
+    onHoverEnd = config.onHoverEnd;
+  var canUsePE = supportsPointerEvent();
+  var addMoveListener = useEvent(canUsePE ? 'pointermove' : 'mousemove', opts);
+  var addEnterListener = useEvent(canUsePE ? 'pointerenter' : 'mouseenter', opts);
+  var addLeaveListener = useEvent(canUsePE ? 'pointerleave' : 'mouseleave', opts);
+  // These custom events are used to implement the "contain" prop.
+  var addLockListener = useEvent(lockEventType, opts);
+  var addUnlockListener = useEvent(unlockEventType, opts);
+  useLayoutEffect(() => {
+    var target = targetRef.current;
+    if (target !== null) {
+      /**
+       * End the hover gesture
+       */
+      var hoverEnd = function hoverEnd(e) {
+        if (onHoverEnd != null) {
+          onHoverEnd(e);
+        }
+        if (onHoverChange != null) {
+          onHoverChange(false);
+        }
+        // Remove the listeners once finished.
+        addMoveListener(target, null);
+        addLeaveListener(target, null);
+      };
+
+      /**
+       * Leave element
+       */
+      var leaveListener = function leaveListener(e) {
+        var target = targetRef.current;
+        if (target != null && getPointerType(e) !== 'touch') {
+          if (contain) {
+            dispatchCustomEvent(target, unlockEventType);
+          }
+          hoverEnd(e);
+        }
+      };
+
+      /**
+       * Move within element
+       */
+      var moveListener = function moveListener(e) {
+        if (getPointerType(e) !== 'touch') {
+          if (onHoverUpdate != null) {
+            // Not all browsers have these properties
+            if (e.x == null) {
+              e.x = e.clientX;
+            }
+            if (e.y == null) {
+              e.y = e.clientY;
+            }
+            onHoverUpdate(e);
+          }
+        }
+      };
+
+      /**
+       * Start the hover gesture
+       */
+      var hoverStart = function hoverStart(e) {
+        if (onHoverStart != null) {
+          onHoverStart(e);
+        }
+        if (onHoverChange != null) {
+          onHoverChange(true);
+        }
+        // Set the listeners needed for the rest of the hover gesture.
+        if (onHoverUpdate != null) {
+          addMoveListener(target, !disabled ? moveListener : null);
+        }
+        addLeaveListener(target, !disabled ? leaveListener : null);
+      };
+
+      /**
+       * Enter element
+       */
+      var enterListener = function enterListener(e) {
+        var target = targetRef.current;
+        if (target != null && getPointerType(e) !== 'touch') {
+          if (contain) {
+            dispatchCustomEvent(target, lockEventType);
+          }
+          hoverStart(e);
+          var lockListener = function lockListener(lockEvent) {
+            if (lockEvent.target !== target) {
+              hoverEnd(e);
+            }
+          };
+          var unlockListener = function unlockListener(lockEvent) {
+            if (lockEvent.target !== target) {
+              hoverStart(e);
+            }
+          };
+          addLockListener(target, !disabled ? lockListener : null);
+          addUnlockListener(target, !disabled ? unlockListener : null);
+        }
+      };
+      addEnterListener(target, !disabled ? enterListener : null);
+    }
+  }, [addEnterListener, addMoveListener, addLeaveListener, addLockListener, addUnlockListener, contain, disabled, onHoverStart, onHoverChange, onHoverUpdate, onHoverEnd, targetRef]);
+}

package/dist/modules/useHover/index.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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 { getModality } from '../modality';
+import useEvent from '../useEvent';
+import useLayoutEffect from '../useLayoutEffect';
+
+/**
+ * Types
+ */
+
+export type HoverEventsConfig = {
+  contain?: ?boolean,
+  disabled?: ?boolean,
+  onHoverStart?: ?(e: any) => void,
+  onHoverChange?: ?(bool: boolean) => void,
+  onHoverUpdate?: ?(e: any) => void,
+  onHoverEnd?: ?(e: any) => void,
+};
+
+/**
+ * Implementation
+ */
+
+const emptyObject = {};
+const opts = {
+  passive: true
+};
+const lockEventType = 'react-gui:hover:lock';
+const unlockEventType = 'react-gui:hover:unlock';
+declare var supportsPointerEvent: () => any;
+declare function dispatchCustomEvent(target: EventTarget, type: string, payload?: {
+  bubbles?: boolean,
+  cancelable?: boolean,
+  detail?: {
+    [key: string]: mixed
+  },
+}): any; // This accounts for the non-PointerEvent fallback events.
+declare function getPointerType(event: any): any;
+declare export default function useHover(targetRef: any, config: HoverEventsConfig): void;

package/dist/modules/useLayoutEffect/index.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * useLayoutEffect throws an error on the server. On the few occasions where is
+ * problematic, use this hook.
+ *
+ * 
+ */
+
+import { useEffect, useLayoutEffect } from 'react';
+import canUseDOM from '../canUseDom';
+var useLayoutEffectImpl = canUseDOM ? useLayoutEffect : useEffect;
+export default useLayoutEffectImpl;

package/dist/modules/useLayoutEffect/index.js.flow

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * useLayoutEffect throws an error on the server. On the few occasions where is
+ * problematic, use this hook.
+ *
+ * @flow
+ */
+
+import { useEffect, useLayoutEffect } from 'react';
+import canUseDOM from '../canUseDom';
+const useLayoutEffectImpl: typeof useLayoutEffect = canUseDOM ? useLayoutEffect : useEffect;
+export default useLayoutEffectImpl;

package/dist/modules/useLocale/index.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+import React, { createContext, useContext } from 'react';
+import { isLocaleRTL } from './isLocaleRTL';
+var defaultLocale = {
+  direction: 'ltr',
+  locale: 'en-US'
+};
+var LocaleContext = /*#__PURE__*/createContext(defaultLocale);
+export function getLocaleDirection(locale) {
+  return isLocaleRTL(locale) ? 'rtl' : 'ltr';
+}
+export function LocaleProvider(props) {
+  var direction = props.direction,
+    locale = props.locale,
+    children = props.children;
+  var needsContext = direction || locale;
+  return needsContext ? /*#__PURE__*/React.createElement(LocaleContext.Provider, {
+    children: children,
+    value: {
+      direction: locale ? getLocaleDirection(locale) : direction,
+      locale
+    }
+  }) : children;
+}
+export function useLocaleContext() {
+  return useContext(LocaleContext);
+}

package/dist/modules/useLocale/index.js.flow

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 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 strict
+ */
+
+import type { Node } from 'react';
+import React, { createContext, useContext } from 'react';
+import { isLocaleRTL } from './isLocaleRTL';
+type Locale = string;
+type WritingDirection = 'ltr' | 'rtl';
+type LocaleValue = {
+  // Locale writing direction.
+  direction: WritingDirection,
+  // Locale BCP47 language code: https://www.ietf.org/rfc/bcp/bcp47.txt
+  locale: ?Locale,
+};
+type ProviderProps = {
+  ...LocaleValue,
+  children: any,
+};
+const defaultLocale = {
+  direction: 'ltr',
+  locale: 'en-US'
+};
+const LocaleContext = createContext<LocaleValue>(defaultLocale);
+declare export function getLocaleDirection(locale: Locale): WritingDirection;
+declare export function LocaleProvider(props: ProviderProps): Node;
+declare export function useLocaleContext(): LocaleValue;