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

package/dist/cjs/vendor/react-native/ReactNative/ReactNativeFeatureFlags.js

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+exports.__esModule = true;
+exports.default = void 0;
+var ReactNativeFeatureFlags = {
+  isLayoutAnimationEnabled: () => true,
+  shouldEmitW3CPointerEvents: () => false,
+  shouldPressibilityUseW3CPointerEventsForHover: () => false,
+  animatedShouldDebounceQueueFlush: () => false,
+  animatedShouldUseSingleOp: () => false
+};
+var _default = exports.default = ReactNativeFeatureFlags;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/SectionList/index.js

@@ -0,0 +1,150 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _Platform = _interopRequireDefault(require("../../../exports/Platform"));
+var React = _interopRequireWildcard(require("react"));
+var _VirtualizedSectionList = _interopRequireDefault(require("../VirtualizedSectionList"));
+var _excluded = ["stickySectionHeadersEnabled"];
+/**
+ * A performant interface for rendering sectioned lists, supporting the most handy features:
+ *
+ *  - Fully cross-platform.
+ *  - Configurable viewability callbacks.
+ *  - List header support.
+ *  - List footer support.
+ *  - Item separator support.
+ *  - Section header support.
+ *  - Section separator support.
+ *  - Heterogeneous data and item rendering support.
+ *  - Pull to Refresh.
+ *  - Scroll loading.
+ *
+ * If you don't need section support and want a simpler interface, use
+ * [`<FlatList>`](https://reactnative.dev/docs/flatlist).
+ *
+ * Simple Examples:
+ *
+ *     <SectionList
+ *       renderItem={({item}) => <ListItem title={item} />}
+ *       renderSectionHeader={({section}) => <Header title={section.title} />}
+ *       sections={[ // homogeneous rendering between sections
+ *         {data: [...], title: ...},
+ *         {data: [...], title: ...},
+ *         {data: [...], title: ...},
+ *       ]}
+ *     />
+ *
+ *     <SectionList
+ *       sections={[ // heterogeneous rendering between sections
+ *         {data: [...], renderItem: ...},
+ *         {data: [...], renderItem: ...},
+ *         {data: [...], renderItem: ...},
+ *       ]}
+ *     />
+ *
+ * This is a convenience wrapper around [`<VirtualizedList>`](docs/virtualizedlist),
+ * and thus inherits its props (as well as those of `ScrollView`) that aren't explicitly listed
+ * here, along with the following caveats:
+ *
+ * - Internal state is not preserved when content scrolls out of the render window. Make sure all
+ *   your data is captured in the item data or external stores like Flux, Redux, or Relay.
+ * - This is a `PureComponent` which means that it will not re-render if `props` remain shallow-
+ *   equal. Make sure that everything your `renderItem` function depends on is passed as a prop
+ *   (e.g. `extraData`) that is not `===` after updates, otherwise your UI may not update on
+ *   changes. This includes the `data` prop and parent component state.
+ * - In order to constrain memory and enable smooth scrolling, content is rendered asynchronously
+ *   offscreen. This means it's possible to scroll faster than the fill rate and momentarily see
+ *   blank content. This is a tradeoff that can be adjusted to suit the needs of each application,
+ *   and we are working on improving it behind the scenes.
+ * - By default, the list looks for a `key` prop on each item and uses that for the React key.
+ *   Alternatively, you can provide a custom `keyExtractor` prop.
+ *
+ */
+class SectionList extends React.PureComponent {
+  constructor() {
+    super(...arguments);
+    this._captureRef = ref => {
+      this._wrapperListRef = ref;
+    };
+  }
+  /**
+   * Scrolls to the item at the specified `sectionIndex` and `itemIndex` (within the section)
+   * positioned in the viewable area such that `viewPosition` 0 places it at the top (and may be
+   * covered by a sticky header), 1 at the bottom, and 0.5 centered in the middle. `viewOffset` is a
+   * fixed number of pixels to offset the final target position, e.g. to compensate for sticky
+   * headers.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToLocation(params) {
+    if (this._wrapperListRef != null) {
+      this._wrapperListRef.scrollToLocation(params);
+    }
+  }
+
+  /**
+   * Tells the list an interaction has occurred, which should trigger viewability calculations, e.g.
+   * if `waitForInteractions` is true and the user has not scrolled. This is typically called by
+   * taps on items or by navigation actions.
+   */
+  recordInteraction() {
+    var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    listRef && listRef.recordInteraction();
+  }
+
+  /**
+   * Displays the scroll indicators momentarily.
+   *
+   * @platform ios
+   */
+  flashScrollIndicators() {
+    var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    listRef && listRef.flashScrollIndicators();
+  }
+
+  /**
+   * Provides a handle to the underlying scroll responder.
+   */
+  getScrollResponder() {
+    var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    if (listRef) {
+      return listRef.getScrollResponder();
+    }
+  }
+  getScrollableNode() {
+    var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    if (listRef) {
+      return listRef.getScrollableNode();
+    }
+  }
+  render() {
+    var _this$props = this.props,
+      _stickySectionHeadersEnabled = _this$props.stickySectionHeadersEnabled,
+      restProps = (0, _objectWithoutPropertiesLoose2.default)(_this$props, _excluded);
+    var stickySectionHeadersEnabled = _stickySectionHeadersEnabled !== null && _stickySectionHeadersEnabled !== void 0 ? _stickySectionHeadersEnabled : _Platform.default.OS === 'ios';
+    return /*#__PURE__*/React.createElement(_VirtualizedSectionList.default, (0, _extends2.default)({}, restProps, {
+      stickySectionHeadersEnabled: stickySectionHeadersEnabled,
+      ref: this._captureRef,
+      getItemCount: items => items.length,
+      getItem: (items, index) => items[index]
+    }));
+  }
+}
+exports.default = SectionList;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/StaticContainer/index.js

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ *
+ * @format
+ * 
+ */
+
+'use strict';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+/**
+ * Renders static content efficiently by allowing React to short-circuit the
+ * reconciliation process. This component should be used when you know that a
+ * subtree of components will never need to be updated.
+ *
+ *   const someValue = ...; // We know for certain this value will never change.
+ *   return (
+ *     <StaticContainer>
+ *       <MyComponent value={someValue} />
+ *     </StaticContainer>
+ *   );
+ *
+ * Typically, you will not need to use this component and should opt for normal
+ * React reconciliation.
+ */
+
+class StaticContainer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return !!nextProps.shouldUpdate;
+  }
+  render() {
+    var child = this.props.children;
+    return child === null || child === false ? null : React.Children.only(child);
+  }
+}
+var _default = exports.default = StaticContainer;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/StaticRenderer/index.js

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * @format
+ * 
+ */
+
+'use strict';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+exports.__esModule = true;
+exports.default = void 0;
+var React = _interopRequireWildcard(require("react"));
+class StaticRenderer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return nextProps.shouldUpdate;
+  }
+  render() {
+    return this.props.render();
+  }
+}
+var _default = exports.default = StaticRenderer;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/TouchHistoryMath/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * 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.
+ *
+ * @format
+ */
+
+var TouchHistoryMath = {
+  /**
+   * This code is optimized and not intended to look beautiful. This allows
+   * computing of touch centroids that have moved after `touchesChangedAfter`
+   * timeStamp. You can compute the current centroid involving all touches
+   * moves after `touchesChangedAfter`, or you can compute the previous
+   * centroid of all touches that were moved after `touchesChangedAfter`.
+   *
+   * @param {TouchHistoryMath} touchHistory Standard Responder touch track
+   * data.
+   * @param {number} touchesChangedAfter timeStamp after which moved touches
+   * are considered "actively moving" - not just "active".
+   * @param {boolean} isXAxis Consider `x` dimension vs. `y` dimension.
+   * @param {boolean} ofCurrent Compute current centroid for actively moving
+   * touches vs. previous centroid of now actively moving touches.
+   * @return {number} value of centroid in specified dimension.
+   */
+  centroidDimension: function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+    var touchBank = touchHistory.touchBank;
+    var total = 0;
+    var count = 0;
+    var oneTouchData = touchHistory.numberActiveTouches === 1 ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+    if (oneTouchData !== null) {
+      if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {
+        total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY;
+        count = 1;
+      }
+    } else {
+      for (var i = 0; i < touchBank.length; i++) {
+        var touchTrack = touchBank[i];
+        if (touchTrack !== null && touchTrack !== undefined && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+          var toAdd = void 0; // Yuck, program temporarily in invalid state.
+          if (ofCurrent && isXAxis) {
+            toAdd = touchTrack.currentPageX;
+          } else if (ofCurrent && !isXAxis) {
+            toAdd = touchTrack.currentPageY;
+          } else if (!ofCurrent && isXAxis) {
+            toAdd = touchTrack.previousPageX;
+          } else {
+            toAdd = touchTrack.previousPageY;
+          }
+          total += toAdd;
+          count++;
+        }
+      }
+    }
+    return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+  },
+  currentCentroidXOfTouchesChangedAfter: function currentCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true,
+    // isXAxis
+    true // ofCurrent
+    );
+  },
+  currentCentroidYOfTouchesChangedAfter: function currentCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false,
+    // isXAxis
+    true // ofCurrent
+    );
+  },
+  previousCentroidXOfTouchesChangedAfter: function previousCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true,
+    // isXAxis
+    false // ofCurrent
+    );
+  },
+  previousCentroidYOfTouchesChangedAfter: function previousCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+    return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false,
+    // isXAxis
+    false // ofCurrent
+    );
+  },
+  currentCentroidX: function currentCentroidX(touchHistory) {
+    return TouchHistoryMath.centroidDimension(touchHistory, 0,
+    // touchesChangedAfter
+    true,
+    // isXAxis
+    true // ofCurrent
+    );
+  },
+  currentCentroidY: function currentCentroidY(touchHistory) {
+    return TouchHistoryMath.centroidDimension(touchHistory, 0,
+    // touchesChangedAfter
+    false,
+    // isXAxis
+    true // ofCurrent
+    );
+  },
+  noCentroid: -1
+};
+var _default = exports.default = TouchHistoryMath;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/TurboModule/RCTExport.js

