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

package/dist/modules/useResponderEvents/index.js

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ *
+ * 
+ */
+
+/**
+ * Hook for integrating the Responder System into React
+ *
+ *   function SomeComponent({ onStartShouldSetResponder }) {
+ *     const ref = useRef(null);
+ *     useResponderEvents(ref, { onStartShouldSetResponder });
+ *     return <div ref={ref} />
+ *   }
+ */
+
+import * as React from 'react';
+import * as ResponderSystem from './ResponderSystem';
+var emptyObject = {};
+var idCounter = 0;
+function useStable(getInitialValue) {
+  var ref = React.useRef(null);
+  if (ref.current == null) {
+    ref.current = getInitialValue();
+  }
+  return ref.current;
+}
+export default function useResponderEvents(hostRef, config) {
+  if (config === void 0) {
+    config = emptyObject;
+  }
+  var id = useStable(() => idCounter++);
+  var isAttachedRef = React.useRef(false);
+
+  // This is a separate effects so it doesn't run when the config changes.
+  // On initial mount, attach global listeners if needed.
+  // On unmount, remove node potentially attached to the Responder System.
+  React.useEffect(() => {
+    ResponderSystem.attachListeners();
+    return () => {
+      ResponderSystem.removeNode(id);
+    };
+  }, [id]);
+
+  // Register and unregister with the Responder System as necessary
+  React.useEffect(() => {
+    var _config = config,
+      onMoveShouldSetResponder = _config.onMoveShouldSetResponder,
+      onMoveShouldSetResponderCapture = _config.onMoveShouldSetResponderCapture,
+      onScrollShouldSetResponder = _config.onScrollShouldSetResponder,
+      onScrollShouldSetResponderCapture = _config.onScrollShouldSetResponderCapture,
+      onSelectionChangeShouldSetResponder = _config.onSelectionChangeShouldSetResponder,
+      onSelectionChangeShouldSetResponderCapture = _config.onSelectionChangeShouldSetResponderCapture,
+      onStartShouldSetResponder = _config.onStartShouldSetResponder,
+      onStartShouldSetResponderCapture = _config.onStartShouldSetResponderCapture;
+    var requiresResponderSystem = onMoveShouldSetResponder != null || onMoveShouldSetResponderCapture != null || onScrollShouldSetResponder != null || onScrollShouldSetResponderCapture != null || onSelectionChangeShouldSetResponder != null || onSelectionChangeShouldSetResponderCapture != null || onStartShouldSetResponder != null || onStartShouldSetResponderCapture != null;
+    var node = hostRef.current;
+    if (requiresResponderSystem) {
+      ResponderSystem.addNode(id, node, config);
+      isAttachedRef.current = true;
+    } else if (isAttachedRef.current) {
+      ResponderSystem.removeNode(id);
+      isAttachedRef.current = false;
+    }
+  }, [config, hostRef, id]);
+  React.useDebugValue({
+    isResponder: hostRef.current === ResponderSystem.getResponderNode()
+  });
+  React.useDebugValue(config);
+}

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

@@ -0,0 +1,26 @@
+/**
+ * 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
+ */
+
+/**
+ * Hook for integrating the Responder System into React
+ *
+ *   function SomeComponent({ onStartShouldSetResponder }) {
+ *     const ref = useRef(null);
+ *     useResponderEvents(ref, { onStartShouldSetResponder });
+ *     return <div ref={ref} />
+ *   }
+ */
+
+import type { ResponderConfig } from './ResponderSystem';
+import * as React from 'react';
+import * as ResponderSystem from './ResponderSystem';
+const emptyObject = {};
+let idCounter = 0;
+declare function useStable<T>(getInitialValue: () => T): T;
+declare export default function useResponderEvents(hostRef: any, config: ResponderConfig): any;

package/dist/modules/useResponderEvents/utils.js