@@ -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.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+/**
+ * NOTE: This is React Native specific export type.
+ *
+ * RCTExport is an interface type that allows native code generation for React
+ * Native native modules. It exists as a hint to the codegen tool that any
+ * interface that extends it needs to be codegen'ed. Example usage:
+ *
+ *   export interface RCTFoobar extends RCTExport<void> {}
+ *
+ * Native definition for RCTFoobar will then be generated.
+ *
+ * The type param T is a placeholder for future codegen hinting, like versioning
+ * information, native base classes, etc. For now, simply use `void` type as
+ * there's nothing to give hint about.
+ */
+
+// eslint-disable-next-line no-unused-vars

package/dist/cjs/vendor/react-native/TurboModule/TurboModuleRegistry.js

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.get = get;
+exports.getEnforcing = getEnforcing;
+var _invariant = _interopRequireDefault(require("fbjs/lib/invariant"));
+function get(name) {
+  return null;
+}
+function getEnforcing(name) {
+  var module = get(name);
+  (0, _invariant.default)(module != null, "TurboModuleRegistry.getEnforcing(...): '" + name + "' could not be found. " + 'Verify that a module by this name is registered in the native binary.');
+  return module;
+}

package/dist/cjs/vendor/react-native/Types/CoreEventTypes.js

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+'use strict';