@@ -0,0 +1,165 @@
+/**
+ * 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 isSelectionValid from '../../modules/isSelectionValid';
+var keyName = '__reactResponderId';
+function getEventPath(domEvent) {
+  // The 'selectionchange' event always has the 'document' as the target.
+  // Use the anchor node as the initial target to reconstruct a path.
+  // (We actually only need the first "responder" node in practice.)
+  if (domEvent.type === 'selectionchange') {
+    var target = window.getSelection().anchorNode;
+    return composedPathFallback(target);
+  } else {
+    var path = domEvent.composedPath != null ? domEvent.composedPath() : composedPathFallback(domEvent.target);
+    return path;
+  }
+}
+function composedPathFallback(target) {
+  var path = [];
+  while (target != null && target !== document.body) {
+    path.push(target);
+    target = target.parentNode;
+  }
+  return path;
+}
+
+/**
+ * Retrieve the responderId from a host node
+ */
+function getResponderId(node) {
+  if (node != null) {
+    return node[keyName];
+  }
+  return null;
+}
+
+/**
+ * Store the responderId on a host node
+ */
+export function setResponderId(node, id) {
+  if (node != null) {
+    node[keyName] = id;
+  }
+}
+
+/**
+ * Filter the event path to contain only the nodes attached to the responder system
+ */
+export function getResponderPaths(domEvent) {
+  var idPath = [];
+  var nodePath = [];
+  var eventPath = getEventPath(domEvent);
+  for (var i = 0; i < eventPath.length; i++) {
+    var node = eventPath[i];
+    var id = getResponderId(node);
+    if (id != null) {
+      idPath.push(id);
+      nodePath.push(node);
+    }
+  }
+  return {
+    idPath,
+    nodePath
+  };
+}
+
+/**
+ * Walk the paths and find the first common ancestor
+ */
+export function getLowestCommonAncestor(pathA, pathB) {
+  var pathALength = pathA.length;
+  var pathBLength = pathB.length;
+  if (
+  // If either path is empty
+  pathALength === 0 || pathBLength === 0 ||
+  // If the last elements aren't the same there can't be a common ancestor
+  // that is connected to the responder system
+  pathA[pathALength - 1] !== pathB[pathBLength - 1]) {
+    return null;
+  }
+  var itemA = pathA[0];
+  var indexA = 0;
+  var itemB = pathB[0];
+  var indexB = 0;
+
+  // If A is deeper, skip indices that can't match.
+  if (pathALength - pathBLength > 0) {
+    indexA = pathALength - pathBLength;
+    itemA = pathA[indexA];
+    pathALength = pathBLength;
+  }
+
+  // If B is deeper, skip indices that can't match
+  if (pathBLength - pathALength > 0) {
+    indexB = pathBLength - pathALength;
+    itemB = pathB[indexB];
+    pathBLength = pathALength;
+  }
+
+  // Walk in lockstep until a match is found
+  var depth = pathALength;
+  while (depth--) {
+    if (itemA === itemB) {
+      return itemA;
+    }
+    itemA = pathA[indexA++];
+    itemB = pathB[indexB++];
+  }
+  return null;
+}
+
+/**
+ * Determine whether any of the active touches are within the current responder.
+ * This cannot rely on W3C `targetTouches`, as neither IE11 nor Safari implement it.
+ */
+export function hasTargetTouches(target, touches) {
+  if (!touches || touches.length === 0) {
+    return false;
+  }
+  for (var i = 0; i < touches.length; i++) {
+    var node = touches[i].target;
+    if (node != null) {
+      if (target.contains(node)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Ignore 'selectionchange' events that don't correspond with a person's intent to
+ * select text.
+ */
+export function hasValidSelection(domEvent) {
+  if (domEvent.type === 'selectionchange') {
+    return isSelectionValid();
+  }
+  return domEvent.type === 'select';
+}
+
+/**
+ * Events are only valid if the primary button was used without specific modifier keys.
+ */
+export function isPrimaryPointerDown(domEvent) {
+  var altKey = domEvent.altKey,
+    button = domEvent.button,
+    buttons = domEvent.buttons,
+    ctrlKey = domEvent.ctrlKey,
+    type = domEvent.type;
+  var isTouch = type === 'touchstart' || type === 'touchmove';
+  var isPrimaryMouseDown = type === 'mousedown' && (button === 0 || buttons === 1);
+  var isPrimaryMouseMove = type === 'mousemove' && buttons === 1;
+  var noModifiers = altKey === false && ctrlKey === false;
+  if (isTouch || isPrimaryMouseDown && noModifiers || isPrimaryMouseMove && noModifiers) {
+    return true;
+  }
+  return false;
+}

package/dist/modules/useResponderEvents/utils.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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 isSelectionValid from '../../modules/isSelectionValid';
+const keyName = '__reactResponderId';
+declare function getEventPath(domEvent: any): Array<any>;
+declare function composedPathFallback(target: any): Array<any>;
+/**
+ * Retrieve the responderId from a host node
+ */
+declare function getResponderId(node: any): ?number;
+/**
+ * Store the responderId on a host node
+ */
+declare export function setResponderId(node: any, id: number): any;
+/**
+ * Filter the event path to contain only the nodes attached to the responder system
+ */
+declare export function getResponderPaths(domEvent: any): {|
+  idPath: Array<number>,
+  nodePath: Array<any>,
+|};
+/**
+ * Walk the paths and find the first common ancestor
+ */
+declare export function getLowestCommonAncestor(pathA: Array<any>, pathB: Array<any>): any;
+/**
+ * Determine whether any of the active touches are within the current responder.
+ * This cannot rely on W3C `targetTouches`, as neither IE11 nor Safari implement it.
+ */
+declare export function hasTargetTouches(target: any, touches: any): boolean;
+/**
+ * Ignore 'selectionchange' events that don't correspond with a person's intent to
+ * select text.
+ */
+declare export function hasValidSelection(domEvent: any): boolean;
+/**
+ * Events are only valid if the primary button was used without specific modifier keys.
+ */
+declare export function isPrimaryPointerDown(domEvent: any): boolean;

package/dist/modules/useStable/index.js

@@ -0,0 +1,19 @@
+/**
+ * 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';
+var UNINITIALIZED = typeof Symbol === 'function' && typeof Symbol() === 'symbol' ? Symbol() : Object.freeze({});
+export default function useStable(getInitialValue) {
+  var ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = getInitialValue();
+  }
+  // $FlowFixMe (#64650789) Trouble refining types where `Symbol` is concerned.
+  return ref.current;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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 strict-local
+ */
+
+import * as React from 'react';
+const UNINITIALIZED = typeof Symbol === 'function' && typeof Symbol() === 'symbol' ? Symbol() : Object.freeze({});
+declare export default function useStable<T>(getInitialValue: () => T): T;

package/dist/modules/warnOnce/index.js

@@ -0,0 +1,27 @@
+/**
+ * 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 warnedKeys = {};
+
+/**
+ * A simple function that prints a warning message once per session.
+ *
+ * @param {string} key - The key used to ensure the message is printed once.
+ *                       This should be unique to the callsite.
+ * @param {string} message - The message to print
+ */
+export function warnOnce(key, message) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (warnedKeys[key]) {
+      return;
+    }
+    console.warn(message);
+    warnedKeys[key] = true;
+  }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * 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 strict
+ */
+
+const warnedKeys: {
+  [string]: boolean,
+  ...
+} = {};
+
+/**
+ * A simple function that prints a warning message once per session.
+ *
+ * @param {string} key - The key used to ensure the message is printed once.
+ *                       This should be unique to the callsite.
+ * @param {string} message - The message to print
+ */
+declare export function warnOnce(key: string, message: string): any;

package/dist/types/index.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+
+export type ColorValue = null | string;
+export type DimensionValue = null | number | string;
+export type EdgeInsetsValue = {|
+  top: number,
+  left: number,
+  right: number,
+  bottom: number,
+|};
+export type GenericStyleProp<+T> = null | void | $ReadOnly<T> | false | '' | $ReadOnlyArray<GenericStyleProp<T>>;
+export type LayoutValue = {
+  x: number,
+  y: number,
+  width: number,
+  height: number,
+};
+export type LayoutEvent = {
+  nativeEvent: {
+    layout: LayoutValue,
+    target: any,
+  },
+  timeStamp: number,
+};
+export type PointValue = {|
+  x: number,
+  y: number,
+|};
+type LayoutCallback = (x: number, y: number, width: number, height: number, left: number, top: number) => void;
+type MeasureInWindowCallback = (left: number, top: number, width: number, height: number) => void;
+
+// Mixin to HTMLElement that represents additions from the `usePlatformMethods` hook
+export interface PlatformMethods {
+  blur: () => void,
+  focus: () => void,
+  measure: (callback: LayoutCallback) => void,
+  measureInWindow: (callback: MeasureInWindowCallback) => void,
+  measureLayout: (relativeToNativeNode: {}, onSuccess: LayoutCallback, onFail: () => void) => void,
+}