package/dist/cjs/vendor/react-native/Utilities/Platform.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _Platform = _interopRequireDefault(require("../../../exports/Platform"));
+var _default = exports.default = _Platform.default;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Utilities/clamp.js

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @format
+ * 
+ */
+
+'use strict';
+
+exports.__esModule = true;
+exports.default = void 0;
+function clamp(min, value, max) {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+var _default = exports.default = clamp;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Utilities/setAndForwardRef.js

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * @format
+ * 
+ */
+
+'use strict';
+
+exports.__esModule = true;
+exports.default = void 0;
+/**
+ * This is a helper function for when a component needs to be able to forward a ref
+ * to a child component, but still needs to have access to that component as part of
+ * its implementation.
+ *
+ * Its main use case is in wrappers for native components.
+ *
+ * Usage:
+ *
+ *   class MyView extends React.Component {
+ *     _nativeRef = null;
+ *
+ *     _setNativeRef = setAndForwardRef({
+ *       getForwardedRef: () => this.props.forwardedRef,
+ *       setLocalRef: ref => {
+ *         this._nativeRef = ref;
+ *       },
+ *     });
+ *
+ *     render() {
+ *       return <View ref={this._setNativeRef} />;
+ *     }
+ *   }
+ *
+ *   const MyViewWithRef = React.forwardRef((props, ref) => (
+ *     <MyView {...props} forwardedRef={ref} />
+ *   ));
+ *
+ *   module.exports = MyViewWithRef;
+ */
+
+function setAndForwardRef(_ref) {
+  var getForwardedRef = _ref.getForwardedRef,
+    setLocalRef = _ref.setLocalRef;
+  return function forwardRef(ref) {
+    var forwardedRef = getForwardedRef();
+    setLocalRef(ref);
+
+    // Forward to user ref prop (if one has been specified)
+    if (typeof forwardedRef === 'function') {
+      // Handle function-based refs. String-based refs are handled as functions.
+      forwardedRef(ref);
+    } else if (typeof forwardedRef === 'object' && forwardedRef != null) {
+      // Handle createRef-based refs
+      forwardedRef.current = ref;
+    }
+  };
+}
+var _default = exports.default = setAndForwardRef;
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Utilities/useMergeRefs.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useMergeRefs;
+var _react = require("react");
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+/**
+ * Constructs a new ref that forwards new values to each of the given refs. The
+ * given refs will always be invoked in the order that they are supplied.
+ *
+ * WARNING: A known problem of merging refs using this approach is that if any
+ * of the given refs change, the returned callback ref will also be changed. If
+ * the returned callback ref is supplied as a `ref` to a React element, this may
+ * lead to problems with the given refs being invoked more times than desired.
+ */
+function useMergeRefs() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  return (0, _react.useCallback)(current => {
+    for (var _i = 0, _refs = refs; _i < _refs.length; _i++) {
+      var ref = _refs[_i];
+      if (ref != null) {
+        if (typeof ref === 'function') {
+          ref(current);
+        } else {
+          ref.current = current;
+        }
+      }
+    }
+  }, [...refs] // eslint-disable-line react-hooks/exhaustive-deps
+  );
+}
+module.exports = exports.default;

package/dist/cjs/vendor/react-native/Utilities/useRefEffect.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useRefEffect;
+var _react = require("react");
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+
+/**
+ * Constructs a callback ref that provides similar semantics as `useEffect`. The
+ * supplied `effect` callback will be called with non-null component instances.
+ * The `effect` callback can also optionally return a cleanup function.
+ *
+ * When a component is updated or unmounted, the cleanup function is called. The
+ * `effect` callback will then be called again, if applicable.
+ *
+ * When a new `effect` callback is supplied, the previously returned cleanup
+ * function will be called before the new `effect` callback is called with the
+ * same instance.
+ *
+ * WARNING: The `effect` callback should be stable (e.g. using `useCallback`).
+ */
+function useRefEffect(effect) {
+  var cleanupRef = (0, _react.useRef)(undefined);
+  return (0, _react.useCallback)(instance => {
+    if (cleanupRef.current) {
+      cleanupRef.current();
+      cleanupRef.current = undefined;
+    }
+    if (instance != null) {
+      cleanupRef.current = effect(instance);
+    }
+  }, [effect]);
+}
+module.exports = exports.default;